diff --git a/CMakeLists.txt b/CMakeLists.txt index fd731f9a7896cfebf6d49a81eba7bd93c5c78da6..3b077b8d7681ce5beee3bc66b2e03d47206662e1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,7 +29,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}") include_directories(include) -set (BIOEM_ICC_FLAGS "-xHost -O3 -fno-alias -fno-fnalias -unroll -g0 -ipo") +set (BIOEM_ICC_FLAGS "-O3 -fno-alias -fno-fnalias -unroll -g0 -ip") set (BIOEM_GCC_FLAGS "-O3 -march=native -fweb -mfpmath=sse -frename-registers -minline-all-stringops -ftracer -funroll-loops -fpeel-loops -fprefetch-loop-arrays -ffast-math -ggdb") if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel") @@ -50,11 +50,6 @@ if (NOT FFTW_FOUND) endif() include_directories(${FFTW_INCLUDE_DIRS}) -find_package( Boost 1.43 REQUIRED COMPONENTS program_options ) -include_directories( ${Boost_INCLUDE_DIRS} ) - - - ###Find Optional Packages ###Find CUDA @@ -163,7 +158,6 @@ if (FFTWF_LIBRARIES) else() target_link_libraries(bioEM -L${FFTW_LIBDIR} -lfftw3 -lfftw3f) endif() -target_link_libraries(bioEM ${Boost_PROGRAM_OPTIONS_LIBRARY}) if (MPI_FOUND) target_link_libraries(bioEM ${MPI_LIBRARIES}) @@ -172,7 +166,6 @@ endif() ###Show Status message(STATUS "Build Status") message(STATUS "FFTW library: ${FFTW_LIBDIR}") -message(STATUS "Boost directory: ${Boost_LIBRARY_DIRS}") message(STATUS "FFTW includedir: ${FFTW_INCLUDEDIR}") message(STATUS "CUDA libraries: ${CUDA_CUDA_LIBRARY}") message(STATUS "CUDART libraries: ${CUDA_LIBRARIES}") diff --git a/autotuner.cpp b/autotuner.cpp index 125fc6c651579f8c0259a773a1326d410a716273..c31cd427d4ce7e6116e23a9390d39647356609c3 100644 --- a/autotuner.cpp +++ b/autotuner.cpp @@ -1,3 +1,15 @@ +/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + < BioEM software for Bayesian inference of Electron Microscopy images> + Copyright (C) 2017 Pilar Cossio, Markus Rampp, Luka Stanisic and Gerhard + Hummer. + Max Planck Institute of Biophysics, Frankfurt, Germany. + Max Planck Computing and Data Facility, Garching, Germany. + + Released under the GNU Public License, v3. + See license statement for terms of distribution. + + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + #include "autotuner.h" void Autotuner::Reset() @@ -16,64 +28,75 @@ void Autotuner::Reset() fb = 0.; fx = 0.; - if (algo == 3) workload = 50; + if (algo == 3) + workload = 50; } bool Autotuner::Needed(int iteration) { - if (stopTuning) return false; + if (stopTuning) + return false; switch (algo) - { + { case 1: case 3: return iteration % (stable + 1) == stable; - case 2: return (iteration == (int) stable / 2 ) || (iteration == stable); + case 2: + return (iteration == (int) stable / 2) || (iteration == stable); default: /* Should never happen */; - } + } return false; } bool Autotuner::Finished() { switch (algo) - { + { case 1: if (workload < 30) - { - workload = best_workload; - return stopTuning = true; - } + { + workload = best_workload; + return stopTuning = true; + } break; case 2: - if (best_workload != 0) return stopTuning = true; + if (best_workload != 0) + return stopTuning = true; break; case 3: - if ((c - b == limit) && (b - a == limit)) return stopTuning = true; + if ((c - b == limit) && (b - a == limit)) + return stopTuning = true; break; default: /* Should never happen */; - } + } return false; } void Autotuner::Tune(double compTime) { switch (algo) - { - case 1: AlgoSimple(compTime); break; - case 2: AlgoRatio(compTime); break; - case 3: AlgoBisection(compTime); break; + { + case 1: + AlgoSimple(compTime); + break; + case 2: + AlgoRatio(compTime); + break; + case 3: + AlgoBisection(compTime); + break; default: /* Should never happen */; - } + } } void Autotuner::AlgoSimple(double compTime) { if (best_time == 0. || compTime < best_time) - { - best_time = compTime; - best_workload = workload; - } + { + best_time = compTime; + best_workload = workload; + } workload -= 5; } @@ -81,46 +104,46 @@ void Autotuner::AlgoSimple(double compTime) void Autotuner::AlgoRatio(double compTime) { if (best_time == 0.) - { - best_time = compTime; - workload = 1; - } + { + best_time = compTime; + workload = 1; + } else - { - best_workload = (int) 100 * (compTime / (best_time + compTime)); - workload = best_workload; - } + { + best_workload = (int) 100 * (compTime / (best_time + compTime)); + workload = best_workload; + } } void Autotuner::AlgoBisection(double compTime) { if (fb == 0.) - { - fb = compTime; - x = 75; - workload = x; - return; - } + { + fb = compTime; + x = 75; + workload = x; + return; + } fx = compTime; if (fx < fb) - { - if (x < b) - c = b; - else - a = b; - b = x; - fb = fx; - } + { + if (x < b) + c = b; + else + a = b; + b = x; + fb = fx; + } else - { - if (x < b) - a = x; - else - c = x; - } - - x = (c-b > b-a) ? (int)(b+(c-b)/2) : (int)(a+(b-a+1)/2); + { + if (x < b) + a = x; + else + c = x; + } + + x = (c - b > b - a) ? (int) (b + (c - b) / 2) : (int) (a + (b - a + 1) / 2); workload = x; } diff --git a/bioem.cpp b/bioem.cpp index 8b5d284dd4017df08d3a40dfd01022681bb6b547..1cf3cd02b2b1df89836a110a01fe46eaf7b41b6b 100644 --- a/bioem.cpp +++ b/bioem.cpp @@ -1,414 +1,538 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. - + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + #ifdef WITH_MPI #include -#define MPI_CHK(expr) \ - if (expr != MPI_SUCCESS) \ - { \ - fprintf(stderr, "Error in MPI function %s: %d\n", __FILE__, __LINE__); \ - } +#define MPI_CHK(expr) \ + if (expr != MPI_SUCCESS) \ + { \ + fprintf(stderr, "Error in MPI function %s: %d\n", __FILE__, __LINE__); \ + } #endif +#include "MersenneTwister.h" +#include +#include #include -#include -#include -#include -#include +#include #include -#include #include +#include #include #include +#include #include -#include +#include #ifdef WITH_OPENMP #include #endif +#include "autotuner.h" +#include "timer.h" #include #include -#include "timer.h" -#include "autotuner.h" -#include "param.h" #include "bioem.h" -#include "model.h" #include "map.h" +#include "model.h" +#include "param.h" #ifdef BIOEM_USE_NVTX #include "nvToolsExt.h" -const uint32_t colors[] = { 0x0000ff00, 0x000000ff, 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x00ff0000, 0x00ffffff }; -const int num_colors = sizeof(colors)/sizeof(colors[0]); -enum myColor { COLOR_PROJECTION, COLOR_CONVOLUTION, COLOR_COMPARISON, COLOR_WORKLOAD, COLOR_INIT }; +const uint32_t colors[] = {0x0000ff00, 0x000000ff, 0x00ffff00, 0x00ff00ff, + 0x0000ffff, 0x00ff0000, 0x00ffffff}; +const int num_colors = sizeof(colors) / sizeof(colors[0]); +enum myColor +{ + COLOR_PROJECTION, + COLOR_CONVOLUTION, + COLOR_COMPARISON, + COLOR_WORKLOAD, + COLOR_INIT +}; // Projection number is stored in category attribute // Convolution number is stored in payload attribute -#define cuda_custom_timeslot(name,iMap,iConv,cid) { \ - int color_id = cid; \ - color_id = color_id%num_colors; \ - nvtxEventAttributes_t eventAttrib = {0}; \ - eventAttrib.version = NVTX_VERSION; \ - eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; \ - eventAttrib.colorType = NVTX_COLOR_ARGB; \ - eventAttrib.color = colors[color_id]; \ - eventAttrib.category = iMap; \ - eventAttrib.payloadType = NVTX_PAYLOAD_TYPE_UNSIGNED_INT64; \ - eventAttrib.payload.llValue = iConv; \ - eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; \ - eventAttrib.message.ascii = name; \ - nvtxRangePushEx(&eventAttrib); \ +#define cuda_custom_timeslot(name, iMap, iConv, cid) \ + { \ + int color_id = cid; \ + color_id = color_id % num_colors; \ + nvtxEventAttributes_t eventAttrib = {0}; \ + eventAttrib.version = NVTX_VERSION; \ + eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE; \ + eventAttrib.colorType = NVTX_COLOR_ARGB; \ + eventAttrib.color = colors[color_id]; \ + eventAttrib.category = iMap; \ + eventAttrib.payloadType = NVTX_PAYLOAD_TYPE_UNSIGNED_INT64; \ + eventAttrib.payload.llValue = iConv; \ + eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII; \ + eventAttrib.message.ascii = name; \ + nvtxRangePushEx(&eventAttrib); \ } #define cuda_custom_timeslot_end nvtxRangePop(); #else -#define cuda_custom_timeslot(name,iMap,iConv,cid) +#define cuda_custom_timeslot(name, iMap, iConv, cid) #define cuda_custom_timeslot_end #endif #include "bioem_algorithm.h" -using namespace boost; -namespace po = boost::program_options; -namespace bran= boost::random; - using namespace std; -/* For dvl nodes in hydra with problem in boost - namespace std { - typedef decltype(nullptr) nullptr_t; - }*/ - -// A helper function of Boost -template -ostream& operator<<(ostream& os, const vector& v) -{ - copy(v.begin(), v.end(), ostream_iterator(os, " ")); - return os; -} - bioem::bioem() { - FFTAlgo = getenv("FFTALGO") == NULL ? 1 : atoi(getenv("FFTALGO")); - DebugOutput = getenv("BIOEM_DEBUG_OUTPUT") == NULL ? 0 : atoi(getenv("BIOEM_DEBUG_OUTPUT")); - nProjectionsAtOnce = getenv("BIOEM_PROJECTIONS_AT_ONCE") == NULL ? 1 : atoi(getenv("BIOEM_PROJECTIONS_AT_ONCE")); + BioEMAlgo = getenv("BIOEM_ALGO") == NULL ? 1 : atoi(getenv("BIOEM_ALGO")); + + DebugOutput = getenv("BIOEM_DEBUG_OUTPUT") == NULL ? + 0 : + atoi(getenv("BIOEM_DEBUG_OUTPUT")); + + if (getenv("BIOEM_PROJ_CONV_AT_ONCE") != NULL) + { + nProjectionsAtOnce = atoi(getenv("BIOEM_PROJ_CONV_AT_ONCE")); + if (BioEMAlgo == 1 && getenv("GPU") && atoi(getenv("GPU")) && + nProjectionsAtOnce > 1) + { + printf("Warning: using parallel convolutions with GPUs can create race " + "condition and lead to inaccurate results. " + "BIOEM_PROJ_CONV_AT_ONCE is going to be set 1.\n"); + nProjectionsAtOnce = 1; + } + } + else if (BioEMAlgo == 1) + nProjectionsAtOnce = 1; + else + nProjectionsAtOnce = + getenv("OMP_NUM_THREADS") == NULL ? 1 : atoi(getenv("OMP_NUM_THREADS")); + + if (getenv("BIOEM_CUDA_THREAD_COUNT") != NULL) + CudaThreadCount = atoi(getenv("BIOEM_CUDA_THREAD_COUNT")); + else if (BioEMAlgo == 1) + CudaThreadCount = CUDA_THREAD_COUNT_ALGO1; + else + CudaThreadCount = CUDA_THREAD_COUNT_ALGO2; + Autotuning = false; } -bioem::~bioem() +bioem::~bioem() {} + +void bioem::printOptions(myoption_t *myoptions, int myoptions_length) { + printf("\nCommand line inputs:\n"); + + // Find longest column width + int maxlen = 0; + for (int i = 0; i < myoptions_length; i++) + { + if (myoptions[i].hidden) + continue; + if (maxlen < strlen(myoptions[i].name)) + maxlen = strlen(myoptions[i].name); + } + + for (int i = 0; i < myoptions_length; i++) + { + if (myoptions[i].hidden) + continue; + printf(" --%-*s", maxlen, myoptions[i].name); + if (myoptions[i].arg == required_argument) + printf(" arg"); + else + printf(" "); + printf(" %s\n", myoptions[i].desc); + } + printf("\n"); } -int bioem::configure(int ac, char* av[]) +int bioem::readOptions(int ac, char *av[]) { - // ************************************************************************************** - // **** Configuration Routine using boost for extracting parameters, models and maps **** - // ************************************************************************************** - // ****** And Precalculating necessary grids, map crosscorrelations and kernels ******** - // ************************************************************************************* - HighResTimer timer; + // *** Inizialzing default variables *** + std::string infile, modelfile, mapfile, Inputanglefile, Inputbestmap; + Model.readPDB = false; + param.param_device.writeAngles = 0; + param.dumpMap = false; + param.loadMap = false; + param.printModel = false; + RefMap.readMRC = false; + RefMap.readMultMRC = false; + param.notuniformangles = false; + OutfileName = "Output_Probabilities"; + + cout << " ++++++++++++ FROM COMMAND LINE +++++++++++\n\n"; + + // Write your options here + myoption_t myoptions[] = { + {"Modelfile", required_argument, "(Mandatory) Name of model file", false}, + {"Particlesfile", required_argument, + "(Mandatory) Name of particle-image file", false}, + {"Inputfile", required_argument, + "(Mandatory) Name of input parameter file", false}, + {"PrintBestCalMap", required_argument, + "(Optional) Only print best calculated map. NO BioEM!", true}, + {"ReadOrientation", required_argument, + "(Optional) Read file name containing orientations", false}, + {"ReadPDB", no_argument, "(Optional) If reading model file in PDB format", + false}, + {"ReadMRC", no_argument, + "(Optional) If reading particle file in MRC format", false}, + {"ReadMultipleMRC", no_argument, "(Optional) If reading Multiple MRCs", + false}, + {"DumpMaps", no_argument, + "(Optional) Dump maps after they were read from particle-image file", + false}, + {"LoadMapDump", no_argument, "(Optional) Read Maps from dump option", + false}, + {"OutputFile", required_argument, + "(Optional) For changing the outputfile name", false}, + {"help", no_argument, "(Optional) Produce help message", false}}; + int myoptions_length = sizeof(myoptions) / sizeof(myoption_t); + + // If not all Mandatory parameters are defined + if ((ac < 2)) + { + printf("Error: Need to specify all mandatory options\n"); + printOptions(myoptions, myoptions_length); + return 1; + } + // Creating options structure for getopt_long() + struct option *long_options = + (option *) calloc((myoptions_length + 1), sizeof(option)); + for (int i = 0; i < myoptions_length; i++) + { + long_options[i].name = myoptions[i].name; + long_options[i].has_arg = myoptions[i].arg; + } - std::string infile, modelfile, mapfile,Inputanglefile,Inputbestmap; - if (mpi_rank == 0) - { - // *** Inizialzing default variables *** - std::string infile, modelfile, mapfile,Inputanglefile,Inputbestmap; - Model.readPDB = false; - param.param_device.writeAngles = false; - param.dumpMap = false; - param.loadMap = false; - RefMap.readMRC = false; - RefMap.readMultMRC = false; - param.notuniformangles=false; - yesoutfilename=false; - - // ************************************************************************************* - cout << " ++++++++++++ FROM COMMAND LINE +++++++++++\n\n"; - // ************************************************************************************* - - // ********************* Command line reading input with BOOST ************************ - - try { - po::options_description desc("Command line inputs"); - desc.add_options() - ("Modelfile", po::value< std::string>() , "(Mandatory) Name of model file") - ("Particlesfile", po::value< std::string>(), "if BioEM (Mandatory) Name of particle-image file") - ("Inputfile", po::value(), "if BioEM (Mandatory) Name of input parameter file") - ("PrintBestCalMap", po::value< std::string>(), "(Optional) Only print best calculated map. NO BioEM (!)") - ("ReadOrientation", po::value< std::string>(), "(Optional) Read file name containing orientations") - ("ReadPDB", "(Optional) If reading model file in PDB format") - ("ReadMRC", "(Optional) If reading particle file in MRC format") - ("ReadMultipleMRC", "(Optional) If reading Multiple MRCs") - ("DumpMaps", "(Optional) Dump maps after they were read from particle-image file") - ("LoadMapDump", "(Optional) Read Maps from dump option") - ("OutputFile", po::value< std::string>(), "(Optional) For changing the outputfile name") - ("help", "(Optional) Produce help message") - ; - - - po::positional_options_description p; - p.add("Inputfile", -1); - p.add("Modelfile", -1); - p.add("Particlesfile", -1); - p.add("ReadPDB", -1); - p.add("ReadMRC", -1); - p.add("ReadMultipleMRC", -1); - p.add("ReadOrientation",-1); - p.add("PrintBestCalMap",-1); - p.add("DumpMaps", -1); - p.add("LoadMapDump", -1); - p.add("OutputFile",-1); - - po::variables_map vm; - po::store(po::command_line_parser(ac, av). - options(desc).positional(p).run(), vm); - po::notify(vm); - - if((ac < 4)) { - std::cout << desc << std::endl; - return 1; - } - if (vm.count("help")) { - cout << "Usage: options_description [options]\n"; - cout << desc; - return 1; - } - - if (vm.count("Inputfile")) - { - cout << "Input file is: "; - cout << vm["Inputfile"].as< std::string >() << "\n"; - infile = vm["Inputfile"].as< std::string >(); - } - if (vm.count("Modelfile")) - { - cout << "Model file is: " - << vm["Modelfile"].as< std::string >() << "\n"; - modelfile = vm["Modelfile"].as< std::string >(); - } - if (vm.count("ReadPDB")) - { - cout << "Reading model file in PDB format.\n"; - Model.readPDB = true; - } - if (vm.count("ReadOrientation")) - { - cout << "Reading Orientation from file: " - << vm["ReadOrientation"].as< std::string >() << "\n"; - cout << "Important! if using Quaternions, include \n"; - cout << "QUATERNIONS keyword in INPUT PARAMETER FILE\n"; - cout << "First row in file should be the total number of orientations (int)\n"; - cout << "Euler angle format should be alpha (12.6f) beta (12.6f) gamma (12.6f)\n"; - cout << "Quaternion format q1 (12.6f) q2 (12.6f) q3 (12.6f) q4 (12.6f)\n"; - Inputanglefile = vm["ReadOrientation"].as< std::string >(); - param.notuniformangles=true; - } - if (vm.count("OutputFile")) - { - OutfileName = vm["OutputFile"].as< std::string >(); - cout << "Writing OUTPUT to: " << vm["OutputFile"].as< std::string >() << "\n"; - yesoutfilename=true; - } - if (vm.count("PrintBestCalMap")) - { - cout << "Reading Euler Angles from file: " - << vm["PrintBestCalMap"].as< std::string >() << "\n"; - Inputbestmap = vm["PrintBestCalMap"].as< std::string >(); - param.printModel=true; - } - - if (vm.count("ReadMRC")) - { - cout << "Reading particle file in MRC format.\n"; - RefMap.readMRC=true; - } - - if (vm.count("ReadMultipleMRC")) - { - cout << "Reading Multiple MRCs.\n"; - RefMap.readMultMRC=true; - } - - if (vm.count("DumpMaps")) - { - cout << "Dumping Maps after reading from file.\n"; - param.dumpMap = true; - } - - if (vm.count("LoadMapDump")) - { - cout << "Loading Map dump.\n"; - param.loadMap = true; - } - - if (vm.count("Particlesfile")) - { - cout << "Paricle file is: " - << vm["Particlesfile"].as< std::string >() << "\n"; - mapfile = vm["Particlesfile"].as< std::string >(); - } - } - catch(std::exception& e) - { - cout << e.what() << "\n"; - return 1; - } - - //check for consitency in multiple MRCs - if(RefMap.readMultMRC && not(RefMap.readMRC)) - { - cout << "For Multiple MRCs command --ReadMRC is necesary too"; - exit(1); - } - - if(!Model.readPDB){ - cout << "Note: Reading model in simple text format (not PDB)\n"; - cout << "---- x y z radius density ------- \n"; - } - - if (DebugOutput >= 2 && mpi_rank == 0) timer.ResetStart(); - // ********************* Reading Parameter Input *************************** - if(!param.printModel){ - // Standard definition for BioEM - param.readParameters(infile.c_str()); - - // ********************* Reading Particle Maps Input ********************** - RefMap.readRefMaps(param, mapfile.c_str()); - - - } else{ - // Reading parameters for only writting down Best projection - - param.forprintBest(Inputbestmap.c_str()); - } - - // ********************* Reading Model Input ****************************** - Model.readModel(param, modelfile.c_str()); - - cout << "**NOTE:: look at file COORDREAD to confirm that the Model coordinates are correct\n"; - - if (DebugOutput >= 2 && mpi_rank == 0) printf("Reading Input Data Time: %f\n", timer.GetCurrentElapsedTime()); - - if(param.param_device.writeCC && mpi_size>1){ - cout << "Exiting::: WRITE CROSS-CORRELATION ONLY VAILD FOR 1 MPI PROCESS\n"; - exit(1); - } + int myopt; + while (1) + { + /* getopt_long stores the option index here. */ + int option_index = 0; + myopt = getopt_long(ac, av, "", long_options, &option_index); + + /* Detect the end of the options. */ + if (myopt == -1) + break; - // Generating Grids of orientations - if(!param.printModel)param.CalculateGridsParam(Inputanglefile.c_str()); + switch (myopt) + { + case 0: +#ifdef DEBUG + printf("option %s", long_options[option_index].name); + if (optarg) + printf(" with arg %s", optarg); + printf("\n"); +#endif + // Here write actions for each option + if (!strcmp(long_options[option_index].name, "help")) + { + cout << "Usage: options_description [options]\n"; + printOptions(myoptions, myoptions_length); + return 1; + } + if (!strcmp(long_options[option_index].name, "Inputfile")) + { + cout << "Input file is: " << optarg << "\n"; + infile = optarg; + } + if (!strcmp(long_options[option_index].name, "Modelfile")) + { + cout << "Model file is: " << optarg << "\n"; + modelfile = optarg; + } + if (!strcmp(long_options[option_index].name, "ReadPDB")) + { + cout << "Reading model file in PDB format.\n"; + Model.readPDB = true; + } + if (!strcmp(long_options[option_index].name, "ReadOrientation")) + { + cout << "Reading Orientation from file: " << optarg << "\n"; + cout << "Important! if using Quaternions, include \n"; + cout << "QUATERNIONS keyword in INPUT PARAMETER FILE\n"; + cout << "First row in file should be the total number of " + "orientations " + "(int)\n"; + cout << "Euler angle format should be alpha (12.6f) beta (12.6f) " + "gamma (12.6f)\n"; + cout << "Quaternion format q1 (12.6f) q2 (12.6f) q3 (12.6f) q4 " + "(12.6f)\n"; + Inputanglefile = optarg; + param.notuniformangles = true; + } + if (!strcmp(long_options[option_index].name, "OutputFile")) + { + cout << "Writing OUTPUT to: " << optarg << "\n"; + OutfileName = optarg; + } + if (!strcmp(long_options[option_index].name, "PrintBestCalMap")) + { + cout << "Reading Best Parameters from file: " << optarg << "\n"; + Inputbestmap = optarg; + param.printModel = true; + } + if (!strcmp(long_options[option_index].name, "ReadMRC")) + { + cout << "Reading particle file in MRC format.\n"; + RefMap.readMRC = true; + } + if (!strcmp(long_options[option_index].name, "ReadMultipleMRC")) + { + cout << "Reading Multiple MRCs.\n"; + RefMap.readMultMRC = true; + } + if (!strcmp(long_options[option_index].name, "DumpMaps")) + { + cout << "Dumping Maps after reading from file.\n"; + param.dumpMap = true; + } + if (!strcmp(long_options[option_index].name, "LoadMapDump")) + { + cout << "Loading Map dump.\n"; + param.loadMap = true; + } + if (!strcmp(long_options[option_index].name, "Particlesfile")) + { + cout << "Particle file is: " << optarg << "\n"; + mapfile = optarg; + } + break; + case '?': + /* getopt_long already printed an error message. */ + printOptions(myoptions, myoptions_length); + return 1; + default: + abort(); } + } + /* Print any remaining command line arguments (not options) and exit */ + if (optind < ac) + { + printf("Error: non-option ARGV-elements: "); + while (optind < ac) + printf("%s ", av[optind++]); + putchar('\n'); + printOptions(myoptions, myoptions_length); + return 1; + } -#ifdef WITH_MPI + // check for consitency in multiple MRCs + if (RefMap.readMultMRC && not(RefMap.readMRC)) + { + cout << "For Multiple MRCs command --ReadMRC is necesary too"; + exit(1); + } + if (!Model.readPDB) + { + cout << "Note: Reading model in simple text format (not PDB)\n"; + cout << "---- x y z radius density ------- \n"; + } + if (DebugOutput >= 2 && mpi_rank == 0) + timer.ResetStart(); - // ********************* MPI inizialization/ Transfer of parameters****************** - if (mpi_size > 1) - { - if (DebugOutput >= 2 && mpi_rank == 0) timer.ResetStart(); - MPI_Bcast(¶m, sizeof(param), MPI_BYTE, 0, MPI_COMM_WORLD); - //We have to reinitialize all pointers !!!!!!!!!!!! - if (mpi_rank != 0) param.angprior = NULL; + // *** Reading Parameter Input *** + if (!param.printModel) + { + // Standard definition for BioEM + param.readParameters(infile.c_str()); + // *** Reading Particle Maps Input *** + RefMap.readRefMaps(param, mapfile.c_str()); + } + else + { + // Reading parameters for only writting down Best projection + param.forprintBest(Inputbestmap.c_str()); + } - if (mpi_rank != 0)param.angles = (myfloat3_t*) mallocchk(param.nTotGridAngles * sizeof (myfloat3_t)); - MPI_Bcast(param.angles, param.nTotGridAngles * sizeof (myfloat3_t),MPI_BYTE, 0, MPI_COMM_WORLD); + // *** Reading Model Input *** + Model.readModel(param, modelfile.c_str()); -#ifdef DEBUG - for(int n=0;n= 2 && mpi_rank == 0) + printf("Reading Input Data Time: %f\n", timer.GetCurrentElapsedTime()); + + // Generating Grids of orientations + if (!param.printModel) + param.CalculateGridsParam(Inputanglefile.c_str()); + + return (0); +} + +int bioem::configure(int ac, char *av[]) +{ + // ************************************************************************************** + // **** Configuration Routine using getopts for extracting parameters, models + // and maps **** + // ************************************************************************************** + // ****** And Precalculating necessary grids, map crosscorrelations and + // kernels ******** + // ************************************************************************************* + + HighResTimer timer; + + if (mpi_rank == 0 && readOptions(ac, av)) + return 1; + +#ifdef WITH_MPI - MPI_Bcast(&Model, sizeof(Model), MPI_BYTE, 0, MPI_COMM_WORLD); - if (mpi_rank != 0) Model.points = (bioem_model::bioem_model_point*) mallocchk(sizeof(bioem_model::bioem_model_point) * Model.nPointsModel); - MPI_Bcast(Model.points, sizeof(bioem_model::bioem_model_point) * Model.nPointsModel, MPI_BYTE, 0, MPI_COMM_WORLD); + // ********************* MPI inizialization/ Transfer of + // parameters****************** + if (mpi_size > 1) + { + if (DebugOutput >= 2 && mpi_rank == 0) + timer.ResetStart(); + MPI_Bcast(¶m, sizeof(param), MPI_BYTE, 0, MPI_COMM_WORLD); + // We have to reinitialize all pointers !!!!!!!!!!!! + if (mpi_rank != 0) + param.angprior = NULL; - MPI_Bcast(&RefMap, sizeof(RefMap), MPI_BYTE, 0, MPI_COMM_WORLD); - if (mpi_rank != 0) RefMap.maps = (myfloat_t*) mallocchk(RefMap.refMapSize * sizeof(myfloat_t) * RefMap.ntotRefMap); - MPI_Bcast(RefMap.maps, RefMap.refMapSize * sizeof(myfloat_t) * RefMap.ntotRefMap, MPI_BYTE, 0, MPI_COMM_WORLD); - if (DebugOutput >= 2 && mpi_rank == 0) printf("MPI Broadcast of Input Data %f\n", timer.GetCurrentElapsedTime()); + if (mpi_rank != 0) + param.angles = + (myfloat3_t *) mallocchk(param.nTotGridAngles * sizeof(myfloat3_t)); + MPI_Bcast(param.angles, param.nTotGridAngles * sizeof(myfloat3_t), MPI_BYTE, + 0, MPI_COMM_WORLD); +#ifdef DEBUG + for (int n = 0; n < param.nTotGridAngles; n++) + { + cout << "CHECK: Angle orient " << mpi_rank << " " << n << " " + << param.angles[n].pos[0] << " " << param.angles[n].pos[1] << " " + << param.angles[n].pos[2] << " " << param.angles[n].quat4 << " " + << "\n"; } + +#endif + //****refCtf, CtfParam, angles automatically filled by precalculate function + // bellow + + MPI_Bcast(&Model, sizeof(Model), MPI_BYTE, 0, MPI_COMM_WORLD); + if (mpi_rank != 0) + Model.points = (bioem_model::bioem_model_point *) mallocchk( + sizeof(bioem_model::bioem_model_point) * Model.nPointsModel); + MPI_Bcast(Model.points, + sizeof(bioem_model::bioem_model_point) * Model.nPointsModel, + MPI_BYTE, 0, MPI_COMM_WORLD); + + MPI_Bcast(&RefMap, sizeof(RefMap), MPI_BYTE, 0, MPI_COMM_WORLD); + if (mpi_rank != 0) + RefMap.maps = (myfloat_t *) mallocchk( + RefMap.refMapSize * sizeof(myfloat_t) * RefMap.ntotRefMap); + MPI_Bcast(RefMap.maps, + RefMap.refMapSize * sizeof(myfloat_t) * RefMap.ntotRefMap, + MPI_BYTE, 0, MPI_COMM_WORLD); + if (DebugOutput >= 2 && mpi_rank == 0) + printf("MPI Broadcast of Input Data %f\n", timer.GetCurrentElapsedTime()); + } #endif // ****************** Precalculating Necessary Stuff ********************* - if (DebugOutput >= 2 && mpi_rank == 0) timer.ResetStart(); + if (DebugOutput >= 2 && mpi_rank == 0) + timer.ResetStart(); param.PrepareFFTs(); if (DebugOutput >= 2 && mpi_rank == 0) - { - printf("Time Prepare FFTs %f\n", timer.GetCurrentElapsedTime()); - timer.ResetStart(); - } + { + printf("Time Prepare FFTs %f\n", timer.GetCurrentElapsedTime()); + timer.ResetStart(); + } precalculate(); // ****************** For debugging ********************* if (getenv("BIOEM_DEBUG_BREAK")) - { - const int cut = atoi(getenv("BIOEM_DEBUG_BREAK")); - if (param.nTotGridAngles > cut) param.nTotGridAngles = cut; - if (param.nTotCTFs > cut) param.nTotCTFs = cut; - } + { + const int cut = atoi(getenv("BIOEM_DEBUG_BREAK")); + if (param.nTotGridAngles > cut) + param.nTotGridAngles = cut; + if (param.nTotCTFs > cut) + param.nTotCTFs = cut; + } if (DebugOutput >= 2 && mpi_rank == 0) - { - printf("Time Precalculate %f\n", timer.GetCurrentElapsedTime()); - timer.ResetStart(); - } + { + printf("Time Precalculate %f\n", timer.GetCurrentElapsedTime()); + timer.ResetStart(); + } + + // Number of parallel Convolutions and Comparisons + param.nTotParallelConv = min(param.nTotCTFs, nProjectionsAtOnce); // ****************** For autotuning ********************** - if ((getenv("GPU") && atoi(getenv("GPU"))) && ((!getenv("GPUWORKLOAD") || (atoi(getenv("GPUWORKLOAD")) == -1))) && (!getenv("BIOEM_DEBUG_BREAK") || (atoi(getenv("BIOEM_DEBUG_BREAK")) > FIRST_STABLE))) - { - Autotuning = true; - if (mpi_rank == 0) printf("Autotuning of GPUWorkload enabled:\n\tAlgorithm %d\n\tRecalibration at every %d projections\n\tComparisons are considered stable after first %d comparisons\n", AUTOTUNING_ALGORITHM, RECALIB_FACTOR, FIRST_STABLE); - } + if ((getenv("GPU") && atoi(getenv("GPU"))) && (BioEMAlgo == 1) && + ((!getenv("GPUWORKLOAD") || (atoi(getenv("GPUWORKLOAD")) == -1))) && + (!getenv("BIOEM_DEBUG_BREAK") || + (atoi(getenv("BIOEM_DEBUG_BREAK")) > FIRST_STABLE))) + { + Autotuning = true; + if (mpi_rank == 0) + printf("Autotuning of GPUWorkload enabled:\n\tAlgorithm " + "%d\n\tRecalibration at every %d projections\n\tComparisons are " + "considered stable after first %d comparisons\n", + AUTOTUNING_ALGORITHM, RECALIB_FACTOR, FIRST_STABLE); + } else + { + Autotuning = false; + if (mpi_rank == 0) { - Autotuning = false; - if (mpi_rank == 0) printf("Autotuning of GPUWorkload disabled\n"); + printf("Autotuning of GPUWorkload disabled"); + if (getenv("GPU") && atoi(getenv("GPU"))) + printf(", using GPUWorkload: %d%%\n", + (getenv("GPUWORKLOAD") && (atoi(getenv("GPUWORKLOAD")) != -1)) ? + atoi(getenv("GPUWORKLOAD")) : + 100); + else + printf(", please enable GPUs\n"); } + } // ****************** Initializing pointers ********************* deviceInit(); if (DebugOutput >= 2 && mpi_rank == 0) - { - printf("Time Device Init %f\n", timer.GetCurrentElapsedTime()); - timer.ResetStart(); - } + { + printf("Time Device Init %f\n", timer.GetCurrentElapsedTime()); + timer.ResetStart(); + } - if(!param.printModel)pProb.init(RefMap.ntotRefMap, param.nTotGridAngles, param.nTotCC, *this); + if (!param.printModel) + pProb.init(RefMap.ntotRefMap, param.nTotGridAngles, *this); if (DebugOutput >= 2 && mpi_rank == 0) - { - printf("Time Init Probabilities %f\n", timer.GetCurrentElapsedTime()); - timer.ResetStart(); - } + { + printf("Time Init Probabilities %f\n", timer.GetCurrentElapsedTime()); + timer.ResetStart(); + } - return(0); + return (0); } void bioem::cleanup() { - //Deleting allocated pointers + // Deleting allocated pointers free_device_host(pProb.ptr); RefMap.freePointers(); } @@ -416,723 +540,1019 @@ void bioem::cleanup() int bioem::precalculate() { // ************************************************************************************** - // **Precalculating Routine of Orientation grids, Map crosscorrelations and CTF Kernels** + // **Precalculating Routine of Orientation grids, Map crosscorrelations and + // CTF Kernels** // ************************************************************************************** HighResTimer timer; - if (DebugOutput >= 3) - { - printf("\tTime Precalculate Grids Param: %f\n", timer.GetCurrentElapsedTime()); - timer.ResetStart(); - } + if (DebugOutput >= 2) + { + printf("\tTime Precalculate Grids Param: %f\n", + timer.GetCurrentElapsedTime()); + timer.ResetStart(); + } // Precalculating CTF Kernels stored in class Param param.CalculateRefCTF(); - if (DebugOutput >= 3) - { - printf("\tTime Precalculate CTFs: %f\n", timer.GetCurrentElapsedTime()); - timer.ResetStart(); - } - //Precalculate Maps - if(!param.printModel) RefMap.precalculate(param, *this); - if (DebugOutput >= 3) printf("\tTime Precalculate Maps: %f\n", timer.GetCurrentElapsedTime()); + if (DebugOutput >= 2) + { + printf("\tTime Precalculate CTFs: %f\n", timer.GetCurrentElapsedTime()); + timer.ResetStart(); + } + // Precalculate Maps + if (!param.printModel) + RefMap.precalculate(param, *this); + if (DebugOutput >= 2) + printf("\tTime Precalculate Maps: %f\n", timer.GetCurrentElapsedTime()); - return(0); + return (0); } -int bioem::run() +int bioem::printModel() { - // ************************************************************************************** - // ********** Secondary routine for printing out the only best projection *************** + // ********** Secondary routine for printing out the only best projection + // *************** // ************************************************************************************** - if(mpi_rank == 0 && param.printModel){ //Only works for 1 MPI process (not parallelized) - - cout << "\nAnalysis for printing best projection::: \n \n" ; - mycomplex_t* proj_mapsFFT; - myfloat_t* conv_map = NULL; - mycomplex_t* conv_mapFFT; - myfloat_t sumCONV, sumsquareCONV; + cout << "\nAnalysis for printing best projection::: \n \n"; + mycomplex_t *proj_mapsFFT; + myfloat_t *conv_map = NULL; + mycomplex_t *conv_mapFFT; + myfloat_t sumCONV, sumsquareCONV; - proj_mapsFFT = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D); - conv_mapFFT = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D); - conv_map = (myfloat_t*) myfftw_malloc(sizeof(myfloat_t) * param.param_device.NumberPixels * param.param_device.NumberPixels); + proj_mapsFFT = (mycomplex_t *) myfftw_malloc( + sizeof(mycomplex_t) * param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D); + conv_mapFFT = (mycomplex_t *) myfftw_malloc( + sizeof(mycomplex_t) * param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D); + conv_map = (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) * + param.param_device.NumberPixels * + param.param_device.NumberPixels); - cout << "...... Calculating Projection .......................\n " ; + cout << "...... Calculating Projection .......................\n "; - createProjection(0, proj_mapsFFT); + createProjection(0, proj_mapsFFT); - cout << "...... Calculating Convolution .......................\n " ; + cout << "...... Calculating Convolution .......................\n "; - createConvolutedProjectionMap(0, 0, proj_mapsFFT, conv_map, conv_mapFFT, sumCONV, sumsquareCONV); + createConvolutedProjectionMap_noFFT(proj_mapsFFT, conv_map, conv_mapFFT, + sumCONV, sumsquareCONV); - } + return (0); +} +int bioem::run() +{ // ************************************************************************************** - // **** Main BioEM routine, projects, convolutes and compares with Map using OpenMP **** + // **** Main BioEM routine, projects, convolutes and compares with Map using + // OpenMP **** // ************************************************************************************** - // **** If we want to control the number of threads -> omp_set_num_threads(XX); ****** - // ****************** Declarying class of Probability Pointer ************************* + // **** If we want to control the number of threads -> + // omp_set_num_threads(XX); ****** + // ****************** Declarying class of Probability Pointer + // ************************* cuda_custom_timeslot("Initialization", -1, -1, COLOR_INIT); - if (mpi_rank == 0) printf("\tInitializing Probabilities\n"); + if (mpi_rank == 0) + printf("\tInitializing Probabilities\n"); // Contros for MPI - if(mpi_size > param.nTotGridAngles){ - cout << "EXIT: Wrong MPI setup More MPI processes than orientations\n"; exit(1); + if (mpi_size > param.nTotGridAngles) + { + cout << "EXIT: Wrong MPI setup More MPI processes than orientations\n"; + exit(1); } // Inizialzing Probabilites to zero and constant to -Infinity - for (int iRefMap = 0; iRefMap < RefMap.ntotRefMap; iRefMap ++) - { - bioem_Probability_map& pProbMap = pProb.getProbMap(iRefMap); + for (int iRefMap = 0; iRefMap < RefMap.ntotRefMap; iRefMap++) + { + bioem_Probability_map &pProbMap = pProb.getProbMap(iRefMap); - pProbMap.Total = 0.0; - pProbMap.Constoadd = -FLT_MAX; //Problem if using double presicion + pProbMap.Total = 0.0; + pProbMap.Constoadd = MIN_PROB; - if (param.param_device.writeAngles) - { - for (int iOrient = 0; iOrient < param.nTotGridAngles; iOrient ++) - { - bioem_Probability_angle& pProbAngle = pProb.getProbAngle(iRefMap, iOrient); - - pProbAngle.forAngles = 0.0; - pProbAngle.ConstAngle = -FLT_MAX; - } - } - - if (param.param_device.writeCC) - { int cc=0; - for (int cent_x = 0; cent_x < param.param_device.NumberPixels; cent_x = cent_x + param.param_device.CCdisplace) - { - for (int cent_y = 0; cent_y < param.param_device.NumberPixels; cent_y = cent_y + param.param_device.CCdisplace) - { - bioem_Probability_cc& pProbCC = pProb.getProbCC(iRefMap, cc); - //Debuggin:: cout << iRefMap << " " << cc << " " << cent_x << " " << cent_y << "\n"; - - if(!param.param_device.CCwithBayes) { - pProbCC.forCC=-FLT_MAX; - }else { - pProbCC.forCC = 0.0; - pProbCC.ConstCC=-FLT_MAX; - } - cc++; - } - } - if(!FFTAlgo){cout << "Cross correlation calculation must be with enviormental variable FFTALGO=1\n"; exit(1);} - } - } + if (param.param_device.writeAngles) + { + for (int iOrient = 0; iOrient < param.nTotGridAngles; iOrient++) + { + bioem_Probability_angle &pProbAngle = + pProb.getProbAngle(iRefMap, iOrient); - if(!FFTAlgo){cout << "Remark: Not using FFT algorithm. Not using Prior in B-Env.";} + pProbAngle.forAngles = 0.0; + pProbAngle.ConstAngle = MIN_PROB; + } + } + } // ************************************************************************************** deviceStartRun(); - // ******************************** MAIN CYCLE ****************************************** - - mycomplex_t* proj_mapsFFT; - myfloat_t* conv_map = NULL; - mycomplex_t* conv_mapFFT; - myfloat_t sumCONV, sumsquareCONV; - - //allocating fftw_complex vector - const int ProjMapSize = (param.FFTMapSize + 64) & ~63; //Make sure this is properly aligned for fftw..., Actually this should be ensureb by using FFTMapSize, but it is not due to a bug in CUFFT which cannot handle padding properly - //******** Alocating Vectors ************* - proj_mapsFFT = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * ProjMapSize * nProjectionsAtOnce); - conv_mapFFT = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D); - if (!FFTAlgo) conv_map = (myfloat_t*) myfftw_malloc(sizeof(myfloat_t) * param.param_device.NumberPixels * param.param_device.NumberPixels); - - cuda_custom_timeslot_end; //Ending initialization + // ******************************** MAIN CYCLE + // ****************************************** + + mycomplex_t *proj_mapsFFT; + mycomplex_t *conv_mapsFFT; + myparam5_t *comp_params = + new myparam5_t[param.nTotParallelConv * PIPELINE_LVL]; + int iPipeline = 0; + + // allocating fftw_complex vector + const int ProjMapSize = + (param.FFTMapSize + 64) & ~63; // Make sure this is properly aligned for + // fftw..., Actually this should be ensureb by + // using FFTMapSize, but it is not due to a bug + // in CUFFT which cannot handle padding properly + //******** Allocating Vectors ************* + proj_mapsFFT = (mycomplex_t *) myfftw_malloc( + sizeof(mycomplex_t) * ProjMapSize * nProjectionsAtOnce); + conv_mapsFFT = + (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param.FFTMapSize * + param.nTotParallelConv * PIPELINE_LVL); + + cuda_custom_timeslot_end; // Ending initialization HighResTimer timer, timer2; /* Autotuning */ Autotuner aut; if (Autotuning) - { - aut.Initialize(AUTOTUNING_ALGORITHM, FIRST_STABLE); - rebalanceWrapper(aut.Workload()); - } - - if (DebugOutput >= 1 && mpi_rank == 0) printf("\tMain Loop GridAngles %d, CTFs %d, RefMaps %d, Shifts (%d/%d)², Pixels %d², OMP Threads %d, MPI Ranks %d\n", param.nTotGridAngles, param.nTotCTFs, RefMap.ntotRefMap, 2 * param.param_device.maxDisplaceCenter + param.param_device.GridSpaceCenter, param.param_device.GridSpaceCenter, param.param_device.NumberPixels, omp_get_max_threads(), mpi_size); - - + { + aut.Initialize(AUTOTUNING_ALGORITHM, FIRST_STABLE); + rebalanceWrapper(aut.Workload()); + } - const int iOrientStart = (int) ((long long int) mpi_rank * param.nTotGridAngles / mpi_size); - int iOrientEnd = (int) ((long long int) (mpi_rank + 1) * param.nTotGridAngles / mpi_size); - if (iOrientEnd > param.nTotGridAngles) iOrientEnd = param.nTotGridAngles; + if (DebugOutput >= 1 && mpi_rank == 0) + printf("\tMain Loop GridAngles %d, CTFs %d, RefMaps %d, Shifts (%d/%d)², " + "Pixels %d², OMP Threads %d, MPI Ranks %d\n", + param.nTotGridAngles, param.nTotCTFs, RefMap.ntotRefMap, + 2 * param.param_device.maxDisplaceCenter + + param.param_device.GridSpaceCenter, + param.param_device.GridSpaceCenter, param.param_device.NumberPixels, + omp_get_max_threads(), mpi_size); + + const int iOrientStart = + (int) ((long long int) mpi_rank * param.nTotGridAngles / mpi_size); + int iOrientEnd = + (int) ((long long int) (mpi_rank + 1) * param.nTotGridAngles / mpi_size); + if (iOrientEnd > param.nTotGridAngles) + iOrientEnd = param.nTotGridAngles; /* Vectors for computing statistic on different parts of the code */ TimeStat ts((iOrientEnd - iOrientStart), param.nTotCTFs); - if (DebugOutput >= 1) ts.InitTimeStat(4); + if (DebugOutput >= 1) + ts.InitTimeStat(4); - // **************************Loop Over orientations*************************************** + // **************************Loop Over + // orientations*************************************** - for (int iOrientAtOnce = iOrientStart; iOrientAtOnce < iOrientEnd; iOrientAtOnce += nProjectionsAtOnce) + for (int iOrientAtOnce = iOrientStart; iOrientAtOnce < iOrientEnd; + iOrientAtOnce += nProjectionsAtOnce) + { + // *************************************************************************************** + // ***** Creating Projection for given orientation and transforming to + // Fourier space ***** + if (DebugOutput >= 1) { - // *************************************************************************************** - // ***** Creating Projection for given orientation and transforming to Fourier space ***** - if (DebugOutput >= 1) - { - timer2.ResetStart(); - timer.ResetStart(); - } - int iTmpEnd = std::min(iOrientEnd, iOrientAtOnce + nProjectionsAtOnce); + timer2.ResetStart(); + timer.ResetStart(); + } + int iOrientEndAtOnce = + std::min(iOrientEnd, iOrientAtOnce + nProjectionsAtOnce); - // **************************Parallel orientations for projections at once*************** +// **************************Parallel orientations for projections at +// once*************** #pragma omp parallel for - for (int iOrient = iOrientAtOnce; iOrient < iTmpEnd;iOrient++) - { - createProjection(iOrient, &proj_mapsFFT[(iOrient - iOrientAtOnce) * ProjMapSize]); - } + for (int iOrient = iOrientAtOnce; iOrient < iOrientEndAtOnce; iOrient++) + { + createProjection(iOrient, + &proj_mapsFFT[(iOrient - iOrientAtOnce) * ProjMapSize]); + } + if (DebugOutput >= 1) + { + ts.time = timer.GetCurrentElapsedTime(); + ts.Add(TS_PROJECTION); + if (DebugOutput >= 2) + printf("\tTime Projection %d-%d: %f (rank %d)\n", iOrientAtOnce, + iOrientEndAtOnce - 1, ts.time, mpi_rank); + } + /* Recalibrate if needed */ + if (Autotuning && ((iOrientAtOnce - iOrientStart) % RECALIB_FACTOR == 0) && + ((iOrientEnd - iOrientAtOnce) > RECALIB_FACTOR) && + (iOrientAtOnce != iOrientStart)) + { + aut.Reset(); + rebalanceWrapper(aut.Workload()); + } + + for (int iOrient = iOrientAtOnce; iOrient < iOrientEndAtOnce; iOrient++) + { + mycomplex_t *proj_mapFFT = + &proj_mapsFFT[(iOrient - iOrientAtOnce) * ProjMapSize]; + + // *************************************************************************************** + // ***** **** Internal Loop over PSF/CTF convolutions **** ***** + for (int iConvAtOnce = 0; iConvAtOnce < param.nTotCTFs; + iConvAtOnce += param.nTotParallelConv) + { + if (DebugOutput >= 1) + timer.ResetStart(); + int iConvEndAtOnce = + std::min(param.nTotCTFs, iConvAtOnce + param.nTotParallelConv); + // Total number of convolutions that can be treated in this iteration in + // parallel + int maxParallelConv = iConvEndAtOnce - iConvAtOnce; +#pragma omp parallel for + for (int iConv = iConvAtOnce; iConv < iConvEndAtOnce; iConv++) + { + // *** Calculating convolutions of projection map and + // crosscorrelations *** + int i = + (iPipeline & 1) * param.nTotParallelConv + (iConv - iConvAtOnce); + mycomplex_t *localmultFFT = &conv_mapsFFT[i * param.FFTMapSize]; + + createConvolutedProjectionMap(iOrient, iConv, proj_mapFFT, + localmultFFT, comp_params[i].sumC, + comp_params[i].sumsquareC); + + comp_params[i].amp = param.CtfParam[iConv].pos[0]; + comp_params[i].pha = param.CtfParam[iConv].pos[1]; + comp_params[i].env = param.CtfParam[iConv].pos[2]; + } + if (DebugOutput >= 1) + { + ts.time = timer.GetCurrentElapsedTime(); + ts.Add(TS_CONVOLUTION); + if (DebugOutput >= 2) + printf("\t\tTime Convolution %d %d-%d: %f (rank %d)\n", iOrient, + iConvAtOnce, iConvEndAtOnce - 1, ts.time, mpi_rank); + } + + // ******************Internal loop over Reference images CUDA or + // OpenMP****************** + // *** Comparing each calculated convoluted map with all experimental + // maps *** + ts.time = 0.; + if ((DebugOutput >= 1) || (Autotuning && aut.Needed(iConvAtOnce))) + timer.ResetStart(); + compareRefMaps(iPipeline++, iOrient, iConvAtOnce, maxParallelConv, + conv_mapsFFT, comp_params); + if (DebugOutput >= 1) + { + ts.time = timer.GetCurrentElapsedTime(); + ts.Add(TS_COMPARISON); + } + if (DebugOutput >= 2) + { + if (Autotuning) + printf("\t\tTime Comparison %d %d-%d: %f sec with GPU workload " + "%d%% (rank %d)\n", + iOrient, iConvAtOnce, iConvEndAtOnce - 1, ts.time, + aut.Workload(), mpi_rank); + else + printf("\t\tTime Comparison %d %d-%d: %f sec (rank %d)\n", iOrient, + iConvAtOnce, iConvEndAtOnce - 1, ts.time, mpi_rank); + } + if (Autotuning && aut.Needed(iConvAtOnce)) + { + if (ts.time == 0.) + ts.time = timer.GetCurrentElapsedTime(); + aut.Tune(ts.time); + if (aut.Finished() && DebugOutput >= 1) + printf("\tOptimal GPU workload %d%% (rank %d)\n", aut.Workload(), + mpi_rank); + rebalanceWrapper(aut.Workload()); + } + } if (DebugOutput >= 1) - { - ts.time = timer.GetCurrentElapsedTime(); - ts.Add(TS_PROJECTION); - if (DebugOutput >= 2) printf("\tTime Projection %d: %f (rank %d)\n", iOrientAtOnce, ts.time, mpi_rank); - } - /* Recalibrate if needed */ - if (Autotuning && ((iOrientAtOnce - iOrientStart) % RECALIB_FACTOR == 0) && ((iOrientEnd - iOrientAtOnce) > RECALIB_FACTOR) && (iOrientAtOnce != iOrientStart)) - { - aut.Reset(); - rebalanceWrapper(aut.Workload()); - } - - for (int iOrient = iOrientAtOnce; iOrient < iTmpEnd;iOrient++) - { - mycomplex_t* proj_mapFFT = &proj_mapsFFT[(iOrient - iOrientAtOnce) * ProjMapSize]; - - // *************************************************************************************** - // ***** **** Internal Loop over PSF/CTF convolutions **** ***** - - for (int iConv = 0; iConv < param.nTotCTFs; iConv++) - { - // *** Calculating convolutions of projection map and crosscorrelations *** - if (DebugOutput >= 1) timer.ResetStart(); - createConvolutedProjectionMap(iOrient, iConv, proj_mapFFT, conv_map, conv_mapFFT, sumCONV, sumsquareCONV); - if (DebugOutput >= 1) - { - ts.time = timer.GetCurrentElapsedTime(); - ts.Add(TS_CONVOLUTION); - if (DebugOutput >= 2) printf("\t\tTime Convolution %d %d: %f (rank %d)\n", iOrient, iConv, ts.time, mpi_rank); - } - - if ((DebugOutput >= 1) || (Autotuning && aut.Needed(iConv))) timer.ResetStart(); - myfloat_t amp,pha,env; - - amp=param.CtfParam[iConv].pos[0]; - pha=param.CtfParam[iConv].pos[1]; - env=param.CtfParam[iConv].pos[2]; - - // ******************Internal loop over Reference images CUDA or OpenMP****************** - // *** Comparing each calculated convoluted map with all experimental maps *** - - compareRefMaps(iOrient, iConv, amp, pha, env, conv_map, conv_mapFFT, sumCONV, sumsquareCONV); - - ts.time = 0.; - if (DebugOutput >= 1) - { - ts.time = timer.GetCurrentElapsedTime(); - ts.Add(TS_COMPARISON); - } - if (DebugOutput >= 2) - { - const int nShifts = 2 * param.param_device.maxDisplaceCenter / param.param_device.GridSpaceCenter + 1; - const double nFlops = (double) RefMap.ntotRefMap * (double) nShifts * (double) nShifts * - (((double) param.param_device.NumberPixels - (double) param.param_device.maxDisplaceCenter / 2.) * ((double) param.param_device.NumberPixels - (double) param.param_device.maxDisplaceCenter / 2.) * 5. + 25.) / ts.time; - const double nGBs = (double) RefMap.ntotRefMap * (double) nShifts * (double) nShifts * - (((double) param.param_device.NumberPixels - (double) param.param_device.maxDisplaceCenter / 2.) * ((double) param.param_device.NumberPixels - (double) param.param_device.maxDisplaceCenter / 2.) * 2. + 8.) * (double) sizeof(myfloat_t) / ts.time; - const double nGBs2 = (double) RefMap.ntotRefMap * ((double) param.param_device.NumberPixels * (double) param.param_device.NumberPixels + 8.) * (double) sizeof(myfloat_t) / ts.time; - - if (Autotuning) printf("\t\tTime Comparison %d %d: %f sec (%f GFlops, %f GB/s (cached), %f GB/s, with GPU workload %d%%) (rank %d)\n", iOrient, iConv, ts.time, nFlops / 1000000000., nGBs / 1000000000., nGBs2 / 1000000000., aut.Workload(), mpi_rank); - else printf("\t\tTime Comparison %d %d: %f sec (%f GFlops, %f GB/s (cached), %f GB/s) (rank %d)\n", iOrient, iConv, ts.time, nFlops / 1000000000., nGBs / 1000000000., nGBs2 / 1000000000., mpi_rank); - } - if (Autotuning && aut.Needed(iConv)) - { - if (ts.time == 0.) ts.time = timer.GetCurrentElapsedTime(); - aut.Tune(ts.time); - if (aut.Finished() && DebugOutput >= 1) printf("\tOptimal GPU workload %d%% (rank %d)\n", aut.Workload(), mpi_rank); - rebalanceWrapper(aut.Workload()); - } - } - if (DebugOutput >= 1) - { - ts.time = timer2.GetCurrentElapsedTime(); - ts.Add(TS_TPROJECTION); - printf("\tTotal time for projection %d: %f (rank %d)\n", iOrient, ts.time, mpi_rank); - timer2.ResetStart(); - } - } + { + ts.time = timer2.GetCurrentElapsedTime(); + ts.Add(TS_TPROJECTION); + printf("\tTotal time for projection %d: %f (rank %d)\n", iOrient, + ts.time, mpi_rank); + timer2.ResetStart(); + } } + } /* Statistical summary on different parts of the code */ if (DebugOutput >= 1) - { - ts.PrintTimeStat(mpi_rank); - ts.EmptyTimeStat(); - } + { + ts.PrintTimeStat(mpi_rank); + ts.EmptyTimeStat(); + } - //deallocating fftw_complex vector + // deallocating fftw_complex vector myfftw_free(proj_mapsFFT); - myfftw_free(conv_mapFFT); - if (!FFTAlgo) myfftw_free(conv_map); + myfftw_free(conv_mapsFFT); deviceFinishRun(); - - - // ************* Collecing all the probabilities from MPI replicas *************** +// ******************************************************************************* +// ************* Collecing all the probabilities from MPI replicas +// *************** #ifdef WITH_MPI if (mpi_size > 1) + { + if (DebugOutput >= 1 && mpi_rank == 0) + timer.ResetStart(); + // Reduce Constant and summarize probabilities { - if (DebugOutput >= 1 && mpi_rank == 0) timer.ResetStart(); - //Reduce Constant and summarize probabilities + myprob_t *tmp1 = new myprob_t[RefMap.ntotRefMap]; + myprob_t *tmp2 = new myprob_t[RefMap.ntotRefMap]; + myprob_t *tmp3 = new myprob_t[RefMap.ntotRefMap]; + for (int i = 0; i < RefMap.ntotRefMap; i++) + { + tmp1[i] = pProb.getProbMap(i).Constoadd; + } + MPI_Allreduce(tmp1, tmp2, RefMap.ntotRefMap, MY_MPI_FLOAT, MPI_MAX, + MPI_COMM_WORLD); + + for (int i = 0; i < RefMap.ntotRefMap; i++) { - myfloat_t* tmp1 = new myfloat_t[RefMap.ntotRefMap]; - myfloat_t* tmp2 = new myfloat_t[RefMap.ntotRefMap]; - myfloat_t* tmp3 = new myfloat_t[RefMap.ntotRefMap]; - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - tmp1[i] = pProb.getProbMap(i).Constoadd; - } - MPI_Allreduce(tmp1, tmp2, RefMap.ntotRefMap, MY_MPI_FLOAT, MPI_MAX, MPI_COMM_WORLD); - - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - bioem_Probability_map& pProbMap = pProb.getProbMap(i); + bioem_Probability_map &pProbMap = pProb.getProbMap(i); #ifdef DEBUG - cout << "Reduction " << mpi_rank << " Map " << i << " Prob " << pProbMap.Total << " Const " << pProbMap.Constoadd << "\n"; + cout << "Reduction " << mpi_rank << " Map " << i << " Prob " + << pProbMap.Total << " Const " << pProbMap.Constoadd << "\n"; #endif - tmp1[i] = pProbMap.Total * exp(pProbMap.Constoadd - tmp2[i]); - - } - MPI_Reduce(tmp1, tmp3, RefMap.ntotRefMap, MY_MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); - - //Find MaxProb - MPI_Status mpistatus; - { - int* tmpi1 = new int[RefMap.ntotRefMap]; - int* tmpi2 = new int[RefMap.ntotRefMap]; - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - bioem_Probability_map& pProbMap = pProb.getProbMap(i); - tmpi1[i] = tmp2[i] <= pProbMap.Constoadd ? mpi_rank : -1; - //temporary array that has the mpirank for the highest pProb.constant - } - MPI_Allreduce(tmpi1, tmpi2, RefMap.ntotRefMap, MPI_INT, MPI_MAX, MPI_COMM_WORLD); - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - if (tmpi2[i] == -1) - { - if (mpi_rank == 0) printf("Error: Could not find highest probability\n"); - } - else if (tmpi2[i] != 0) //Skip if rank 0 already has highest probability - { - if (mpi_rank == 0) - { - MPI_Recv(&pProb.getProbMap(i).max, sizeof(pProb.getProbMap(i).max), MPI_BYTE, tmpi2[i], i, MPI_COMM_WORLD, &mpistatus); - } - else if (mpi_rank == tmpi2[i]) - { - MPI_Send(&pProb.getProbMap(i).max, sizeof(pProb.getProbMap(i).max), MPI_BYTE, 0, i, MPI_COMM_WORLD); - } - } - } - delete[] tmpi1; - delete[] tmpi2; - } - - if (mpi_rank == 0) - { - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - bioem_Probability_map& pProbMap = pProb.getProbMap(i); - pProbMap.Total = tmp3[i]; - pProbMap.Constoadd = tmp2[i]; - } - } - - delete[] tmp1; - delete[] tmp2; - delete[] tmp3; - if (DebugOutput >= 1 && mpi_rank == 0 && mpi_size > 1) printf("Time MPI Reduction: %f\n", timer.GetCurrentElapsedTime()); + tmp1[i] = pProbMap.Total * exp(pProbMap.Constoadd - tmp2[i]); } + MPI_Reduce(tmp1, tmp3, RefMap.ntotRefMap, MY_MPI_FLOAT, MPI_SUM, 0, + MPI_COMM_WORLD); - //Angle Reduction and Probability summation for individual angles - if (param.param_device.writeAngles) - { - const int count = RefMap.ntotRefMap * param.nTotGridAngles; - myfloat_t* tmp1 = new myfloat_t[count]; - myfloat_t* tmp2 = new myfloat_t[count]; - myfloat_t* tmp3 = new myfloat_t[count]; - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - for (int j = 0;j < param.nTotGridAngles;j++) - { - // tmp1[i] = pProb.getProbMap(i).Constoadd; - // bioem_Probability_angle& pProbAngle = pProb.getProbAngle(i, j); - tmp1[i * param.nTotGridAngles + j]= pProb.getProbAngle(i, j).ConstAngle; - } - } - - MPI_Allreduce(tmp1, tmp2, count, MY_MPI_FLOAT, MPI_MAX, MPI_COMM_WORLD); - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - for (int j = 0;j < param.nTotGridAngles;j++) - { - bioem_Probability_angle& pProbAngle = pProb.getProbAngle(i, j); - tmp1[i * param.nTotGridAngles + j] = pProbAngle.forAngles * exp(pProbAngle.ConstAngle - tmp2[i * param.nTotGridAngles + j]); - } - } - MPI_Reduce(tmp1, tmp3, count, MY_MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); - if (mpi_rank == 0) - { - for (int i = 0;i < RefMap.ntotRefMap;i++) - { - for (int j = 0;j < param.nTotGridAngles;j++) - { - bioem_Probability_angle& pProbAngle = pProb.getProbAngle(i, j); - pProbAngle.forAngles = tmp3[i * param.nTotGridAngles + j]; - pProbAngle.ConstAngle = tmp2[i * param.nTotGridAngles + j]; - } - } - } - delete[] tmp1; - delete[] tmp2; - delete[] tmp3; - } + // Find MaxProb + MPI_Status mpistatus; + { + int *tmpi1 = new int[RefMap.ntotRefMap]; + int *tmpi2 = new int[RefMap.ntotRefMap]; + for (int i = 0; i < RefMap.ntotRefMap; i++) + { + bioem_Probability_map &pProbMap = pProb.getProbMap(i); + tmpi1[i] = tmp2[i] <= pProbMap.Constoadd ? mpi_rank : -1; + // temporary array that has the mpirank for the highest pProb.constant + } + MPI_Allreduce(tmpi1, tmpi2, RefMap.ntotRefMap, MPI_INT, MPI_MAX, + MPI_COMM_WORLD); + for (int i = 0; i < RefMap.ntotRefMap; i++) + { + if (tmpi2[i] == -1) + { + if (mpi_rank == 0) + printf("Error: Could not find highest probability\n"); + } + else if (tmpi2[i] != + 0) // Skip if rank 0 already has highest probability + { + if (mpi_rank == 0) + { + MPI_Recv(&pProb.getProbMap(i).max, + sizeof(pProb.getProbMap(i).max), MPI_BYTE, tmpi2[i], i, + MPI_COMM_WORLD, &mpistatus); + } + else if (mpi_rank == tmpi2[i]) + { + MPI_Send(&pProb.getProbMap(i).max, + sizeof(pProb.getProbMap(i).max), MPI_BYTE, 0, i, + MPI_COMM_WORLD); + } + } + } + delete[] tmpi1; + delete[] tmpi2; + } + + if (mpi_rank == 0) + { + for (int i = 0; i < RefMap.ntotRefMap; i++) + { + bioem_Probability_map &pProbMap = pProb.getProbMap(i); + pProbMap.Total = tmp3[i]; + pProbMap.Constoadd = tmp2[i]; + } + } + + delete[] tmp1; + delete[] tmp2; + delete[] tmp3; + if (DebugOutput >= 1 && mpi_rank == 0 && mpi_size > 1) + printf("Time MPI Reduction: %f\n", timer.GetCurrentElapsedTime()); } -#endif + // Angle Reduction and Probability summation for individual angles + if (param.param_device.writeAngles) + { + const int count = RefMap.ntotRefMap * param.nTotGridAngles; + myprob_t *tmp1 = new myprob_t[count]; + myprob_t *tmp2 = new myprob_t[count]; + myprob_t *tmp3 = new myprob_t[count]; + for (int i = 0; i < RefMap.ntotRefMap; i++) + { + for (int j = 0; j < param.nTotGridAngles; j++) + { + // tmp1[i] = pProb.getProbMap(i).Constoadd; + // bioem_Probability_angle& pProbAngle = + // pProb.getProbAngle(i, j); + tmp1[i * param.nTotGridAngles + j] = + pProb.getProbAngle(i, j).ConstAngle; + } + } + + MPI_Allreduce(tmp1, tmp2, count, MY_MPI_FLOAT, MPI_MAX, MPI_COMM_WORLD); + for (int i = 0; i < RefMap.ntotRefMap; i++) + { + for (int j = 0; j < param.nTotGridAngles; j++) + { + bioem_Probability_angle &pProbAngle = pProb.getProbAngle(i, j); + tmp1[i * param.nTotGridAngles + j] = + pProbAngle.forAngles * + exp(pProbAngle.ConstAngle - tmp2[i * param.nTotGridAngles + j]); + } + } + MPI_Reduce(tmp1, tmp3, count, MY_MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD); + if (mpi_rank == 0) + { + for (int i = 0; i < RefMap.ntotRefMap; i++) + { + for (int j = 0; j < param.nTotGridAngles; j++) + { + bioem_Probability_angle &pProbAngle = pProb.getProbAngle(i, j); + pProbAngle.forAngles = tmp3[i * param.nTotGridAngles + j]; + pProbAngle.ConstAngle = tmp2[i * param.nTotGridAngles + j]; + } + } + } + delete[] tmp1; + delete[] tmp2; + delete[] tmp3; + } + } +#endif // ************* Writing Out Probabilities *************** if (mpi_rank == 0) + { + + // Output for Angle Probability File + ofstream angProbfile; + angProbfile.precision(OUTPUT_PRECISION); + angProbfile.setf(ios::fixed); + if (param.param_device.writeAngles) + { + angProbfile.open("ANG_PROB"); + angProbfile << "************************* HEADER:: NOTATION " + "*******************************************\n"; + if (!param.doquater) + { + angProbfile << " RefMap: MapNumber ; alpha[rad] - beta[rad] - " + "gamma[rad] - logP - cal log Probability + Constant: " + "Numerical Const.+ log (volume) + prior ang\n"; + } + else + { + angProbfile << " RefMap: MapNumber ; q1 - q2 -q3 - logP- cal log " + "Probability + Constant: Numerical Const. + log " + "(volume) + prior ang\n"; + }; + angProbfile << "************************* HEADER:: NOTATION " + "*******************************************\n"; + // angProbfile <<"Model Used: " << modelfile.c_str() << "\n"; + // angProbfile <<"Input Used: " << infile.c_str() << "\n"; + } + + // Output for Standard Probability + ofstream outputProbFile; + outputProbFile.precision(OUTPUT_PRECISION); + outputProbFile.setf(ios::fixed); + outputProbFile.open(OutfileName.c_str()); + outputProbFile << "************************* HEADER:: NOTATION " + "*******************************************\n"; + outputProbFile << "Notation= RefMap: MapNumber ; LogProb natural " + "logarithm of posterior Probability ; Constant: " + "Numerical Const. for adding Probabilities \n"; + if (!param.doquater) + { + if (param.usepsf) + { + outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: " + "MaxLogProb - alpha[rad] - beta[rad] - gamma[rad] - " + "PSF amp - PSF phase - PSF envelope - center x - " + "center y - normalization - offsett \n"; + } + else + { + outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: " + "MaxLogProb - alpha[rad] - beta[rad] - gamma[rad] - " + "CTF amp - CTF defocus - CTF B-Env - center x - " + "center y - normalization - offsett \n"; + } + } + else { - - // Output for Angle Probability File - ofstream angProbfile; - if(param.param_device.writeAngles) - { - angProbfile.open ("ANG_PROB"); - angProbfile <<"************************* HEADER:: NOTATION *******************************************\n"; - if(!param.doquater){ angProbfile <<" RefMap: MapNumber ; alpha[rad] - beta[rad] - gamma[rad] - logP - cal log Probability + Constant: Numerical Const.+ log (volume) + prior ang\n" ;} - else { angProbfile <<" RefMap: MapNumber ; q1 - q2 -q3 - logP- cal log Probability + Constant: Numerical Const. + log (volume) + prior ang\n" ;}; - angProbfile <<"************************* HEADER:: NOTATION *******************************************\n"; - // angProbfile <<"Model Used: " << modelfile.c_str() << "\n"; - // angProbfile <<"Input Used: " << infile.c_str() << "\n"; - } - // Output for Cross Correlation File - ofstream ccProbfile; - if(param.param_device.writeCC) - { - ccProbfile.open ("CROSS_CORRELATION"); - ccProbfile <<"************************* HEADER:: NOTATION *******************************************\n"; - ccProbfile <<" RefMap: MapNumber ; Pixel x - Pixel y - Cross-Correlation \n"; - ccProbfile <<"Note that the highest Cross-correlation is the best.\n"; - ccProbfile <<"If the particles are flipped, include the keyward FLIPPED in the Param file.\n"; - ccProbfile <<"************************* HEADER:: NOTATION *******************************************\n"; - } - - // Output for Standard Probability - ofstream outputProbFile; - if(!yesoutfilename)OutfileName="Output_Probabilities"; - outputProbFile.open (OutfileName.c_str()); - outputProbFile <<"************************* HEADER:: NOTATION *******************************************\n"; - outputProbFile << "Notation= RefMap: MapNumber ; LogProb natural logarithm of posterior Probability ; Constant: Numerical Const. for adding Probabilities \n"; - if(!param.doquater){ - if(param.usepsf){ - outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: MaxLogProb - alpha[rad] - beta[rad] - gamma[rad] - PSF amp - PSF phase - PSF envelope - center x - center y - normalization - offsett \n";}else{ - outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: MaxLogProb - alpha[rad] - beta[rad] - gamma[rad] - CTF amp - CTF defocus - CTF B-Env - center x - center y - normalization - offsett \n";} - }else { - if(param.usepsf){ - // if( localcc[rx * param.param_device.NumberPixels + ry] < - outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: MaxLogProb - q1 - q2 - q3 - q4 -PSF amp - PSF phase - PSF envelope - center x - center y - normalization - offsett \n"; - }else{ - outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: MaxLogProb - q1 - q2 - q3 - q4 - CTF amp - CTF defocus - CTF B-Env - center x - center y - normalization - offsett \n"; - }} - if(param.writeCTF) outputProbFile << " RefMap: MapNumber ; CTFMaxParm: defocus - b-Env (B ref. Penzeck 2010)\n"; - if(param.yespriorAngles) outputProbFile << "**** Remark: Using Prior Proability in Angles ****\n"; - outputProbFile <<"************************* HEADER:: NOTATION *******************************************\n\n"; - - - // Loop over reference maps - // ************* Over all maps *************** - - for (int iRefMap = 0; iRefMap < RefMap.ntotRefMap; iRefMap ++) - { - // **** Total Probability *** - bioem_Probability_map& pProbMap = pProb.getProbMap(iRefMap); - - //Controll for Value of Total Probability - // cout << pProbMap.Total << " " << pProbMap.Constoadd << " " << FLT_MAX <<" " << log(FLT_MAX) << "\n"; - if(pProbMap.Total>1.e-38){ - - outputProbFile << "RefMap: " << iRefMap << " LogProb: " << log(pProbMap.Total) + pProbMap.Constoadd + 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu) << " Constant: " << pProbMap.Constoadd << "\n"; - outputProbFile << "RefMap: " << iRefMap << " Maximizing Param: "; - // *** Param that maximize probability**** - outputProbFile << (log(pProbMap.Total) + pProbMap.Constoadd + 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5) * (log(2 * M_PI) + 1) + log(param.param_device.volu)) << " "; - - - }else{ - outputProbFile << "Warining! with Map " << iRefMap << "Numerical Integrated Probability without constant = 0.0;\n"; - outputProbFile << "Warining RefMap: " << iRefMap << "Check that constant is finite: " << pProbMap.Constoadd << "\n"; - outputProbFile << "Warining RefMap: i) check model, ii) check refmap , iii) check GPU on/off command inconsitency\n"; - // outputProbFile << "Warning! " << iRefMap << " LogProb: " << pProbMap.Constoadd + 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu) << " Constant: " << pProbMap.Constoadd << "\n"; - } - // outputProbFile << "RefMap: " << iRefMap << " Maximizing Param: "; - - // *** Param that maximize probability**** - // outputProbFile << (pProbMap.Constoadd + 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5) * (log(2 * M_PI) + 1) + log(param.param_device.volu)) << " "; - - outputProbFile << param.angles[pProbMap.max.max_prob_orient].pos[0] << " [] "; - outputProbFile << param.angles[pProbMap.max.max_prob_orient].pos[1] << " [] "; - outputProbFile << param.angles[pProbMap.max.max_prob_orient].pos[2] << " [] "; - if(param.doquater)outputProbFile << param.angles[pProbMap.max.max_prob_orient].quat4 << " [] "; - outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[0] << " [] "; - if(!param.usepsf){outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[1]/ 2.f /M_PI / param.elecwavel * 0.0001 << " [micro-m] "; - }else{outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[1] << " [1/A²] ";} - if(!param.usepsf){outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[2] << " [A²] ";} - else{outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[2] << " [1/A²] ";} - outputProbFile << pProbMap.max.max_prob_cent_x << " [pix] "; - outputProbFile << pProbMap.max.max_prob_cent_y << " [pix] " ; - if(FFTAlgo){outputProbFile << pProbMap.max.max_prob_norm << " [] " ;}else{outputProbFile << "N.A." << " [] ";} - if(FFTAlgo){outputProbFile << pProbMap.max.max_prob_mu << " [] ";}else{outputProbFile << "N.A." << " [] ";} - outputProbFile << "\n"; - - // Writing out CTF parameters if requiered - if(param.writeCTF && param.usepsf){ - - myfloat_t denomi; - denomi = param.CtfParam[pProbMap.max.max_prob_conv].pos[1] * param.CtfParam[pProbMap.max.max_prob_conv].pos[1] + - param.CtfParam[pProbMap.max.max_prob_conv].pos[2] * param.CtfParam[pProbMap.max.max_prob_conv].pos[2]; - outputProbFile << "RefMap: " << iRefMap << " CTFMaxParam: "; - outputProbFile << 2*M_PI*param.CtfParam[pProbMap.max.max_prob_conv].pos[1]/denomi/param.elecwavel*0.0001 << " [micro-m] "; - outputProbFile << 4*M_PI*M_PI*param.CtfParam[pProbMap.max.max_prob_conv].pos[2]/denomi << " [A²] \n"; - } - - //*************** Writing Individual Angle probabilities - if(param.param_device.writeAngles) - { - for (int iOrient = 0; iOrient < param.nTotGridAngles; iOrient++) - { - bioem_Probability_angle& pProbAngle = pProb.getProbAngle(iRefMap, iOrient); - - myfloat_t logp=log(pProbAngle.forAngles)+ pProbAngle.ConstAngle+0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu); - if(!param.doquater){ - // For Euler Angles - if(param.yespriorAngles){ - logp+=param.angprior[iOrient]; - angProbfile << " " << iRefMap << " " << param.angles[iOrient].pos[0] << " " << param.angles[iOrient].pos[1] << " " << param.angles[iOrient].pos[2] << " " << logp << " Separated: " - << log(pProbAngle.forAngles) << " " << pProbAngle.ConstAngle << " " << 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu) << " " << param.angprior[iOrient] << "\n"; - } else - { - angProbfile << " " << iRefMap << " " << param.angles[iOrient].pos[0] << " " << param.angles[iOrient].pos[1] << " " << param.angles[iOrient].pos[2] << " " << logp << " Separated: "<< - log(pProbAngle.forAngles) << " " << pProbAngle.ConstAngle << " " << 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu) << "\n"; - } - }else { - // Samething but for Quaternions - if(param.yespriorAngles){ - logp+=param.angprior[iOrient]; - angProbfile << " " << iRefMap << " " << param.angles[iOrient].pos[0] << " " << param.angles[iOrient].pos[1] << " " << param.angles[iOrient].pos[2] << " " << param.angles[iOrient].quat4 << " " << logp << " Separated: " << log(pProbAngle.forAngles) << " " << pProbAngle.ConstAngle << " " << 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu) << " " << param.angprior[iOrient] << "\n"; - } else - { - angProbfile << " " << iRefMap << " " << param.angles[iOrient].pos[0] << " " << param.angles[iOrient].pos[1] << " " << param.angles[iOrient].pos[2] << " " << param.angles[iOrient].quat4 << " " << logp << " Separated: "<< - log(pProbAngle.forAngles) << " " << pProbAngle.ConstAngle << " " << 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu) << "\n"; - } - } - } - } - - //************* Writing Cross-Correlations if requiered - //************* This is currently not in the manual ***** - if(param.param_device.writeCC){ - - int cc=0; - int halfPix; - int rx=0; - int ry=0; - myfloat_t localcc[ (param.param_device.NumberPixels+1) * (param.param_device.NumberPixels+1) ]; - int used[(param.param_device.NumberPixels+1) * (param.param_device.NumberPixels+1)]; - - halfPix = param.param_device.NumberPixels / 2 ; - // Ordering the centers of the Cross Correlation - - for (int rx = 0; rx < param.param_device.NumberPixels ; rx++) - { - for (int ry = 0; ry < param.param_device.NumberPixels ; ry++) - { - localcc[ rx * param.param_device.NumberPixels + ry ] = 0.0; - used[ rx * param.param_device.NumberPixels + ry ]= 0; - } - } - - for (int cent_x = 0; cent_x < param.param_device.NumberPixels ; cent_x = cent_x + param.param_device.CCdisplace) - { - for (int cent_y = 0; cent_y < param.param_device.NumberPixels ; cent_y = cent_y + param.param_device.CCdisplace) - { - //localcc[ rx * param.param_device.NumberPixels + ry ] = 0.0; - bioem_Probability_cc& pProbCC = pProb.getProbCC(iRefMap, cc); - - // Applying Periodic boundary conditions to the CC - if(cent_x < halfPix && cent_y < halfPix){ - // ccProbfile << " " << iRefMap << " " << (myfloat_t) halfPix - cent_x << " " << halfPix - cent_y << " " << pProbCC.forCC <<"\n"; - rx = halfPix - cent_x; - ry = halfPix - cent_y;} - if(cent_x >= halfPix && cent_y < halfPix){ - // ccProbfile << " " << iRefMap << " " << (myfloat_t) 3 * halfPix - cent_x << " " << halfPix - cent_y << " " << pProbCC.forCC <<"\n"; - rx = 3 * halfPix - cent_x; - ry = halfPix - cent_y;} - if(cent_x < halfPix && cent_y >= halfPix){ - // ccProbfile << " " << iRefMap << " " << (myfloat_t) halfPix - cent_x << " " << 3 * halfPix - cent_y << " " << pProbCC.forCC <<"\n"; - rx = halfPix - cent_x; - ry = 3 * halfPix - cent_y;} - if(cent_x >= halfPix && cent_y >= halfPix){ - // ccProbfile << " " << iRefMap << " " << 3* halfPix - cent_x << " " << 3 * halfPix - cent_y << " " << pProbCC.forCC <<"\n"; - rx = 3 * halfPix - cent_x; - ry = 3 * halfPix - cent_y;} - // cout << " TT " << cent_x << " " << rx << " " << cent_y << " " << ry << " " << pProbCC.forCC << "\n"; - if(!param.param_device.CCwithBayes){ - localcc[ rx * param.param_device.NumberPixels + ry ] = pProbCC.forCC; - }else{ - localcc[ rx * param.param_device.NumberPixels + ry ] = log(pProbCC.forCC)+pProbCC.ConstCC; - } - used[ rx * param.param_device.NumberPixels + ry] = 1; - cc++; - } - // ccProbfile << "\n"; - } - if(!param.ignoreCCoff){ -/* for (int rx = param.param_device.CCdisplace; rx < param.param_device.NumberPixels ; rx = rx + param.param_device.CCdisplace) - { - for (int ry = param.param_device.CCdisplace; ry < param.param_device.NumberPixels ; ry = ry + param.param_device.CCdisplace) - {*/ - for (int rx = param.param_device.CCdisplace; rx < param.param_device.NumberPixels ; rx++) - { - for (int ry = param.param_device.CCdisplace; ry < param.param_device.NumberPixels ; ry++) - { - - if(used[ rx * param.param_device.NumberPixels + ry ] == 1){ - ccProbfile << "RefMap: "<< iRefMap << " " << rx << " " << ry << " " << localcc[ rx * param.param_device.NumberPixels + ry ] << "\n" ; - }else{ - if(localcc[ rx * param.param_device.NumberPixels + ry ] <= -FLT_MAX)ccProbfile << "RefMap: "<< iRefMap << " " << rx << " " << ry << " " << -FLT_MAX << "\n" ; - } - // cout << " cc " << rx << " " << ry << " " << localcc[ rx * param.param_device.NumberPixels + ry ] <<"\n" ; - } - // ccProbfile << "\n"; - } - }else{ - for (int rx = param.param_device.CCdisplace; rx < param.param_device.NumberPixels ; rx++) - { - for (int ry = param.param_device.CCdisplace; ry < param.param_device.NumberPixels ; ry++) - { - if(used[ rx * param.param_device.NumberPixels + ry ] == 1){ - ccProbfile << "RefMap: "<< iRefMap << " " << rx << " " << ry << " " << localcc[ rx * param.param_device.NumberPixels + ry ] << "\n" ; - }else{ - if(localcc[ rx * param.param_device.NumberPixels + ry ] <= -FLT_MAX)ccProbfile << "RefMap: "<< iRefMap << " " << rx << " " << ry << " " << -FLT_MAX << "\n" ; - } - } - // ccProbfile << "\n"; - } - - } - } - } - - if(param.param_device.writeAngles) - { - angProbfile.close(); - } - - if(param.param_device.writeCC) - { - ccProbfile.close(); - } - - outputProbFile.close(); + if (param.usepsf) + { + // if( localcc[rx * param.param_device.NumberPixels + ry] < + outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: " + "MaxLogProb - q1 - q2 - q3 - q4 -PSF amp - PSF phase " + "- PSF envelope - center x - center y - " + "normalization - offsett \n"; + } + else + { + outputProbFile << "Notation= RefMap: MapNumber ; Maximizing Param: " + "MaxLogProb - q1 - q2 - q3 - q4 - CTF amp - CTF " + "defocus - CTF B-Env - center x - center y - " + "normalization - offsett \n"; + } } + if (param.writeCTF) + outputProbFile << " RefMap: MapNumber ; CTFMaxParm: defocus - b-Env (B " + "ref. Penzeck 2010)\n"; + if (param.yespriorAngles) + outputProbFile << "**** Remark: Using Prior Proability in Angles ****\n"; + outputProbFile << "************************* HEADER:: NOTATION " + "*******************************************\n\n"; + + // Loop over reference maps + // ************* Over all maps *************** + + for (int iRefMap = 0; iRefMap < RefMap.ntotRefMap; iRefMap++) + { + // **** Total Probability *** + bioem_Probability_map &pProbMap = pProb.getProbMap(iRefMap); - return(0); + // Controll for Value of Total Probability + // cout << pProbMap.Total << " " << pProbMap.Constoadd << " " << FLT_MAX + // <<" " << log(FLT_MAX) << "\n"; + if (pProbMap.Total > 1.e-38) + { + + outputProbFile << "RefMap: " << iRefMap << " LogProb: " + << log(pProbMap.Total) + pProbMap.Constoadd + + 0.5 * log(M_PI) + + (1 - param.param_device.Ntotpi * 0.5) * + (log(2 * M_PI) + 1) + + log(param.param_device.volu) + << " Constant: " << pProbMap.Constoadd << "\n"; + outputProbFile << "RefMap: " << iRefMap << " Maximizing Param: "; + // *** Param that maximize probability**** + outputProbFile << (log(pProbMap.Total) + pProbMap.Constoadd + + 0.5 * log(M_PI) + + (1 - param.param_device.Ntotpi * 0.5) * + (log(2 * M_PI) + 1) + + log(param.param_device.volu)) + << " "; + } + else + { + outputProbFile + << "Warining! with Map " << iRefMap + << "Numerical Integrated Probability without constant = 0.0;\n"; + outputProbFile << "Warining RefMap: " << iRefMap + << "Check that constant is finite: " + << pProbMap.Constoadd << "\n"; + outputProbFile << "Warining RefMap: i) check model, ii) check refmap , " + "iii) check GPU on/off command inconsitency\n"; + // outputProbFile << "Warning! " << iRefMap << " LogProb: " + //<< pProbMap.Constoadd + 0.5 * log(M_PI) + (1 - + // param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + + // log(param.param_device.volu) << " Constant: " << pProbMap.Constoadd + //<< "\n"; + } + // outputProbFile << "RefMap: " << iRefMap << " Maximizing + // Param: "; + + // *** Param that maximize probability**** + // outputProbFile << (pProbMap.Constoadd + 0.5 * log(M_PI) + (1 + //- param.param_device.Ntotpi * 0.5) * (log(2 * M_PI) + 1) + + // log(param.param_device.volu)) << " "; + + outputProbFile << param.angles[pProbMap.max.max_prob_orient].pos[0] + << " [] "; + outputProbFile << param.angles[pProbMap.max.max_prob_orient].pos[1] + << " [] "; + outputProbFile << param.angles[pProbMap.max.max_prob_orient].pos[2] + << " [] "; + if (param.doquater) + outputProbFile << param.angles[pProbMap.max.max_prob_orient].quat4 + << " [] "; + outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[0] + << " [] "; + if (!param.usepsf) + { + outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[1] / + 2.f / M_PI / param.elecwavel * 0.0001 + << " [micro-m] "; + } + else + { + outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[1] + << " [1/A²] "; + } + if (!param.usepsf) + { + outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[2] + << " [A²] "; + } + else + { + outputProbFile << param.CtfParam[pProbMap.max.max_prob_conv].pos[2] + << " [1/A²] "; + } + outputProbFile << pProbMap.max.max_prob_cent_x << " [pix] "; + outputProbFile << pProbMap.max.max_prob_cent_y << " [pix] "; + outputProbFile << pProbMap.max.max_prob_norm << " [] "; + outputProbFile << pProbMap.max.max_prob_mu << " [] "; + outputProbFile << "\n"; + + // Writing out CTF parameters if requiered + if (param.writeCTF && param.usepsf) + { + + myfloat_t denomi; + denomi = param.CtfParam[pProbMap.max.max_prob_conv].pos[1] * + param.CtfParam[pProbMap.max.max_prob_conv].pos[1] + + param.CtfParam[pProbMap.max.max_prob_conv].pos[2] * + param.CtfParam[pProbMap.max.max_prob_conv].pos[2]; + outputProbFile << "RefMap: " << iRefMap << " CTFMaxParam: "; + outputProbFile + << 2 * M_PI * param.CtfParam[pProbMap.max.max_prob_conv].pos[1] / + denomi / param.elecwavel * 0.0001 + << " [micro-m] "; + outputProbFile + << 4 * M_PI * M_PI * + param.CtfParam[pProbMap.max.max_prob_conv].pos[2] / denomi + << " [A²] \n"; + } + + //*************** Writing Individual Angle probabilities + if (param.param_device.writeAngles) + { + // Finding the best param.param_device.writeAngles probabilities + // This implementation is clean, but not the most optimal one + // and it supposes param.param_device.writeAngles << + // param.nTotGridAngles + unsigned K = + param.param_device.writeAngles; // number of best probabilities + // clang-format off + std::priority_queue, + std::vector >, + std::greater > > + q; + // clang-format on + for (int iOrient = 0; iOrient < param.nTotGridAngles; iOrient++) + { + bioem_Probability_angle &pProbAngle = + pProb.getProbAngle(iRefMap, iOrient); + + myprob_t logp = + log(pProbAngle.forAngles) + pProbAngle.ConstAngle + + 0.5 * log(M_PI) + + (1 - param.param_device.Ntotpi * 0.5) * (log(2 * M_PI) + 1) + + log(param.param_device.volu); + + if (q.size() < K) + q.push(std::pair(logp, iOrient)); + else if (q.top().first < logp) + { + q.pop(); + q.push(std::pair(logp, iOrient)); + } + } + K = q.size(); + int *rev_iOrient = (int *) malloc(K * sizeof(int)); + myprob_t *rev_logp = (myprob_t *) malloc(K * sizeof(myprob_t)); + for (int i = K - 1; i >= 0; i--) + { + rev_iOrient[i] = q.top().second; + rev_logp[i] = q.top().first; + q.pop(); + } + for (unsigned i = 0; i < K; i++) + { + int iOrient = rev_iOrient[i]; + bioem_Probability_angle &pProbAngle = + pProb.getProbAngle(iRefMap, iOrient); + myprob_t logp = rev_logp[i]; + + if (!param.doquater) + { + // For Euler Angles + if (param.yespriorAngles) + { + logp += param.angprior[iOrient]; + angProbfile << " " << iRefMap << " " + << param.angles[iOrient].pos[0] << " " + << param.angles[iOrient].pos[1] << " " + << param.angles[iOrient].pos[2] << " " << logp + << " Separated: " << log(pProbAngle.forAngles) << " " + << pProbAngle.ConstAngle << " " + << 0.5 * log(M_PI) + + (1 - param.param_device.Ntotpi * 0.5) * + (log(2 * M_PI) + 1) + + log(param.param_device.volu) + << " " << param.angprior[iOrient] << "\n"; + } + else + { + angProbfile << " " << iRefMap << " " + << param.angles[iOrient].pos[0] << " " + << param.angles[iOrient].pos[1] << " " + << param.angles[iOrient].pos[2] << " " << logp + << " Separated: " << log(pProbAngle.forAngles) << " " + << pProbAngle.ConstAngle << " " + << 0.5 * log(M_PI) + + (1 - param.param_device.Ntotpi * 0.5) * + (log(2 * M_PI) + 1) + + log(param.param_device.volu) + << "\n"; + } + } + else + { + // Samething but for Quaternions + if (param.yespriorAngles) + { + logp += param.angprior[iOrient]; + angProbfile << " " << iRefMap << " " + << param.angles[iOrient].pos[0] << " " + << param.angles[iOrient].pos[1] << " " + << param.angles[iOrient].pos[2] << " " + << param.angles[iOrient].quat4 << " " << logp + << " Separated: " << log(pProbAngle.forAngles) << " " + << pProbAngle.ConstAngle << " " + << 0.5 * log(M_PI) + + (1 - param.param_device.Ntotpi * 0.5) * + (log(2 * M_PI) + 1) + + log(param.param_device.volu) + << " " << param.angprior[iOrient] << "\n"; + } + else + { + angProbfile << " " << iRefMap << " " + << param.angles[iOrient].pos[0] << " " + << param.angles[iOrient].pos[1] << " " + << param.angles[iOrient].pos[2] << " " + << param.angles[iOrient].quat4 << " " << logp + << " Separated: " << log(pProbAngle.forAngles) << " " + << pProbAngle.ConstAngle << " " + << 0.5 * log(M_PI) + + (1 - param.param_device.Ntotpi * 0.5) * + (log(2 * M_PI) + 1) + + log(param.param_device.volu) + << "\n"; + } + } + } + free(rev_iOrient); + free(rev_logp); + } + } + + if (param.param_device.writeAngles) + { + angProbfile.close(); + } + + outputProbFile.close(); + } + + return (0); } -int bioem::compareRefMaps(int iOrient, int iConv, myfloat_t amp, myfloat_t pha, myfloat_t env, const myfloat_t* conv_map, mycomplex_t* localmultFFT, myfloat_t sumC, myfloat_t sumsquareC, const int startMap) +int bioem::compareRefMaps(int iPipeline, int iOrient, int iConvStart, + int maxParallelConv, mycomplex_t *localmultFFT, + myparam5_t *comp_params, const int startMap) { - //*************************************************************************************** //***** BioEM routine for comparing reference maps to convoluted maps ***** //*************************************************************************************** - cuda_custom_timeslot("Comparison", iOrient, iConv, COLOR_COMPARISON); - if (FFTAlgo) - { - //With FFT Algorithm + cuda_custom_timeslot("Comparison", iOrient, iConvStart, COLOR_COMPARISON); + + int k = (iPipeline & 1) * param.nTotParallelConv; + + if (BioEMAlgo == 1) + { #pragma omp parallel for schedule(dynamic, 1) - for (int iRefMap = startMap; iRefMap < RefMap.ntotRefMap; iRefMap ++) - { - const int num = omp_get_thread_num(); - calculateCCFFT(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, localmultFFT, param.fft_scratch_complex[num], param.fft_scratch_real[num]); - } + for (int iRefMap = startMap; iRefMap < RefMap.ntotRefMap; iRefMap++) + { + const int num = omp_get_thread_num(); + for (int iConv = 0; iConv < maxParallelConv; iConv++) + { + calculateCCFFT(iRefMap, &localmultFFT[(k + iConv) * param.FFTMapSize], + param.fft_scratch_complex[num], + param.fft_scratch_real[num]); + doRefMapFFT( + iRefMap, iOrient, iConvStart + iConv, comp_params[k + iConv].amp, + comp_params[k + iConv].pha, comp_params[k + iConv].env, + comp_params[k + iConv].sumC, comp_params[k + iConv].sumsquareC, + param.fft_scratch_real[num], pProb, param.param_device, RefMap); + } } + } else + { + myblockCPU_t *comp_blocks = new myblockCPU_t[maxParallelConv]; + for (int iRefMap = startMap; iRefMap < RefMap.ntotRefMap; iRefMap++) { - //Without FFT Algorithm #pragma omp parallel for schedule(dynamic, 1) - for (int iRefMap = startMap; iRefMap < RefMap.ntotRefMap; iRefMap ++) - { - compareRefMapShifted < -1 > (iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, conv_map, pProb, param.param_device, RefMap); - } + for (int iConv = 0; iConv < maxParallelConv; iConv++) + { + const int num = omp_get_thread_num(); + calculateCCFFT(iRefMap, &localmultFFT[(k + iConv) * param.FFTMapSize], + param.fft_scratch_complex[num], + param.fft_scratch_real[num]); + doRefMap_CPU_Parallel(iRefMap, iOrient, iConv, + param.fft_scratch_real[num], &comp_params[k], + comp_blocks); + } + doRefMap_CPU_Reduce(iRefMap, iOrient, iConvStart, maxParallelConv, + &comp_params[k], comp_blocks); } + delete[] comp_blocks; + } cuda_custom_timeslot_end; - return(0); + return (0); } -inline void bioem::calculateCCFFT(int iRefMap, int iOrient, int iConv, myfloat_t amp, myfloat_t pha, myfloat_t env, myfloat_t sumC, myfloat_t sumsquareC, mycomplex_t* localConvFFT, mycomplex_t* localCCT, myfloat_t* lCC) +inline void bioem::calculateCCFFT(int iRefMap, mycomplex_t *localConvFFT, + mycomplex_t *localCCT, myfloat_t *lCC) { //*************************************************************************************** - //***** Calculating cross correlation in FFTALGOrithm ***** + //***** Calculating cross correlation with FFT algorithm ***** - for(int i = 0; i < param.param_device.NumberPixels; i++) - { - for(int j = 0; j < param.param_device.NumberPixels; j++) lCC[i * param.param_device.NumberPixels + j] = 0.f; - } + for (int i = 0; i < param.param_device.NumberPixels; i++) + { + for (int j = 0; j < param.param_device.NumberPixels; j++) + lCC[i * param.param_device.NumberPixels + j] = 0.f; + } + + const mycomplex_t *RefMapFFT = &RefMap.RefMapsFFT[iRefMap * param.FFTMapSize]; + for (int i = 0; i < param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D; + i++) + { + localCCT[i][0] = localConvFFT[i][0] * RefMapFFT[i][0] + + localConvFFT[i][1] * RefMapFFT[i][1]; + localCCT[i][1] = localConvFFT[i][1] * RefMapFFT[i][0] - + localConvFFT[i][0] * RefMapFFT[i][1]; + } + + myfftw_execute_dft_c2r(param.fft_plan_c2r_backward, localCCT, lCC); +} +inline void bioem::doRefMap_CPU_Parallel(int iRefMap, int iOrient, int iConv, + myfloat_t *lCC, + myparam5_t *comp_params, + myblockCPU_t *comp_block) +{ + //*************************************************************************************** + //***** Computation of log probabilities, done in parallel by OMP - const mycomplex_t* RefMapFFT = &RefMap.RefMapsFFT[iRefMap * param.FFTMapSize]; - for(int i = 0; i < param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D; i++) + int myGlobalId = iConv * param.param_device.NtotDisp; + myfloat_t bestLogpro = MIN_PROB; + int dispC = + param.param_device.NumberPixels - param.param_device.maxDisplaceCenter; + int cent_x, cent_y, address, bestId = 0; + myfloat_t value, bestValue = 0.; + myprob_t logpro = 0., sumExp = 0.; + + for (int myX = 0; myX < param.param_device.NxDisp; myX++) + { + for (int myY = 0; myY < param.param_device.NxDisp; myY++, myGlobalId++) { - localCCT[i][0] = localConvFFT[i][0] * RefMapFFT[i][0] + localConvFFT[i][1] * RefMapFFT[i][1]; - localCCT[i][1] = localConvFFT[i][1] * RefMapFFT[i][0] - localConvFFT[i][0] * RefMapFFT[i][1]; + cent_x = (myX * param.param_device.GridSpaceCenter + dispC) % + param.param_device.NumberPixels; + cent_y = (myY * param.param_device.GridSpaceCenter + dispC) % + param.param_device.NumberPixels; + address = cent_x * param.param_device.NumberPixels + cent_y; + value = (myfloat_t) lCC[address] / + (myfloat_t)(param.param_device.NumberPixels * + param.param_device.NumberPixels); + + logpro = calc_logpro( + param.param_device, comp_params[iConv].amp, comp_params[iConv].pha, + comp_params[iConv].env, comp_params[iConv].sumC, + comp_params[iConv].sumsquareC, value, RefMap.sum_RefMap[iRefMap], + RefMap.sumsquare_RefMap[iRefMap]); +#ifdef DEBUG_PROB + printf("\t\t\tProb: iRefMap %d, iOrient %d, iConv %d, " + "cent_x %d, cent_y %d, address %d, value %f, logpro %f\n", + iRefMap, iOrient, iConv, cent_x, cent_y, address, value, logpro); +#endif + if (bestLogpro < logpro) + { + sumExp *= exp(-logpro + bestLogpro); + bestLogpro = logpro; + bestId = myGlobalId; + bestValue = value; + } + sumExp += exp(logpro - bestLogpro); } + } - myfftw_execute_dft_c2r(param.fft_plan_c2r_backward, localCCT, lCC); - - // printf("HereCC %p %f %d %d %d %d \n", &lCC[139 * param.param_device.NumberPixels + 139],lCC[139 * param.param_device.NumberPixels + 139],mpi_rank,iConv,iOrient,iRefMap); + comp_block[iConv].logpro = bestLogpro; + comp_block[iConv].sumExp = sumExp; + comp_block[iConv].id = bestId; + comp_block[iConv].value = bestValue; +} - doRefMapFFT(iRefMap, iOrient, iConv, amp, pha, env, lCC, sumC, sumsquareC, pProb, param.param_device, RefMap); +inline void bioem::doRefMap_CPU_Reduce(int iRefMap, int iOrient, int iConvStart, + int maxParallelConv, + myparam5_t *comp_params, + myblockCPU_t *comp_block) +{ + //*************************************************************************************** + //***** Reduction of previously compututed log probabilities + bioem_Probability_map &pProbMap = pProb.getProbMap(iRefMap); -#ifdef DEBUG - if (param.param_device.writeCC) - { int cc=0; - for (int cent_x = 0; cent_x < param.param_device.NumberPixels ; cent_x = cent_x + param.param_device.CCdisplace) - { - for (int cent_y = 0; cent_y < param.param_device.NumberPixels ; cent_y = cent_y + param.param_device.CCdisplace) - { - cout << "CHECKCC " << " " << cent_x << " " << cent_y <<" " << lCC[cent_x * param.param_device.NumberPixels + cent_y] / (myfloat_t) (param.param_device.NumberPixels * param.param_device.NumberPixels ) << "\n"; - cc++; - } - } + for (int i = 0; i < maxParallelConv; i++) + { + if (pProbMap.Constoadd < comp_block[i].logpro) + { + pProbMap.Total *= exp(-comp_block[i].logpro + pProbMap.Constoadd); + pProbMap.Constoadd = comp_block[i].logpro; + + // ********** Getting parameters that maximize the probability *********** + int myGlobalId = comp_block[i].id; + int myConv = myGlobalId / param.param_device.NtotDisp; + myGlobalId -= myConv * param.param_device.NtotDisp; + int myX = myGlobalId / param.param_device.NxDisp; + myGlobalId -= myX * param.param_device.NxDisp; + int myY = myGlobalId; + + int dispC = param.param_device.NumberPixels - + param.param_device.maxDisplaceCenter; + myfloat_t value = comp_block[i].value; + + pProbMap.max.max_prob_cent_x = + -((myX * param.param_device.GridSpaceCenter + dispC) - + param.param_device.NumberPixels); + pProbMap.max.max_prob_cent_y = + -((myY * param.param_device.GridSpaceCenter + dispC) - + param.param_device.NumberPixels); + pProbMap.max.max_prob_orient = iOrient; + pProbMap.max.max_prob_conv = iConvStart + myConv; + + pProbMap.max.max_prob_norm = + -(-comp_params[myConv].sumC * RefMap.sum_RefMap[iRefMap] + + param.param_device.Ntotpi * value) / + (comp_params[myConv].sumC * comp_params[myConv].sumC - + comp_params[myConv].sumsquareC * param.param_device.Ntotpi); + pProbMap.max.max_prob_mu = + -(-comp_params[myConv].sumC * value + + comp_params[myConv].sumsquareC * RefMap.sum_RefMap[iRefMap]) / + (comp_params[myConv].sumC * comp_params[myConv].sumC - + comp_params[myConv].sumsquareC * param.param_device.Ntotpi); + +#ifdef DEBUG_PROB + printf("\tProbabilities change: iRefMap %d, iOrient %d, iConv %d, " + "Total %f, Const %f, bestlogpro %f, sumExp %f, bestId %d\n", + iRefMap, iOrient, iConvStart + myConv, pProbMap.Total, + pProbMap.Constoadd, comp_block[i].logpro, comp_block[i].sumExp, + comp_block[i].id); + printf("\tParameters: myConv %d, myX %d, myY %d, cent_x -, cent_y -, " + "probX %d, probY %d\n", + myConv, myX, myY, pProbMap.max.max_prob_cent_x, + pProbMap.max.max_prob_cent_y); +#endif } + pProbMap.Total += + comp_block[i].sumExp * exp(comp_block[i].logpro - pProbMap.Constoadd); +#ifdef DEBUG_PROB + printf("\t\tProbabilities after Reduce: iRefMap %d, iOrient %d, iConv " + "%d, Total %f, Const %f, bestlogpro %f, sumExp %f, bestId %d\n", + iRefMap, iOrient, iConvStart, pProbMap.Total, pProbMap.Constoadd, + comp_block[i].logpro, comp_block[i].sumExp, comp_block[i].id); #endif + // Code for writing angles, not used by default + if (param.param_device.writeAngles) + { + bioem_Probability_angle &pProbAngle = + pProb.getProbAngle(iRefMap, iOrient); + if (pProbAngle.ConstAngle < comp_block[i].logpro) + { + pProbAngle.forAngles *= + exp(-comp_block[i].logpro + pProbAngle.ConstAngle); + pProbAngle.ConstAngle = comp_block[i].logpro; + } + pProbAngle.forAngles += comp_block[i].sumExp * + exp(comp_block[i].logpro - pProbAngle.ConstAngle); + } + } } -int bioem::createProjection(int iMap, mycomplex_t* mapFFT) +int bioem::createProjection(int iMap, mycomplex_t *mapFFT) { // ************************************************************************************** - // **** BioEM Create Projection routine in Euler angles / Quaternions ****************** - // ********************* and turns projection into Fourier space ************************ + // **** BioEM Create Projection routine in Euler angles / Quaternions + // ****************** + // ********************* and turns projection into Fourier space + // ************************ // ************************************************************************************** cuda_custom_timeslot("Projection", iMap, 0, COLOR_PROJECTION); @@ -1140,35 +1560,38 @@ int bioem::createProjection(int iMap, mycomplex_t* mapFFT) myfloat3_t RotatedPointsModel[Model.nPointsModel]; myfloat_t rotmat[3][3]; myfloat_t alpha, gam, beta; - myfloat_t* localproj; + myfloat_t *localproj; localproj = param.fft_scratch_real[omp_get_thread_num()]; - memset(localproj, 0, param.param_device.NumberPixels * param.param_device.NumberPixels * sizeof(*localproj)); + memset(localproj, 0, param.param_device.NumberPixels * + param.param_device.NumberPixels * + sizeof(*localproj)); //*************** Rotating the model **************************** //*************** Quaternions **************************** - if(param.doquater){ + if (param.doquater) + { myfloat_t quater[4]; - //quaternion - quater[0]=param.angles[iMap].pos[0]; - quater[1]=param.angles[iMap].pos[1]; - quater[2]=param.angles[iMap].pos[2]; - quater[3]=param.angles[iMap].quat4; - - //Rotation Matrix for Quaterions (wikipeda) - rotmat[0][0] = 1- 2 * quater[1] * quater[1] - 2 * quater[2] * quater[2]; - rotmat[1][0] = 2 * ( quater[0] * quater[1] - quater[2] * quater[3]); - rotmat[2][0] = 2 * ( quater[0] * quater[2] + quater[1] * quater[3]); - rotmat[0][1] = 2 * ( quater[0] * quater[1] + quater[2] * quater[3]); - rotmat[1][1] = 1- 2 * quater[0] * quater[0] - 2 * quater[2] * quater[2]; - rotmat[2][1] = 2 * ( quater[1] * quater[2] - quater[0] * quater[3]); - rotmat[0][2] = 2 * ( quater[0] * quater[2] - quater[1] * quater[3]); - rotmat[1][2] = 2 * ( quater[1] * quater[2] + quater[0] * quater[3]); - rotmat[2][2] = 1- 2 * quater[0] * quater[0] - 2 * quater[1] * quater[1]; - - - } else{ + // quaternion + quater[0] = param.angles[iMap].pos[0]; + quater[1] = param.angles[iMap].pos[1]; + quater[2] = param.angles[iMap].pos[2]; + quater[3] = param.angles[iMap].quat4; + + // Rotation Matrix for Quaterions (wikipeda) + rotmat[0][0] = 1 - 2 * quater[1] * quater[1] - 2 * quater[2] * quater[2]; + rotmat[1][0] = 2 * (quater[0] * quater[1] - quater[2] * quater[3]); + rotmat[2][0] = 2 * (quater[0] * quater[2] + quater[1] * quater[3]); + rotmat[0][1] = 2 * (quater[0] * quater[1] + quater[2] * quater[3]); + rotmat[1][1] = 1 - 2 * quater[0] * quater[0] - 2 * quater[2] * quater[2]; + rotmat[2][1] = 2 * (quater[1] * quater[2] - quater[0] * quater[3]); + rotmat[0][2] = 2 * (quater[0] * quater[2] - quater[1] * quater[3]); + rotmat[1][2] = 2 * (quater[1] * quater[2] + quater[0] * quater[3]); + rotmat[2][2] = 1 - 2 * quater[0] * quater[0] - 2 * quater[1] * quater[1]; + } + else + { //*************** Euler Angles**************************** // Doing Euler angles instead of Quaternions @@ -1176,9 +1599,10 @@ int bioem::createProjection(int iMap, mycomplex_t* mapFFT) beta = param.angles[iMap].pos[1]; gam = param.angles[iMap].pos[2]; - //*** To see how things are going: -#ifdef DEBUG - cout << "Id " << omp_get_thread_num() << " Angs: " << alpha << " " << beta << " " << gam << "\n"; +//*** To see how things are going: +#ifdef DEBUG + cout << "Id " << omp_get_thread_num() << " Angs: " << alpha << " " << beta + << " " << gam << "\n"; #endif // ********** Creat Rotation with pre-defiend grid of orientations********** // Same notation as in Goldstein and Mathematica @@ -1191,308 +1615,446 @@ int bioem::createProjection(int iMap, mycomplex_t* mapFFT) rotmat[2][0] = sin(beta) * sin(alpha); rotmat[2][1] = -sin(beta) * cos(alpha); rotmat[2][2] = cos(beta); + } -} - -// The rotation matrix is calculated either for the quaternions or for the euler angles - for(int n = 0; n < Model.nPointsModel; n++) - { - RotatedPointsModel[n].pos[0] = 0.0; - RotatedPointsModel[n].pos[1] = 0.0; - RotatedPointsModel[n].pos[2] = 0.0; - } - for(int n = 0; n < Model.nPointsModel; n++) + // The rotation matrix is calculated either for the quaternions or for the + // euler angles + for (int n = 0; n < Model.nPointsModel; n++) + { + RotatedPointsModel[n].pos[0] = 0.0; + RotatedPointsModel[n].pos[1] = 0.0; + RotatedPointsModel[n].pos[2] = 0.0; + } + for (int n = 0; n < Model.nPointsModel; n++) + { + for (int k = 0; k < 3; k++) + { + for (int j = 0; j < 3; j++) { - for(int k = 0; k < 3; k++) - { - for(int j = 0; j < 3; j++) - { - RotatedPointsModel[n].pos[k] += rotmat[k][j] * Model.points[n].point.pos[j]; - } - } + RotatedPointsModel[n].pos[k] += + rotmat[k][j] * Model.points[n].point.pos[j]; } + } + } - - - if(param.printrotmod) { - for(int n = 0; n < Model.nPointsModel; n++) cout << "ROTATED " << iMap << " " << n <<" "<< RotatedPointsModel[n].pos[0] << " " << RotatedPointsModel[n].pos[1] << " " << RotatedPointsModel[n].pos[2] << "\n"; - + if (param.printrotmod) + { + for (int n = 0; n < Model.nPointsModel; n++) + cout << "ROTATED " << iMap << " " << n << " " + << RotatedPointsModel[n].pos[0] << " " + << RotatedPointsModel[n].pos[1] << " " + << RotatedPointsModel[n].pos[2] << "\n"; } int i, j; - //*************** Creating projection **************************** + //*************** Creating projection **************************** //********** Projection with radius *************** int irad; myfloat_t dist, rad2; - myfloat_t tempden=0.0; + myfloat_t tempden = 0.0; - for(int n = 0; n < Model.nPointsModel; n++) + for (int n = 0; n < Model.nPointsModel; n++) + { + if (Model.points[n].radius <= param.pixelSize) { - if(Model.points[n].radius <= param.pixelSize){ - // cout << "Radius less than Pixel size: use keyword NO_PROJECT_RADIUS in inputfile\n"; - i = floor(RotatedPointsModel[n].pos[0] / param.pixelSize + (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f); - j = floor(RotatedPointsModel[n].pos[1] / param.pixelSize + (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f); - - if (i < 0 || j < 0 || i >= param.param_device.NumberPixels || j >= param.param_device.NumberPixels) - { - if (DebugOutput >= 0) cout << "WARNING:::: Model Point out of Projection map: " << i << ", " << j << "\n"; - // continue; - if(not param.ignorepointsout)exit(1); - } - - localproj[i * param.param_device.NumberPixels + j] += Model.points[n].density; - tempden += Model.points[n].density; - - // exit(1); - }else{ - - //Getting Centers of Sphere - i = floor(RotatedPointsModel[n].pos[0] / param.pixelSize + (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f) -param.shiftX; - j = floor(RotatedPointsModel[n].pos[1] / param.pixelSize + (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f) -param.shiftY; - //Getting the radius - irad=int( Model.points[n].radius / param.pixelSize ) + 1; - rad2= Model.points[n].radius * Model.points[n].radius; - - if (i < 0 || j < 0 || i >= param.param_device.NumberPixels || j >= param.param_device.NumberPixels) - { - if (DebugOutput >= 0) cout << "WARNING::: Model Point out of Projection map: " << i << ", " << j << "\n"; - cout << "Model point " << n << "Rotation: " << iMap <<" "<< RotatedPointsModel[n].pos[0] << " " << RotatedPointsModel[n].pos[1] << " " << RotatedPointsModel[n].pos[2] << "\n"; - cout << "Original coor " << n <<" " << Model.points[n].point.pos[0] << " " << Model.points[n].point.pos[1] << " " <= param.param_device.NumberPixels || + j >= param.param_device.NumberPixels) + { + if (DebugOutput >= 0) + cout << "WARNING:::: Model Point out of Projection map: " << i << ", " + << j << "\n"; + // continue; + if (not param.ignorepointsout) + exit(1); } + localproj[i * param.param_device.NumberPixels + j] += + Model.points[n].density; + tempden += Model.points[n].density; + + // exit(1); } + else + { - // To avoid numerical mismatch in projection errors we normalize by the initial density + // Getting Centers of Sphere + i = floor(RotatedPointsModel[n].pos[0] / param.pixelSize + + (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f) - + param.shiftX; + j = floor(RotatedPointsModel[n].pos[1] / param.pixelSize + + (myfloat_t) param.param_device.NumberPixels / 2.0f + 0.5f) - + param.shiftY; + // Getting the radius + irad = int(Model.points[n].radius / param.pixelSize) + 1; + rad2 = Model.points[n].radius * Model.points[n].radius; + + if (i < 0 || j < 0 || i >= param.param_device.NumberPixels || + j >= param.param_device.NumberPixels) + { + if (DebugOutput >= 0) + cout << "WARNING::: Model Point out of Projection map: " << i << ", " + << j << "\n"; + cout << "Model point " << n << "Rotation: " << iMap << " " + << RotatedPointsModel[n].pos[0] << " " + << RotatedPointsModel[n].pos[1] << " " + << RotatedPointsModel[n].pos[2] << "\n"; + cout << "Original coor " << n << " " << Model.points[n].point.pos[0] + << " " << Model.points[n].point.pos[1] << " " + << Model.points[n].point.pos[2] << "\n"; + cout << "WARNING: Angle orient " << n << " " + << param.angles[iMap].pos[0] << " " << param.angles[iMap].pos[1] + << " " << param.angles[iMap].pos[2] << " out " << i << " " << j + << "\n"; + cout << "WARNING: MPI rank " << mpi_rank << "\n"; + // continue; + if (not param.ignorepointsout) + exit(1); + } - myfloat_t ratioDen; - - ratioDen = Model.NormDen / tempden ; + // Projecting over the radius + for (int ii = i - irad; ii < i + irad + 1; ii++) + { + for (int jj = j - irad; jj < j + irad + 1; jj++) + { + dist = ((myfloat_t)(ii - i) * (ii - i) + (jj - j) * (jj - j)) * + param.pixelSize * param.pixelSize; // at pixel center + if (dist < rad2) + { + localproj[ii * param.param_device.NumberPixels + jj] += + param.pixelSize * param.pixelSize * 2 * sqrt(rad2 - dist) * + Model.points[n].density * 3 / + (4 * M_PI * Model.points[n].radius * rad2); + tempden += param.pixelSize * param.pixelSize * 2 * + sqrt(rad2 - dist) * Model.points[n].density * 3 / + (4 * M_PI * Model.points[n].radius * rad2); + } + } + } + } + } + + // To avoid numerical mismatch in projection errors we normalize by the + // initial density - for(int i = 0; i < param.param_device.NumberPixels ; i++){ - for(int j = 0; j < param.param_device.NumberPixels ; j++){ - localproj[ i * param.param_device.NumberPixels + j] *= ratioDen; - } - } + myfloat_t ratioDen; + + ratioDen = Model.NormDen / tempden; + + for (int i = 0; i < param.param_device.NumberPixels; i++) + { + for (int j = 0; j < param.param_device.NumberPixels; j++) + { + localproj[i * param.param_device.NumberPixels + j] *= ratioDen; + } + } - // **** Output Just to check**** +// **** Output Just to check**** #ifdef DEBUG // if(iMap == 0) { ofstream myexamplemap; ofstream myexampleRot; - myexamplemap.open ("MAP_i10"); - myexampleRot.open ("Rot_i10"); + myexamplemap.open("MAP_i10"); + myexampleRot.open("Rot_i10"); myexamplemap << "ANGLES " << alpha << " " << beta << " " << gam << "\n"; - for(int k = 0; k < param.param_device.NumberPixels; k++) - { - for(int j = 0; j < param.param_device.NumberPixels; j++) myexamplemap << "\nMAP " << k << " " << j << " " << localproj[k * param.param_device.NumberPixels + j]; - } + for (int k = 0; k < param.param_device.NumberPixels; k++) + { + for (int j = 0; j < param.param_device.NumberPixels; j++) + myexamplemap << "\nMAP " << k << " " << j << " " + << localproj[k * param.param_device.NumberPixels + j]; + } myexamplemap << " \n"; - for(int n = 0; n < Model.nPointsModel; n++)myexampleRot << "\nCOOR " << RotatedPointsModel[n].pos[0] << " " << RotatedPointsModel[n].pos[1] << " " << RotatedPointsModel[n].pos[2]; + for (int n = 0; n < Model.nPointsModel; n++) + myexampleRot << "\nCOOR " << RotatedPointsModel[n].pos[0] << " " + << RotatedPointsModel[n].pos[1] << " " + << RotatedPointsModel[n].pos[2]; myexamplemap.close(); myexampleRot.close(); } #endif - // ***** Converting projection to Fourier Space for Convolution later with kernel**** + // ***** Converting projection to Fourier Space for Convolution later with + // kernel**** // ********** Omp Critical is necessary with FFTW******* myfftw_execute_dft_r2c(param.fft_plan_r2c_forward, localproj, mapFFT); cuda_custom_timeslot_end; - return(0); + return (0); } -int bioem::createConvolutedProjectionMap(int iMap, int iConv, mycomplex_t* lproj, myfloat_t* Mapconv, mycomplex_t* localmultFFT, myfloat_t& sumC, myfloat_t& sumsquareC) +int bioem::createConvolutedProjectionMap(int iMap, int iConv, + mycomplex_t *lproj, + mycomplex_t *localmultFFT, + myfloat_t &sumC, myfloat_t &sumsquareC) { // ************************************************************************************** - // **** BioEM Create Convoluted Projection Map routine, multiplies in Fourier ********** - // **************** calculated Projection with convoluted precalculated Kernel*********** - // *************** and Backtransforming it to real Space ******************************** + // **** BioEM Create Convoluted Projection Map routine, multiplies in Fourier + // ********** + // **************** calculated Projection with convoluted precalculated + // Kernel*********** + // *************** and Backtransforming it to real Space + // ******************************** // ************************************************************************************** - cuda_custom_timeslot("Convolution", iMap, iConv, COLOR_CONVOLUTION); - mycomplex_t* tmp = param.fft_scratch_complex[omp_get_thread_num()]; - // **** Multiplying FFTmap of model with corresponding kernel ******* - const mycomplex_t* refCTF = ¶m.refCTF[iConv * param.FFTMapSize]; + const mycomplex_t *refCTF = ¶m.refCTF[iConv * param.FFTMapSize]; - for(int i = 0; i < param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D; i++) - { - localmultFFT[i][0] = ( lproj[i][0] * refCTF[i][0] + lproj[i][1] * refCTF[i][1] ) ; - localmultFFT[i][1] = ( lproj[i][1] * refCTF[i][0] - lproj[i][0] * refCTF[i][1] ) ; - } + for (int i = 0; i < param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D; + i++) + { + localmultFFT[i][0] = + (lproj[i][0] * refCTF[i][0] + lproj[i][1] * refCTF[i][1]); + localmultFFT[i][1] = + (lproj[i][1] * refCTF[i][0] - lproj[i][0] * refCTF[i][1]); + } - // *** Calculating Cross-correlations of cal-convoluted map with its self ***** (for BioEM formula) + // *** Calculating Cross-correlations of cal-convoluted map with its self + // ***** (for BioEM formula) sumC = localmultFFT[0][0]; //**** Calculating the second norm and storing it (for BioEM formula) sumsquareC = 0; - if (FFTAlgo) + + //*** With FFT algorithm + int jloopend = param.param_device.NumberFFTPixels1D; + if ((param.param_device.NumberPixels & 1) == 0) + jloopend--; + for (int i = 0; i < param.param_device.NumberPixels; i++) + { + for (int j = 1; j < jloopend; j++) { - //*** With FFT algorithm - int jloopend = param.param_device.NumberFFTPixels1D; - if ((param.param_device.NumberPixels & 1) == 0) jloopend--; - for(int i = 0; i < param.param_device.NumberPixels; i++) - { - for (int j = 1;j < jloopend;j++) - { - int k = i * param.param_device.NumberFFTPixels1D + j; - sumsquareC += (localmultFFT[k][0] * localmultFFT[k][0] + localmultFFT[k][1] * localmultFFT[k][1]) * 2; - } - int k = i * param.param_device.NumberFFTPixels1D; - sumsquareC += localmultFFT[k][0] * localmultFFT[k][0] + localmultFFT[k][1] * localmultFFT[k][1]; - if ((param.param_device.NumberPixels & 1) == 0) - { - k += param.param_device.NumberFFTPixels1D - 1; - sumsquareC += localmultFFT[k][0] * localmultFFT[k][0] + localmultFFT[k][1] * localmultFFT[k][1]; - } - } - - myfloat_t norm2 = (myfloat_t) (param.param_device.NumberPixels * param.param_device.NumberPixels); - sumsquareC = sumsquareC / norm2; + int k = i * param.param_device.NumberFFTPixels1D + j; + sumsquareC += (localmultFFT[k][0] * localmultFFT[k][0] + + localmultFFT[k][1] * localmultFFT[k][1]) * + 2; } - else + int k = i * param.param_device.NumberFFTPixels1D; + sumsquareC += localmultFFT[k][0] * localmultFFT[k][0] + + localmultFFT[k][1] * localmultFFT[k][1]; + if ((param.param_device.NumberPixels & 1) == 0) { - //***** Slow No FFT *** + k += param.param_device.NumberFFTPixels1D - 1; + sumsquareC += localmultFFT[k][0] * localmultFFT[k][0] + + localmultFFT[k][1] * localmultFFT[k][1]; + } + } - //**** Backtransforming the convoluted map it into real space - //FFTW_C2R will destroy the input array, so we have to work on a copy here - memcpy(tmp, localmultFFT, sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D); + myfloat_t norm2 = (myfloat_t)(param.param_device.NumberPixels * + param.param_device.NumberPixels); + sumsquareC = sumsquareC / norm2; - // **** Bringing convoluted Map to real Space **** - myfftw_execute_dft_c2r(param.fft_plan_c2r_backward, tmp, Mapconv); + cuda_custom_timeslot_end; - for(int i = 0; i < param.param_device.NumberPixels * param.param_device.NumberPixels; i++) - { - sumsquareC += Mapconv[i] * Mapconv[i]; - // cout << "CONV " << i << " " << Mapconv[i] << "\n"; - } + return (0); +} - myfloat_t norm2 = (myfloat_t) (param.param_device.NumberPixels * param.param_device.NumberPixels); - myfloat_t norm4 = norm2 * norm2; - sumsquareC = sumsquareC / norm4; - } +int bioem::createConvolutedProjectionMap_noFFT(mycomplex_t *lproj, + myfloat_t *Mapconv, + mycomplex_t *localmultFFT, + myfloat_t &sumC, + myfloat_t &sumsquareC) +{ + // ************************************************************************************** + // **** BioEM Create Convoluted Projection Map routine, multiplies in Fourier + // ********** + // **************** calculated Projection with convoluted precalculated + // Kernel*********** + // *************** and Backtransforming it to real Space + // ******************************** + // ************************************************************************************** + // *************** This routine is only for printing Model + // ****************************** + // ************************************************************************************** + + mycomplex_t *tmp = param.fft_scratch_complex[omp_get_thread_num()]; + + // **** Multiplying FFTmap of model with corresponding kernel ******* + const mycomplex_t *refCTF = param.refCTF; + + for (int i = 0; i < param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D; + i++) + { + localmultFFT[i][0] = + (lproj[i][0] * refCTF[i][0] + lproj[i][1] * refCTF[i][1]); + localmultFFT[i][1] = + (lproj[i][1] * refCTF[i][0] - lproj[i][0] * refCTF[i][1]); + } + // *** Calculating Cross-correlations of cal-convoluted map with its self + // ***** (for BioEM formula) + sumC = localmultFFT[0][0]; + + //**** Calculating the second norm and storing it (for BioEM formula) + sumsquareC = 0; + + //***** Slow No FFT *** + //**** Backtransforming the convoluted map it into real space + // FFTW_C2R will destroy the input array, so we have to work on a copy here + memcpy(tmp, localmultFFT, sizeof(mycomplex_t) * + param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D); + + // **** Bringing convoluted Map to real Space **** + myfftw_execute_dft_c2r(param.fft_plan_c2r_backward, tmp, Mapconv); + + for (int i = 0; + i < param.param_device.NumberPixels * param.param_device.NumberPixels; + i++) + { + sumsquareC += Mapconv[i] * Mapconv[i]; + // cout << "CONV " << i << " " << Mapconv[i] << "\n"; + } + + myfloat_t norm2 = (myfloat_t)(param.param_device.NumberPixels * + param.param_device.NumberPixels); + myfloat_t norm4 = norm2 * norm2; + sumsquareC = sumsquareC / norm4; // ************************************************************************************** - // *********** Routine for printing out the best projetion ****************************** + // *********** Routine for printing out the best projetion + // ****************************** // ************************************************************************************** - if (mpi_rank == 0 && param.printModel) - { -// MTRand mtr; - bran::mt19937 gen; - //Generating random seed so the maps do not have correlated Noise - gen.seed(static_cast(std::time(0))); - //Uniform Noise: bran::uniform_int_distribution<> dist(1, 6); - - //Gaussian noise - bran::normal_distribution <> distn(0.0,param.stnoise); - - memcpy(tmp, localmultFFT, sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D); - - // **** Bringing convoluted Map to real Space **** - myfftw_execute_dft_c2r(param.fft_plan_c2r_backward, tmp, Mapconv); - - myfloat_t norm2 = (myfloat_t) (param.param_device.NumberPixels * param.param_device.NumberPixels); - - ofstream myexamplemap; - myexamplemap.open ("BESTMAP"); - for(int k = 0; k < param.param_device.NumberPixels; k++) - { - for(int j = 0; j < param.param_device.NumberPixels; j++) { - if(!param.withnoise){ - myexamplemap << "\nMAP " << k+param.ddx << " " << j+param.ddy << " " << Mapconv[k * param.param_device.NumberPixels + j] / norm2 *param.bestnorm +param.bestoff ; - } else { - myexamplemap << "\nMAP " << k+param.ddx << " " << j+param.ddy << " " << Mapconv[k * param.param_device.NumberPixels + j] / norm2 *param.bestnorm +param.bestoff+distn(gen); -// cout << distn(gen) << "CHECK\n"; - } - } - myexamplemap << " \n"; - } - myexamplemap.close(); - - cout << "\n\nBest map printed in file: BESTMAP with gnuplot format in columns 2, 3 and 4. \n\n\n"; - exit(1); + // Calling random number routine from MersenneTwister.h + MTRand mtr; - } + // Generating random seed so the maps do not have correlated Noise + mtr.seed(static_cast(std::time(0))); - cuda_custom_timeslot_end; + memcpy(tmp, localmultFFT, sizeof(mycomplex_t) * + param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D); + + // **** Bringing convoluted Map to real Space **** + myfftw_execute_dft_c2r(param.fft_plan_c2r_backward, tmp, Mapconv); + + // Calculating the cross-correlation to the ref maps + // PILAR WORK RefMap.maps + if (param.BestmapCalcCC) + { + myfloat_t ccbm = 0.; + int kk, jj; + + for (int k = 0; k < param.param_device.NumberPixels; k++) + { + for (int j = 0; j < param.param_device.NumberPixels; j++) + { + // Missing periodicity and centers; + kk = k; + jj = j; + if (k - param.ddx < 0) + kk = param.param_device.NumberPixels - (k - param.ddx); + if (j - param.ddy < 0) + jj = param.param_device.NumberPixels - (j - param.ddy); + if (k - param.ddx >= param.param_device.NumberPixels) + kk = k - param.ddx - param.param_device.NumberPixels; + if (j - param.ddy >= param.param_device.NumberPixels) + jj = j - param.ddy - param.param_device.NumberPixels; + + ccbm += (Mapconv[kk * param.param_device.NumberPixels + jj] / norm2 * + param.bestnorm - + RefMap.maps[k * param.param_device.NumberPixels + j]) * + (Mapconv[kk * param.param_device.NumberPixels + jj] / norm2 * + param.bestnorm - + RefMap.maps[k * param.param_device.NumberPixels + j]); + } + } + cout << "CROSS CORELATION " << ccbm << "\n"; + } + else + { + ofstream myexamplemap; + myexamplemap.open("BESTMAP"); + for (int k = 0; k < param.param_device.NumberPixels; k++) + { + for (int j = 0; j < param.param_device.NumberPixels; j++) + { + if (!param.withnoise) + { + myexamplemap << "\nMAP " << k + param.ddx << " " << j + param.ddy + << " " + << Mapconv[k * param.param_device.NumberPixels + j] / + norm2 * param.bestnorm + + param.bestoff; + if (k + param.ddx < param.param_device.NumberPixels && + j + param.ddy < param.param_device.NumberPixels) + { + myexamplemap + << "\nMAPddx " << k << " " << j << " " + << Mapconv[(k - param.ddx) * param.param_device.NumberPixels + + j - param.ddy] / + norm2 * param.bestnorm + + param.bestoff; + } + } + else + { + myexamplemap << "\nMAP " << k + param.ddx << " " << j + param.ddy + << " " + << Mapconv[k * param.param_device.NumberPixels + j] / + norm2 * param.bestnorm + + param.bestoff + + mtr.randNorm(0.0, + param.stnoise); //\\+ distn(gen); + // cout << distn(gen) << "CHECK\n"; + } + } + myexamplemap << " \n"; + } + myexamplemap.close(); - return(0); + cout << "\n\nBest map printed in file: BESTMAP with gnuplot format in " + "columns 2, 3 and 4. \n\n\n"; + } + return (0); } -int bioem::calcross_cor(myfloat_t* localmap, myfloat_t& sum, myfloat_t& sumsquare) +int bioem::calcross_cor(myfloat_t *localmap, myfloat_t &sum, + myfloat_t &sumsquare) { - // *********************** Routine to calculate Cross correlations*********************** + // *********************** Routine to calculate Cross + // correlations*********************** sum = 0.0; sumsquare = 0.0; for (int i = 0; i < param.param_device.NumberPixels; i++) + { + for (int j = 0; j < param.param_device.NumberPixels; j++) { - for (int j = 0; j < param.param_device.NumberPixels; j++) - { - // Calculate Sum of pixels - sum += localmap[i * param.param_device.NumberPixels + j]; - // Calculate Sum of pixels squared - sumsquare += localmap[i * param.param_device.NumberPixels + j] * localmap[i * param.param_device.NumberPixels + j]; - } + // Calculate Sum of pixels + sum += localmap[i * param.param_device.NumberPixels + j]; + // Calculate Sum of pixels squared + sumsquare += localmap[i * param.param_device.NumberPixels + j] * + localmap[i * param.param_device.NumberPixels + j]; } - return(0); + } + return (0); } -int bioem::deviceInit() -{ - return(0); -} +int bioem::deviceInit() { return (0); } -int bioem::deviceStartRun() -{ - return(0); -} +int bioem::deviceStartRun() { return (0); } -int bioem::deviceFinishRun() -{ - return(0); -} +int bioem::deviceFinishRun() { return (0); } -void* bioem::malloc_device_host(size_t size) -{ - return(mallocchk(size)); -} +void *bioem::malloc_device_host(size_t size) { return (mallocchk(size)); } -void bioem::free_device_host(void* ptr) -{ - free(ptr); -} +void bioem::free_device_host(void *ptr) { free(ptr); } void bioem::rebalanceWrapper(int workload) { diff --git a/bioem_algorithm.h b/bioem_algorithm.h index c1936efe85e6e38998f7c1f5b4caf566fec361df..494ba6599d51fd63d27b895070beca3ae5ffe1fb 100644 --- a/bioem_algorithm.h +++ b/bioem_algorithm.h @@ -1,505 +1,200 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ #ifndef BIOEM_ALGORITHM_H #define BIOEM_ALGORITHM_H -//#include -#ifndef BIOEM_GPUCODE -//#define SSECODE //Explicit SSE code, not correct yet since loop counter is assumed multiple of 4, anyway not faster than autovectorized code, only implemented for float, not for double. -#endif - -#ifdef SSECODE -#include -#include -#endif - -template -__device__ static inline void update_prob(const myfloat_t logpro, const int iRefMap, const int iOrient, const int iConv, const int cent_x, const int cent_y, bioem_Probability& pProb, bool doAngle, myfloat_t* buf3 = NULL, int* bufint = NULL) -{ - - // *********** Not using FFT ALGORITHM ****************** - //*********** Routine to perform the numerical BioEM intergal *********** - - // ******* Summing total Probabilities ************* - - bioem_Probability_map& pProbMap = pProb.getProbMap(iRefMap); - - // ******* Need a constant because of numerical divergence***** - if(pProbMap.Constoadd < logpro) - { - pProbMap.Total = pProbMap.Total * exp(-logpro + pProbMap.Constoadd); - pProbMap.Constoadd = logpro; - - // ********** Getting parameters that maximize the probability *********** - if (GPUAlgo == 2) - { - bufint[0] = 1; - buf3[1] = logpro; - } - else - { - pProbMap.max.max_prob_cent_x = - cent_x; - pProbMap.max.max_prob_cent_y = - cent_y; - } - pProbMap.max.max_prob_orient = iOrient; - pProbMap.max.max_prob_conv = iConv; - // pProbMap.max.max_prob_norm = - ( -sumC * RefMap.sum_RefMap[iRefMap] + param.Ntotpi * value ) / ( sumC * sumC - sumsquareC * param.Ntotpi); - // pProbMap.max.max_prob_mu = - ( -sumC * value + sumsquareC * RefMap.sum_RefMap[iRefMap] ) / ( sumC * sumC - sumsquareC * param.Ntotpi); - } - if (GPUAlgo != 2) pProbMap.Total += exp(logpro - pProbMap.Constoadd); - - if (doAngle) - { - bioem_Probability_angle& pProbAngle = pProb.getProbAngle(iRefMap, iOrient); - - //Summing probabilities for each orientation - if(pProbAngle.ConstAngle < logpro) - { - pProbAngle.forAngles = pProbAngle.forAngles * exp(-logpro + pProbAngle.ConstAngle); - pProbAngle.ConstAngle = logpro; - } - - if (GPUAlgo != 2) pProbAngle.forAngles += exp(logpro - pProbAngle.ConstAngle); - } -} - -__device__ static inline myfloat_t calc_logpro(const bioem_param_device& param, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t sum, const myfloat_t sumsquare, const myfloat_t crossproMapConv, const myfloat_t sumref, const myfloat_t sumsquareref) +__device__ static inline myprob_t +calc_logpro(const bioem_param_device ¶m, const myfloat_t amp, + const myfloat_t pha, const myfloat_t env, const myfloat_t sum, + const myfloat_t sumsquare, const myfloat_t crossproMapConv, + const myfloat_t sumref, const myfloat_t sumsquareref) { //*** MAIN ROUTINE TO CALCULATE THE LOGPRO FOR ALL KERNELS*************// // **** calculate the log posterior of Eq. of Pmw in SI of JSB paper ***// // Related to Reference calculated Projection - const myfloat_t ForLogProb = (sumsquare * param.Ntotpi - sum * sum); + const myprob_t ForLogProb = sumsquare * param.Ntotpi - sum * sum; // Products of different cross-correlations (first element in formula) - const myfloat_t firstele = param.Ntotpi * (sumsquareref * sumsquare - crossproMapConv * crossproMapConv) + - 2 * sumref * sum * crossproMapConv - sumsquareref * sum * sum - sumref * sumref * sumsquare; + const myprob_t firstele = + param.Ntotpi * + (sumsquareref * sumsquare - crossproMapConv * crossproMapConv) + + 2 * sumref * sum * crossproMapConv - sumsquareref * sum * sum - + sumref * sumref * sumsquare; /// ******* Calculating log of Prob********* - // As in fortran code: logpro=(3-Ntotpi)*0.5*log(firstele/pConvMap[iOrient].ForLogProbfromConv[iConv])+(Ntotpi*0.5-2)*log(Ntotpi-2)-0.5*log(pConvMap[iOrient].ForLogProbfromConv[iConv])+0.5*log(PI)+(1-Ntotpi*0.5)*(log(2*PI)+1); - - myfloat_t logpro = (3 - param.Ntotpi) * 0.5 * log(firstele) + (param.Ntotpi * 0.5 - 2) * log((param.Ntotpi - 2) * ForLogProb); - - //*************Adding Gaussian Prior to envelope & Defocus parameter****************** - - if(not param.tousepsf){ - logpro = logpro - env * env / 2. / param.sigmaPriorbctf / param.sigmaPriorbctf - - (pha - param.Priordefcent ) * (pha - param.Priordefcent ) / 2. / param.sigmaPriordefo / param.sigmaPriordefo ; - } else { - myfloat_t envF,phaF; - envF = 4.* M_PI * M_PI * env / ( env * env + pha * pha) ; - phaF = 4.* M_PI * M_PI * pha / ( env * env + pha * pha); - logpro = logpro - envF * envF / 2. / param.sigmaPriorbctf / param.sigmaPriorbctf - (phaF - param.Priordefcent ) * (phaF - param.Priordefcent ) / 2. / param.sigmaPriordefo / param.sigmaPriordefo ; + // As in fortran code: + // logpro=(3-Ntotpi)*0.5*log(firstele/pConvMap[iOrient].ForLogProbfromConv[iConv])+(Ntotpi*0.5-2)*log(Ntotpi-2)-0.5*log(pConvMap[iOrient].ForLogProbfromConv[iConv])+0.5*log(PI)+(1-Ntotpi*0.5)*(log(2*PI)+1); + + myprob_t logpro = + (3 - param.Ntotpi) * 0.5 * log(firstele) + + (param.Ntotpi * 0.5 - 2) * log((param.Ntotpi - 2) * ForLogProb); + + //*************Adding Gaussian Prior to envelope & Defocus + // parameter****************** + + if (not param.tousepsf) + { + logpro -= env * env / 2. / param.sigmaPriorbctf / param.sigmaPriorbctf - + (pha - param.Priordefcent) * (pha - param.Priordefcent) / 2. / + param.sigmaPriordefo / param.sigmaPriordefo - + (amp - param.Priorampcent) * (amp - param.Priorampcent) / 2. / + param.sigmaPrioramp / param.sigmaPrioramp; + } + else + { + myprob_t envF, phaF; + envF = 4. * M_PI * M_PI * env / (env * env + pha * pha); + phaF = 4. * M_PI * M_PI * pha / (env * env + pha * pha); + logpro -= envF * envF / 2. / param.sigmaPriorbctf / param.sigmaPriorbctf - + (phaF - param.Priordefcent) * (phaF - param.Priordefcent) / 2. / + param.sigmaPriordefo / param.sigmaPriordefo - + (amp - param.Priorampcent) * (amp - param.Priorampcent) / 2. / + param.sigmaPrioramp / param.sigmaPrioramp; } - return(logpro); + return (logpro); } -__device__ static inline void calProb(int iRefMap, int iOrient, int iConv, myfloat_t amp, myfloat_t pha, myfloat_t env, myfloat_t sumC, myfloat_t sumsquareC, myfloat_t value, int disx, int disy, bioem_Probability& pProb, const bioem_param_device& param, const bioem_RefMap& RefMap) +__device__ static inline void +calProb(int iRefMap, int iOrient, int iConv, const myfloat_t amp, + const myfloat_t pha, const myfloat_t env, const myfloat_t sumC, + const myfloat_t sumsquareC, myfloat_t value, int disx, int disy, + bioem_Probability &pProb, const bioem_param_device ¶m, + const bioem_RefMap &RefMap) { // IMPORTANT ROUTINE Summation of LogProb using FFTALGO // ******************************************************** // *********** Calculates the BioEM probability *********** // ******************************************************** - myfloat_t logpro = calc_logpro(param, amp, pha, env, sumC, sumsquareC, value, RefMap.sum_RefMap[iRefMap], RefMap.sumsquare_RefMap[iRefMap]); + myfloat_t logpro = + calc_logpro(param, amp, pha, env, sumC, sumsquareC, value, + RefMap.sum_RefMap[iRefMap], RefMap.sumsquare_RefMap[iRefMap]); - //GCC is too stupid to inline properly, so the code is copied here - //update_prob<-1>(logpro, iRefMap, iOrient, iConv, disx, disy, pProb, param.writeAngles); - - bioem_Probability_map& pProbMap = pProb.getProbMap(iRefMap); - - // printf("Separate PtotBef: %f Const: %f logProb %f %d %d %d \n",pProbMap.Total,pProbMap.Constoadd,logpro,iRefMap,iOrient,iConv); - if(pProbMap.Constoadd < logpro) - { - pProbMap.Total = pProbMap.Total * exp(-logpro + pProbMap.Constoadd); - pProbMap.Constoadd = logpro; +#ifdef DEBUG_PROB + printf("\t\t\tProb: iRefMap %d, iOrient %d, iConv %d, " + "disx %d, disy %d, address -, value %f, logpro %f\n", + iRefMap, iOrient, iConv, disx, disy, value, logpro); +#endif - // ********** Getting parameters that maximize the probability *********** - pProbMap.max.max_prob_cent_x = - disx; - pProbMap.max.max_prob_cent_y = - disy; - pProbMap.max.max_prob_orient = iOrient; - pProbMap.max.max_prob_conv = iConv; - pProbMap.max.max_prob_norm = - ( -sumC * RefMap.sum_RefMap[iRefMap] + param.Ntotpi * value ) / ( sumC * sumC - sumsquareC * param.Ntotpi); - pProbMap.max.max_prob_mu = - ( -sumC * value + sumsquareC * RefMap.sum_RefMap[iRefMap] ) / ( sumC * sumC - sumsquareC * param.Ntotpi); - } + bioem_Probability_map &pProbMap = pProb.getProbMap(iRefMap); + + if (pProbMap.Constoadd < logpro) + { + pProbMap.Total *= exp(-logpro + pProbMap.Constoadd); + pProbMap.Constoadd = logpro; + + // ********** Getting parameters that maximize the probability *********** + pProbMap.max.max_prob_cent_x = -disx; + pProbMap.max.max_prob_cent_y = -disy; + pProbMap.max.max_prob_orient = iOrient; + pProbMap.max.max_prob_conv = iConv; + pProbMap.max.max_prob_norm = + -(-sumC * RefMap.sum_RefMap[iRefMap] + param.Ntotpi * value) / + (sumC * sumC - sumsquareC * param.Ntotpi); + pProbMap.max.max_prob_mu = + -(-sumC * value + sumsquareC * RefMap.sum_RefMap[iRefMap]) / + (sumC * sumC - sumsquareC * param.Ntotpi); + +#ifdef DEBUG_PROB + printf("\tProbabilities change: iRefMap %d, iOrient %d, iConv %d, Total " + "%f, Const %f, bestlogpro %f, sumExp -, bestId -\n", + iRefMap, iOrient, iConv, pProbMap.Total, pProbMap.Constoadd, logpro); + printf("\tParameters: iConv %d, myX -, myY -, disx %d, disy %d, probX " + "%d, probY %d\n", + iConv, disx, disy, pProbMap.max.max_prob_cent_x, + pProbMap.max.max_prob_cent_y); +#endif + } pProbMap.Total += exp(logpro - pProbMap.Constoadd); - +#ifdef DEBUG_PROB + printf("\t\tProbabilities after Sum: iRefMap %d, iOrient %d, iConv %d, " + "Total %f, Const %f, bestlogpro %f, sumExp -, bestId -\n", + iRefMap, iOrient, iConv, pProbMap.Total, pProbMap.Constoadd, logpro); +#endif if (param.writeAngles) - { - bioem_Probability_angle& pProbAngle = pProb.getProbAngle(iRefMap, iOrient); - // if(iOrient==1)printf("Separate Ptot: %f Const: %f logProb %f param: %d %d %d \n",logpro,pProbAngle.ConstAngle,pProbAngle.forAngles,disx,disx,iOrient); - - if(pProbAngle.ConstAngle < logpro) - { - pProbAngle.forAngles = pProbAngle.forAngles * exp(-logpro + pProbAngle.ConstAngle); - pProbAngle.ConstAngle = logpro; - } - pProbAngle.forAngles += exp(logpro - pProbAngle.ConstAngle); - // if(iOrient==5)printf("After separate Ptot: %f Const: %f logProb %f \n",logpro,pProbAngle.ConstAngle,pProbAngle.forAngles); - } + { + bioem_Probability_angle &pProbAngle = pProb.getProbAngle(iRefMap, iOrient); -} - -__device__ static inline void doRefMapFFT(const int iRefMap, const int iOrient, const int iConv, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t* lCC, const myfloat_t sumC, const myfloat_t sumsquareC, bioem_Probability& pProb, const bioem_param_device& param, const bioem_RefMap& RefMap) -{ - //******************** Using FFT algorithm ************************** - //******************* Get cross-crollation of Ical to Iobs ******************* - //*********** Routine to get the Cross-Corellation from lCC for the interested center displacement ************* - - for (int cent_x = 0; cent_x <= param.maxDisplaceCenter; cent_x = cent_x + param.GridSpaceCenter) + if (pProbAngle.ConstAngle < logpro) { - for (int cent_y = 0; cent_y <= param.maxDisplaceCenter; cent_y = cent_y + param.GridSpaceCenter) - { - calProb(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / (myfloat_t) (param.NumberPixels * param.NumberPixels), cent_x, cent_y, pProb, param, RefMap); - } - for (int cent_y = param.NumberPixels - param.maxDisplaceCenter; cent_y < param.NumberPixels; cent_y = cent_y + param.GridSpaceCenter) - { - calProb(iRefMap, iOrient, iConv,amp, pha, env, sumC, sumsquareC, (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / (myfloat_t) (param.NumberPixels * param.NumberPixels), cent_x, cent_y - param.NumberPixels, pProb, param, RefMap); - } + pProbAngle.forAngles *= exp(-logpro + pProbAngle.ConstAngle); + pProbAngle.ConstAngle = logpro; } - for (int cent_x = param.NumberPixels - param.maxDisplaceCenter; cent_x < param.NumberPixels; cent_x = cent_x + param.GridSpaceCenter) - { - for (int cent_y = 0; cent_y < param.maxDisplaceCenter; cent_y = cent_y + param.GridSpaceCenter) - { - calProb(iRefMap, iOrient, iConv,amp, pha, env, sumC, sumsquareC, (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / (myfloat_t) (param.NumberPixels * param.NumberPixels), cent_x - param.NumberPixels, cent_y, pProb, param, RefMap); - } - for (int cent_y = param.NumberPixels - param.maxDisplaceCenter ; cent_y < param.NumberPixels; cent_y = cent_y + param.GridSpaceCenter) - { - calProb(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / (myfloat_t) (param.NumberPixels * param.NumberPixels), cent_x - param.NumberPixels, cent_y - param.NumberPixels, pProb, param, RefMap); - } - } - - //************ The following if is not in the manual*********** - if (param.writeCC) - { - // If the Cross-correlation is to be written out and stored using Bayesian analysis - int cc=0; - for (int cent_x = 0; cent_x < param.NumberPixels ; cent_x = cent_x + param.CCdisplace) - { - for (int cent_y = 0; cent_y < param.NumberPixels ; cent_y = cent_y + param.CCdisplace) - { - - - bioem_Probability_cc& pProbCC = pProb.getProbCC(iRefMap, cc); - - myfloat_t ttmp,ttmp2; - ttmp2 = (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / (myfloat_t) (param.NumberPixels * param.NumberPixels); - - if(not param.flipped){ - //Here we are inverting the sign of the cross-correlation for the images that are not flipped - ttmp=-ttmp2; } - else{ ttmp=ttmp2; } - - if(!param.CCwithBayes){ - // Storing Only the Maximum both for flipped and not flipped - - if(pProbCC.forCC < ttmp) pProbCC.forCC = ttmp; - - }else { - // Storing the Cross-correlation with Bayesian formalism - if(pProbCC.ConstCC < ttmp) - { - pProbCC.forCC = pProbCC.forCC * exp(-ttmp + pProbCC.ConstCC); - pProbCC.ConstCC = ttmp; - } - pProbCC.forCC += exp(ttmp - pProbCC.ConstCC); - - } - // printf("Separate %d %d Ptot: %f Const: %f logProb %f \n",cent_x,cent_y,pProbCC.forCC,pProbCC.ConstCC,ttmp); - cc++; - - } - } - } - - + pProbAngle.forAngles += exp(logpro - pProbAngle.ConstAngle); + } } -template - __device__ static inline void compareRefMap(const int iRefMap, const int iOrient, const int iConv, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t sumC, - const myfloat_t sumsquareC, const myfloat_t* Mapconv, bioem_Probability& pProb, const bioem_param_device& param, const RefT& RefMap, - const int cent_x, const int cent_y, const int myShift = 0, const int nShifts2 = 0, const int myRef = 0, const bool threadActive = true) +__device__ static inline void +doRefMapFFT(const int iRefMap, const int iOrient, const int iConv, + const myfloat_t amp, const myfloat_t pha, const myfloat_t env, + const myfloat_t sumC, const myfloat_t sumsquareC, + const myfloat_t *lCC, bioem_Probability &pProb, + const bioem_param_device ¶m, const bioem_RefMap &RefMap) { - - //********************* Non FOURIER ALGORITHMS (refer to David) *********** - // ********************** Calculating BioEM Probability ******************************** - // ************************* Loop of center displacement here *************************** - - // Taking into account the center displacement - - // Inizialzing crosscorrelations of calculated projected convolutions -#ifdef SSECODE - myfloat_t sum, sumsquare, crossproMapConv; - __m128 sum_v = _mm_setzero_ps(), sumsquare_v = _mm_setzero_ps(), cross_v = _mm_setzero_ps(), d1, d2; -#else - myfloat_t sum = 0.0; - myfloat_t sumsquare = 0.0; - myfloat_t crossproMapConv = 0.0; -#endif - // Loop over Pixels to calculate dot product and cross-correlations of displaced Ref Conv. Map - myfloat_t logpro; - if (GPUAlgo != 2 || threadActive) + //******************** Using FFT algorithm ************************** + //******************* Get cross-crollation of Ical to Iobs ******************* + //*********** Routine to get the Cross-Corellation from lCC for the interested + // center displacement ************* + + for (int cent_x = 0; cent_x <= param.maxDisplaceCenter; + cent_x = cent_x + param.GridSpaceCenter) + { + for (int cent_y = 0; cent_y <= param.maxDisplaceCenter; + cent_y = cent_y + param.GridSpaceCenter) { - int iStart, jStart, iEnd, jEnd; - if (cent_x < 0) - { - iStart = -cent_x; - iEnd = param.NumberPixels; - } - else - { - iStart = 0; - iEnd = param.NumberPixels - cent_x; - } - if (cent_y < 0) - { - jStart = -cent_y; - jEnd = param.NumberPixels; - } - else - { - jStart = 0; - jEnd = param.NumberPixels - cent_y; - } - - for (int i = iStart; i < iEnd; i += 1) - { -#ifdef SSECODE - const float* ptr1 = &Mapconv.points[i + cent_x][jStart + cent_y]; - const float* ptr2 = RefMap.getp(iRefMap, i, jStart); - int j; - const int count = jEnd - jStart; - for (j = 0; j <= count - 4; j += 4) - { - d1 = _mm_loadu_ps(ptr1); - d2 = _mm_loadu_ps(ptr2); - sum_v = _mm_add_ps(sum_v, d1); - sumsquare_v = _mm_add_ps(sumsquare_v, _mm_mul_ps(d1, d1)); - cross_v = _mm_add_ps(cross_v, _mm_mul_ps(d1, d2)); - ptr1 += 4; - ptr2 += 4; - } -#else - for (int j = jStart; j < jEnd; j += 1) - { - const myfloat_t pointMap = Mapconv[(i + cent_x) * param.NumberPixels + j + cent_y]; - const myfloat_t pointRefMap = RefMap.get(iRefMap, i, j); - crossproMapConv += pointMap * pointRefMap; - // Crosscorrelation of calculated displaced map - sum += pointMap; - // Calculate Sum of pixels squared - sumsquare += pointMap * pointMap; - } -#endif - } -#ifdef SSECODE - sum_v = _mm_hadd_ps(sum_v, sum_v); - sumsquare_v = _mm_hadd_ps(sumsquare_v, sumsquare_v); - cross_v = _mm_hadd_ps(cross_v, cross_v); - sum_v = _mm_hadd_ps(sum_v, sum_v); - sumsquare_v = _mm_hadd_ps(sumsquare_v, sumsquare_v); - cross_v = _mm_hadd_ps(cross_v, cross_v); - sum = _mm_cvtss_f32(sum_v); - sumsquare = _mm_cvtss_f32(sumsquare_v); - crossproMapConv = _mm_cvtss_f32(cross_v); -#endif - - // Calculating elements in BioEM Probability formula - logpro = calc_logpro(param, amp, pha, env, sum, sumsquare, crossproMapConv, RefMap.sum_RefMap[iRefMap], RefMap.sumsquare_RefMap[iRefMap]); + calProb(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, + (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / + (myfloat_t)(param.NumberPixels * param.NumberPixels), + cent_x, cent_y, pProb, param, RefMap); } - else + for (int cent_y = param.NumberPixels - param.maxDisplaceCenter; + cent_y < param.NumberPixels; cent_y = cent_y + param.GridSpaceCenter) { - logpro = 0; + calProb(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, + (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / + (myfloat_t)(param.NumberPixels * param.NumberPixels), + cent_x, cent_y - param.NumberPixels, pProb, param, RefMap); } + } -#ifdef BIOEM_GPUCODE - if (GPUAlgo == 2) - { - extern __shared__ myfloat_t buf[]; - myfloat_t* buf2 = &buf[myBlockDimX]; - myfloat_t* buf3 = &buf2[myBlockDimX + 4 * myRef]; - int* bufint = (int*) buf3; - - buf[myThreadIdxX] = logpro; - if (myShift == 0) - { - bufint[0] = 0; - } - __syncthreads(); - - if (nShifts2 == CUDA_MAX_SHIFT_REDUCE) // 1024 - { - if (myShift < 512) if (buf[myThreadIdxX + 512] > buf[myThreadIdxX]) buf[myThreadIdxX] = buf[myThreadIdxX + 512]; - __syncthreads(); - } - - if (nShifts2 >= 512) - { - if (myShift < 256) if (buf[myThreadIdxX + 256] > buf[myThreadIdxX]) buf[myThreadIdxX] = buf[myThreadIdxX + 256]; - __syncthreads(); - } - - if (nShifts2 >= 256) - { - if (myShift < 128) if (buf[myThreadIdxX + 128] > buf[myThreadIdxX]) buf[myThreadIdxX] = buf[myThreadIdxX + 128]; - __syncthreads(); - } - - if (nShifts2 >= 128) - { - if (myShift < 64) if (buf[myThreadIdxX + 64] > buf[myThreadIdxX]) buf[myThreadIdxX] = buf[myThreadIdxX + 64]; - __syncthreads(); - } - - if (myShift < 32) //Warp Size is 32, threads are synched automatically - { - volatile myfloat_t* vbuf = buf; //Mem must be volatile such that memory access is not reordered - if (nShifts2 >= 64 && vbuf[myThreadIdxX + 32] > vbuf[myThreadIdxX]) vbuf[myThreadIdxX] = vbuf[myThreadIdxX + 32]; - if (nShifts2 >= 32 && vbuf[myThreadIdxX + 16] > vbuf[myThreadIdxX]) vbuf[myThreadIdxX] = vbuf[myThreadIdxX + 16]; - if (nShifts2 >= 16 && vbuf[myThreadIdxX + 8] > vbuf[myThreadIdxX]) vbuf[myThreadIdxX] = vbuf[myThreadIdxX + 8]; - if (nShifts2 >= 8 && vbuf[myThreadIdxX + 4] > vbuf[myThreadIdxX]) vbuf[myThreadIdxX] = vbuf[myThreadIdxX + 4]; - if (nShifts2 >= 4 && vbuf[myThreadIdxX + 2] > vbuf[myThreadIdxX]) vbuf[myThreadIdxX] = vbuf[myThreadIdxX + 2]; - if (nShifts2 >= 2 && vbuf[myThreadIdxX + 1] > vbuf[myThreadIdxX]) vbuf[myThreadIdxX] = vbuf[myThreadIdxX + 1]; - if (myShift == 0 && iRefMap < RefMap.ntotRefMap) - { - const myfloat_t logpro_max = vbuf[myThreadIdxX]; - update_prob(logpro_max, iRefMap, iOrient, iConv, -1, -1, pProb, param.writeAngles, buf3, bufint); - } - } - - __syncthreads(); - - bioem_Probability_map& pProbMap = pProb.getProbMap(iRefMap); - bioem_Probability_angle& pProbAngle = pProb.getProbAngle(iRefMap, iOrient); - - if (bufint[0] == 1 && buf3[1] == logpro && iRefMap < RefMap.ntotRefMap && atomicAdd(&bufint[0], 1) == 1) - { - pProbMap.max.max_prob_cent_x = - cent_x; - pProbMap.max.max_prob_cent_y = - cent_y; - } - - __syncthreads(); - - if (iRefMap < RefMap.ntotRefMap) - { - buf[myThreadIdxX] = exp(logpro - pProbMap.Constoadd); - buf2[myThreadIdxX] = exp(logpro - pProbAngle.ConstAngle); - } - __syncthreads(); - - if (nShifts2 == CUDA_MAX_SHIFT_REDUCE) // 1024 - { - if (myShift < 512) - { - buf[myThreadIdxX] += buf[myThreadIdxX + 512]; - buf2[myThreadIdxX] += buf2[myThreadIdxX + 512]; - } - __syncthreads(); - } - - if (nShifts2 >= 512) - { - if (myShift < 256) - { - buf[myThreadIdxX] += buf[myThreadIdxX + 256]; - buf2[myThreadIdxX] += buf2[myThreadIdxX + 256]; - } - __syncthreads(); - } - - if (nShifts2 >= 256) - { - if (myShift < 128) - { - buf[myThreadIdxX] += buf[myThreadIdxX + 128]; - buf2[myThreadIdxX] += buf2[myThreadIdxX + 128]; - } - __syncthreads(); - } - - if (nShifts2 >= 128) - { - if (myShift < 64) - { - buf[myThreadIdxX] += buf[myThreadIdxX + 64]; - buf2[myThreadIdxX] += buf2[myThreadIdxX + 64]; - } - __syncthreads(); - } - - if (myShift < 32) //Warp Size is 32, threads are synched automatically - { - volatile myfloat_t* vbuf = buf; //Mem must be volatile such that memory access is not reordered - volatile myfloat_t* vbuf2 = buf2; - if (nShifts2 >= 64) - { - vbuf[myThreadIdxX] += vbuf[myThreadIdxX + 32]; - vbuf2[myThreadIdxX] += vbuf2[myThreadIdxX + 32]; - } - if (nShifts2 >= 32) - { - vbuf[myThreadIdxX] += vbuf[myThreadIdxX + 16]; - vbuf2[myThreadIdxX] += vbuf2[myThreadIdxX + 16]; - } - if (nShifts2 >= 16) - { - vbuf[myThreadIdxX] += vbuf[myThreadIdxX + 8]; - vbuf2[myThreadIdxX] += vbuf2[myThreadIdxX + 8]; - } - if (nShifts2 >= 8) - { - vbuf[myThreadIdxX] += vbuf[myThreadIdxX + 4]; - vbuf2[myThreadIdxX] += vbuf2[myThreadIdxX + 4]; - } - if (nShifts2 >= 4) - { - vbuf[myThreadIdxX] += vbuf[myThreadIdxX + 2]; - vbuf2[myThreadIdxX] += vbuf2[myThreadIdxX + 2]; - } - if (nShifts2 >= 2) - { - vbuf[myThreadIdxX] += vbuf[myThreadIdxX + 1]; - vbuf2[myThreadIdxX] += vbuf2[myThreadIdxX + 1]; - } - if (myShift == 0 && iRefMap < RefMap.ntotRefMap) - { - pProbMap.Total += vbuf[myThreadIdxX]; - pProbAngle.forAngles += vbuf2[myThreadIdxX]; - } - } - } - else -#endif + for (int cent_x = param.NumberPixels - param.maxDisplaceCenter; + cent_x < param.NumberPixels; cent_x = cent_x + param.GridSpaceCenter) + { + for (int cent_y = 0; cent_y <= param.maxDisplaceCenter; + cent_y = cent_y + param.GridSpaceCenter) { - update_prob < -1 > (logpro, iRefMap, iOrient, iConv, cent_x, cent_y, pProb, param.writeAngles); + calProb(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, + (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / + (myfloat_t)(param.NumberPixels * param.NumberPixels), + cent_x - param.NumberPixels, cent_y, pProb, param, RefMap); } -} - -template - __device__ static inline void compareRefMapShifted(const int iRefMap, const int iOrient, const int iConv, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t sumC, const myfloat_t sumsquareC, const myfloat_t* Mapconv, bioem_Probability& pProb, const bioem_param_device& param, const RefT& RefMap) -{ - for (int cent_x = -param.maxDisplaceCenter; cent_x <= param.maxDisplaceCenter; cent_x = cent_x + param.GridSpaceCenter) + for (int cent_y = param.NumberPixels - param.maxDisplaceCenter; + cent_y < param.NumberPixels; cent_y = cent_y + param.GridSpaceCenter) { - for (int cent_y = -param.maxDisplaceCenter; cent_y <= param.maxDisplaceCenter; cent_y = cent_y + param.GridSpaceCenter) - { - compareRefMap(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, Mapconv, pProb, param, RefMap, cent_x, cent_y); - } + calProb(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, + (myfloat_t) lCC[cent_x * param.NumberPixels + cent_y] / + (myfloat_t)(param.NumberPixels * param.NumberPixels), + cent_x - param.NumberPixels, cent_y - param.NumberPixels, pProb, + param, RefMap); } + } } #endif diff --git a/bioem_cuda.cu b/bioem_cuda.cu index 71a5c97ee2f30633ad69d64f139fc5cac4064798..75b6ee72e4c6bc6285280e956b908ee2ac39869b 100644 --- a/bioem_cuda.cu +++ b/bioem_cuda.cu @@ -1,9 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -18,715 +22,1076 @@ using namespace std; #include "bioem_cuda_internal.h" -#include "bioem_algorithm.h" //#include "helper_cuda.h" -#define checkCudaErrors(error) \ -{ \ - if ((error) != cudaSuccess) \ - { \ - printf("CUDA Error %d / %s (%s: %d)\n", error, cudaGetErrorString(error), __FILE__, __LINE__); \ - exit(1); \ - } \ -} +#include "bioem_algorithm.h" + +#define checkCudaErrors(error) \ + { \ + if ((error) != cudaSuccess) \ + { \ + printf("CUDA Error %d / %s (%s: %d)\n", error, \ + cudaGetErrorString(error), __FILE__, __LINE__); \ + exit(1); \ + } \ + } + +#ifdef DEBUG_GPU +#define printCudaDebugStart() \ + float time; \ + time = 0.; \ + cudaEvent_t start, stop; \ + checkCudaErrors(cudaEventCreate(&start)); \ + checkCudaErrors(cudaEventCreate(&stop)); \ + checkCudaErrors(cudaEventRecord(start, 0)); +#define printCudaDebug(msg) \ + checkCudaErrors(cudaEventRecord(stop, 0)); \ + checkCudaErrors(cudaEventSynchronize(stop)); \ + checkCudaErrors(cudaEventElapsedTime(&time, start, stop)); \ + printf("\t\t\tGPU: %s %1.6f sec\n", msg, time / 1000); \ + checkCudaErrors(cudaEventRecord(start, 0)); + +#else +#define printCudaDebugStart() +#define printCudaDebug(msg) +#endif static const char *cufftGetErrorStrung(cufftResult error) { - switch (error) - { - case CUFFT_SUCCESS: - return "CUFFT_SUCCESS"; + switch (error) + { + case CUFFT_SUCCESS: + return "CUFFT_SUCCESS"; - case CUFFT_INVALID_PLAN: - return "CUFFT_INVALID_PLAN"; + case CUFFT_INVALID_PLAN: + return "CUFFT_INVALID_PLAN"; - case CUFFT_ALLOC_FAILED: - return "CUFFT_ALLOC_FAILED"; + case CUFFT_ALLOC_FAILED: + return "CUFFT_ALLOC_FAILED"; - case CUFFT_INVALID_TYPE: - return "CUFFT_INVALID_TYPE"; + case CUFFT_INVALID_TYPE: + return "CUFFT_INVALID_TYPE"; - case CUFFT_INVALID_VALUE: - return "CUFFT_INVALID_VALUE"; + case CUFFT_INVALID_VALUE: + return "CUFFT_INVALID_VALUE"; - case CUFFT_INTERNAL_ERROR: - return "CUFFT_INTERNAL_ERROR"; + case CUFFT_INTERNAL_ERROR: + return "CUFFT_INTERNAL_ERROR"; - case CUFFT_EXEC_FAILED: - return "CUFFT_EXEC_FAILED"; + case CUFFT_EXEC_FAILED: + return "CUFFT_EXEC_FAILED"; - case CUFFT_SETUP_FAILED: - return "CUFFT_SETUP_FAILED"; + case CUFFT_SETUP_FAILED: + return "CUFFT_SETUP_FAILED"; - case CUFFT_INVALID_SIZE: - return "CUFFT_INVALID_SIZE"; + case CUFFT_INVALID_SIZE: + return "CUFFT_INVALID_SIZE"; - case CUFFT_UNALIGNED_DATA: - return "CUFFT_UNALIGNED_DATA"; - } - return "UNKNOWN"; + case CUFFT_UNALIGNED_DATA: + return "CUFFT_UNALIGNED_DATA"; + } + return "UNKNOWN"; } /* Handing CUDA Driver errors */ -#define cuErrorCheck(call) \ - do { \ - CUresult __error__; \ - if ((__error__ = (call)) != CUDA_SUCCESS) { \ - printf("CUDA Driver Error %d / %s (%s %d)\n", __error__, cuGetError(__error__),__FILE__, __LINE__); \ - return __error__; \ - } \ +#define cuErrorCheck(call) \ + do \ + { \ + CUresult __error__; \ + if ((__error__ = (call)) != CUDA_SUCCESS) \ + { \ + printf("CUDA Driver Error %d / %s (%s %d)\n", __error__, \ + cuGetError(__error__), __FILE__, __LINE__); \ + return __error__; \ + } \ } while (false) -static const char * cuGetError(CUresult result) { - switch (result) { - case CUDA_SUCCESS: return "No errors"; - case CUDA_ERROR_INVALID_VALUE: return "Invalid value"; - case CUDA_ERROR_OUT_OF_MEMORY: return "Out of memory"; - case CUDA_ERROR_NOT_INITIALIZED: return "Driver not initialized"; - case CUDA_ERROR_DEINITIALIZED: return "Driver deinitialized"; - case CUDA_ERROR_PROFILER_DISABLED: return "Profiler disabled"; - case CUDA_ERROR_PROFILER_NOT_INITIALIZED: return "Profiler not initialized"; - case CUDA_ERROR_PROFILER_ALREADY_STARTED: return "Profiler already started"; - case CUDA_ERROR_PROFILER_ALREADY_STOPPED: return "Profiler already stopped"; - case CUDA_ERROR_NO_DEVICE: return "No CUDA-capable device available"; - case CUDA_ERROR_INVALID_DEVICE: return "Invalid device"; - case CUDA_ERROR_INVALID_IMAGE: return "Invalid kernel image"; - case CUDA_ERROR_INVALID_CONTEXT: return "Invalid context"; - case CUDA_ERROR_CONTEXT_ALREADY_CURRENT: return "Context already current"; - case CUDA_ERROR_MAP_FAILED: return "Map failed"; - case CUDA_ERROR_UNMAP_FAILED: return "Unmap failed"; - case CUDA_ERROR_ARRAY_IS_MAPPED: return "Array is mapped"; - case CUDA_ERROR_ALREADY_MAPPED: return "Already mapped"; - case CUDA_ERROR_NO_BINARY_FOR_GPU: return "No binary for GPU"; - case CUDA_ERROR_ALREADY_ACQUIRED: return "Already acquired"; - case CUDA_ERROR_NOT_MAPPED: return "Not mapped"; - case CUDA_ERROR_NOT_MAPPED_AS_ARRAY: return "Not mapped as array"; - case CUDA_ERROR_NOT_MAPPED_AS_POINTER: return "Not mapped as pointer"; - case CUDA_ERROR_ECC_UNCORRECTABLE: return "Uncorrectable ECC error"; - case CUDA_ERROR_UNSUPPORTED_LIMIT: return "Unsupported CUlimit"; - case CUDA_ERROR_CONTEXT_ALREADY_IN_USE: return "Context already in use"; - case CUDA_ERROR_INVALID_SOURCE: return "Invalid source"; - case CUDA_ERROR_FILE_NOT_FOUND: return "File not found"; - case CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND: return "Shared object symbol not found"; - case CUDA_ERROR_SHARED_OBJECT_INIT_FAILED: return "Shared object initialization failed"; - case CUDA_ERROR_OPERATING_SYSTEM: return "Operating System call failed"; - case CUDA_ERROR_INVALID_HANDLE: return "Invalid handle"; - case CUDA_ERROR_NOT_FOUND: return "Not found"; - case CUDA_ERROR_NOT_READY: return "CUDA not ready"; - case CUDA_ERROR_LAUNCH_FAILED: return "Launch failed"; - case CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES: return "Launch exceeded resources"; - case CUDA_ERROR_LAUNCH_TIMEOUT: return "Launch exceeded timeout"; - case CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING: return "Launch with incompatible texturing"; - case CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED: return "Peer access already enabled"; - case CUDA_ERROR_PEER_ACCESS_NOT_ENABLED: return "Peer access not enabled"; - case CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE: return "Primary context active"; - case CUDA_ERROR_CONTEXT_IS_DESTROYED: return "Context is destroyed"; - case CUDA_ERROR_ASSERT: return "Device assert failed"; - case CUDA_ERROR_TOO_MANY_PEERS: return "Too many peers"; - case CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED: return "Host memory already registered"; - case CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED: return "Host memory not registered"; - case CUDA_ERROR_UNKNOWN: return "Unknown error"; - default: return "Unknown error code"; +static const char *cuGetError(CUresult result) +{ + switch (result) + { + case CUDA_SUCCESS: + return "No errors"; + case CUDA_ERROR_INVALID_VALUE: + return "Invalid value"; + case CUDA_ERROR_OUT_OF_MEMORY: + return "Out of memory"; + case CUDA_ERROR_NOT_INITIALIZED: + return "Driver not initialized"; + case CUDA_ERROR_DEINITIALIZED: + return "Driver deinitialized"; + case CUDA_ERROR_PROFILER_DISABLED: + return "Profiler disabled"; + case CUDA_ERROR_PROFILER_NOT_INITIALIZED: + return "Profiler not initialized"; + case CUDA_ERROR_PROFILER_ALREADY_STARTED: + return "Profiler already started"; + case CUDA_ERROR_PROFILER_ALREADY_STOPPED: + return "Profiler already stopped"; + case CUDA_ERROR_NO_DEVICE: + return "No CUDA-capable device available"; + case CUDA_ERROR_INVALID_DEVICE: + return "Invalid device"; + case CUDA_ERROR_INVALID_IMAGE: + return "Invalid kernel image"; + case CUDA_ERROR_INVALID_CONTEXT: + return "Invalid context"; + case CUDA_ERROR_CONTEXT_ALREADY_CURRENT: + return "Context already current"; + case CUDA_ERROR_MAP_FAILED: + return "Map failed"; + case CUDA_ERROR_UNMAP_FAILED: + return "Unmap failed"; + case CUDA_ERROR_ARRAY_IS_MAPPED: + return "Array is mapped"; + case CUDA_ERROR_ALREADY_MAPPED: + return "Already mapped"; + case CUDA_ERROR_NO_BINARY_FOR_GPU: + return "No binary for GPU"; + case CUDA_ERROR_ALREADY_ACQUIRED: + return "Already acquired"; + case CUDA_ERROR_NOT_MAPPED: + return "Not mapped"; + case CUDA_ERROR_NOT_MAPPED_AS_ARRAY: + return "Not mapped as array"; + case CUDA_ERROR_NOT_MAPPED_AS_POINTER: + return "Not mapped as pointer"; + case CUDA_ERROR_ECC_UNCORRECTABLE: + return "Uncorrectable ECC error"; + case CUDA_ERROR_UNSUPPORTED_LIMIT: + return "Unsupported CUlimit"; + case CUDA_ERROR_CONTEXT_ALREADY_IN_USE: + return "Context already in use"; + case CUDA_ERROR_INVALID_SOURCE: + return "Invalid source"; + case CUDA_ERROR_FILE_NOT_FOUND: + return "File not found"; + case CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND: + return "Shared object symbol not found"; + case CUDA_ERROR_SHARED_OBJECT_INIT_FAILED: + return "Shared object initialization failed"; + case CUDA_ERROR_OPERATING_SYSTEM: + return "Operating System call failed"; + case CUDA_ERROR_INVALID_HANDLE: + return "Invalid handle"; + case CUDA_ERROR_NOT_FOUND: + return "Not found"; + case CUDA_ERROR_NOT_READY: + return "CUDA not ready"; + case CUDA_ERROR_LAUNCH_FAILED: + return "Launch failed"; + case CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES: + return "Launch exceeded resources"; + case CUDA_ERROR_LAUNCH_TIMEOUT: + return "Launch exceeded timeout"; + case CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING: + return "Launch with incompatible texturing"; + case CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED: + return "Peer access already enabled"; + case CUDA_ERROR_PEER_ACCESS_NOT_ENABLED: + return "Peer access not enabled"; + case CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE: + return "Primary context active"; + case CUDA_ERROR_CONTEXT_IS_DESTROYED: + return "Context is destroyed"; + case CUDA_ERROR_ASSERT: + return "Device assert failed"; + case CUDA_ERROR_TOO_MANY_PEERS: + return "Too many peers"; + case CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED: + return "Host memory already registered"; + case CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED: + return "Host memory not registered"; + case CUDA_ERROR_UNKNOWN: + return "Unknown error"; + default: + return "Unknown error code"; } } bioem_cuda::bioem_cuda() { - deviceInitialized = 0; - GPUAlgo = getenv("GPUALGO") == NULL ? 2 : atoi(getenv("GPUALGO")); - GPUAsync = getenv("GPUASYNC") == NULL ? 1 : atoi(getenv("GPUASYNC")); - GPUWorkload = getenv("GPUWORKLOAD") == NULL ? 100 : atoi(getenv("GPUWORKLOAD")); - if (GPUWorkload == -1) GPUWorkload = 100; - GPUDualStream = getenv("GPUDUALSTREAM") == NULL ? 1 : atoi(getenv("GPUDUALSTREAM")); + deviceInitialized = 0; + GPUAsync = getenv("GPUASYNC") == NULL ? 1 : atoi(getenv("GPUASYNC")); + GPUWorkload = + getenv("GPUWORKLOAD") == NULL ? 100 : atoi(getenv("GPUWORKLOAD")); + if (GPUWorkload == -1) + GPUWorkload = 100; + GPUDualStream = + getenv("GPUDUALSTREAM") == NULL ? 1 : atoi(getenv("GPUDUALSTREAM")); } -bioem_cuda::~bioem_cuda() -{ - deviceExit(); -} +bioem_cuda::~bioem_cuda() { deviceExit(); } -__global__ void compareRefMap_kernel(const int iOrient, const int iConv, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t sumC, - const myfloat_t sumsquareC, const myfloat_t* pMap, bioem_Probability pProb, - const bioem_param_device param, const bioem_RefMap_Mod RefMap, const int cent_x, const int cent_y, const int maxRef) +__global__ void multComplexMap(const mycomplex_t *convmap, + const mycomplex_t *refmap, mycuComplex_t *out, + const int MapSize, const int maxParallelConv, + const int NumberRefMaps, const int Offset) { - const int iRefMap = myBlockIdxX * myBlockDimX + myThreadIdxX; - if (iRefMap < maxRef) - { - compareRefMap<0>(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, pMap, pProb, param, RefMap, cent_x, cent_y); - } + int myConv = myBlockIdxX / NumberRefMaps; + int myRef = myBlockIdxX - myConv * NumberRefMaps + Offset; + const mycuComplex_t *myin = (mycuComplex_t *) &refmap[myRef * MapSize]; + const mycuComplex_t *myconv = (mycuComplex_t *) &convmap[myConv * MapSize]; + mycuComplex_t *myout = &out[myBlockIdxX * MapSize]; + for (int i = myThreadIdxX; i < MapSize; i += myBlockDimX) + { + mycuComplex_t val; + const mycuComplex_t conv = myconv[i]; + const mycuComplex_t in = myin[i]; + + val.x = conv.x * in.x + conv.y * in.y; + val.y = conv.y * in.x - conv.x * in.y; + myout[i] = val; + } } -__global__ void compareRefMapShifted_kernel(const int iOrient, const int iConv, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t sumC, const myfloat_t sumsquareC, const myfloat_t* pMap, bioem_Probability pProb, const bioem_param_device param, const bioem_RefMap_Mod RefMap, const int maxRef) +__global__ void +cuDoRefMapsFFT(const int iOrient, const int iConv, const myfloat_t *lCC, + const myparam5_t *comp_params, bioem_Probability pProb, + const bioem_param_device param, const bioem_RefMap RefMap, + const int maxRef, const int Offset) { - const int iRefMap = myBlockIdxX * myBlockDimX + myThreadIdxX; - if (iRefMap < maxRef) - { - compareRefMapShifted<1>(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, pMap, pProb, param, RefMap); - } + if (myBlockIdxX * myBlockDimX + myThreadIdxX >= maxRef) + return; + const int iRefMap = myBlockIdxX * myBlockDimX + myThreadIdxX + Offset; + const myfloat_t *mylCC = &lCC[(myBlockIdxX * myBlockDimX + myThreadIdxX) * + param.NumberPixels * param.NumberPixels]; + doRefMapFFT(iRefMap, iOrient, iConv, comp_params->amp, comp_params->pha, + comp_params->env, comp_params->sumC, comp_params->sumsquareC, + mylCC, pProb, param, RefMap); } -__global__ void cudaZeroMem(void* ptr, size_t size) +__global__ void +doRefMap_GPU_Parallel(const int iRefMap, const int iOrient, const int iConv, + const int maxParallelConv, const myfloat_t *lCC, + const myparam5_t *comp_params, myblockGPU_t *comp_block, + bioem_Probability pProb, const bioem_param_device param, + const bioem_RefMap RefMap, const int maxRef, + const int dispC) { - int* myptr = (int*) ptr; - int mysize = size / sizeof(int); - int myid = myBlockDimX * myBlockIdxX + myThreadIdxX; - int mygrid = myBlockDimX * myGridDimX; - for (int i = myid; i < mysize; i += mygrid) myptr[i] = 0; -} + int myGlobalId = myBlockIdxX * myBlockDimX + myThreadIdxX; + if (myGlobalId >= maxParallelConv * param.NtotDisp) + return; + int myConv = myGlobalId / param.NtotDisp; + myGlobalId -= myConv * param.NtotDisp; + int myX = myGlobalId / param.NxDisp; + myGlobalId -= myX * param.NxDisp; + int myY = myGlobalId; + myGlobalId = myBlockIdxX * myBlockDimX + myThreadIdxX; + + int cent_x = (myX * param.GridSpaceCenter + dispC) % param.NumberPixels; + int cent_y = (myY * param.GridSpaceCenter + dispC) % param.NumberPixels; + int address = (myConv * maxRef * param.NumberPixels * param.NumberPixels) + + (cent_x * param.NumberPixels + cent_y); + myfloat_t value = (myfloat_t) lCC[address] / + (myfloat_t)(param.NumberPixels * param.NumberPixels); + + __shared__ myprob_t bestLogpro[CUDA_THREAD_MAX]; + __shared__ int bestId[CUDA_THREAD_MAX]; + __shared__ myprob_t sumExp[CUDA_THREAD_MAX]; + __shared__ myprob_t sumAngles[CUDA_THREAD_MAX]; + + int nTotalThreads = + ((maxParallelConv * param.NtotDisp) < ((myBlockIdxX + 1) * myBlockDimX)) ? + ((maxParallelConv * param.NtotDisp) - (myBlockIdxX * myBlockDimX)) : + myBlockDimX; + int halfPoint = (nTotalThreads + 1) >> 1; // divide by two + + bioem_Probability_map &pProbMap = pProb.getProbMap(iRefMap); + + bestLogpro[myThreadIdxX] = + calc_logpro(param, comp_params[myConv].amp, comp_params[myConv].pha, + comp_params[myConv].env, comp_params[myConv].sumC, + comp_params[myConv].sumsquareC, value, + RefMap.sum_RefMap[iRefMap], RefMap.sumsquare_RefMap[iRefMap]); +#ifdef DEBUG_PROB + printf("\t\t\tProb: iRefMap %d, iOrient %d, iConv %d, " + "cent_x %d, cent_y %d, address %d, value %f, logpro %f\n", + iRefMap, iOrient, iConv, cent_x, cent_y, address, value, + bestLogpro[myThreadIdxX]); +#endif + bestId[myThreadIdxX] = myGlobalId; + sumExp[myThreadIdxX] = exp(bestLogpro[myThreadIdxX] - pProbMap.Constoadd); + if (param.writeAngles) + { + bioem_Probability_angle &pProbAngle = pProb.getProbAngle(iRefMap, iOrient); + sumAngles[myThreadIdxX] = + exp(bestLogpro[myThreadIdxX] - pProbAngle.ConstAngle); + } + __syncthreads(); -__global__ void compareRefMapLoopShifts_kernel(const int iOrient, const int iConv, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t sumC, const myfloat_t sumsquareC, const myfloat_t* pMap, bioem_Probability pProb, const bioem_param_device param, const bioem_RefMap RefMap, const int blockoffset, const int nShifts, const int nShiftBits, const int maxRef) -{ - const size_t myid = (myBlockIdxX + blockoffset) * myBlockDimX + myThreadIdxX; - const int iRefMap = myid >> (nShiftBits << 1); - const int myRef = myThreadIdxX >> (nShiftBits << 1); - const int myShiftIdx = (myid >> nShiftBits) & (nShifts - 1); - const int myShiftIdy = myid & (nShifts - 1); - const int myShift = myid & (nShifts * nShifts - 1); - const int cent_x = myShiftIdx * param.GridSpaceCenter - param.maxDisplaceCenter; - const int cent_y = myShiftIdy * param.GridSpaceCenter - param.maxDisplaceCenter; - - const bool threadActive = myShiftIdx < nShifts && myShiftIdy < nShifts && iRefMap < maxRef; - - compareRefMap<2>(iRefMap, iOrient, iConv, amp, pha, env, sumC, sumsquareC, pMap, pProb, param, RefMap, cent_x, cent_y, myShift, nShifts * nShifts, myRef, threadActive); + // Total number of active threads + while (nTotalThreads > 1) + { + if (myThreadIdxX < (nTotalThreads >> 1)) + { + // Get the shared value stored by another thread + myprob_t temp = bestLogpro[myThreadIdxX + halfPoint]; + if (temp > bestLogpro[myThreadIdxX]) + { + bestLogpro[myThreadIdxX] = temp; + bestId[myThreadIdxX] = bestId[myThreadIdxX + halfPoint]; + } + sumExp[myThreadIdxX] += sumExp[myThreadIdxX + halfPoint]; + if (param.writeAngles) + { + sumAngles[myThreadIdxX] += sumAngles[myThreadIdxX + halfPoint]; + } + } + __syncthreads(); + nTotalThreads = halfPoint; // divide by two. + halfPoint = (nTotalThreads + 1) >> 1; // divide by two + // only the first half of the threads will be active. + } + if (myThreadIdxX == 0) + { + comp_block[myBlockIdxX].logpro = bestLogpro[0]; + comp_block[myBlockIdxX].id = bestId[0]; + comp_block[myBlockIdxX].sumExp = sumExp[0]; + if (param.writeAngles) + { + comp_block[myBlockIdxX].sumAngles = sumAngles[0]; + } +#ifdef DEBUG_PROB + printf("\t\t\tProb block: iRefMap %d, iOrient %d, iConv %d, " + "bestlogpro %f, bestId %d, sumExp %f\n", + iRefMap, iOrient, iConv, bestLogpro[0], bestId[0], sumExp[0]); +#endif + } } -__global__ void multComplexMap(const mycomplex_t* convmap, const mycomplex_t* refmap, mycuComplex_t* out, const int NumberPixelsTotal, const int MapSize, const int NumberMaps, const int Offset) +__global__ void +doRefMap_GPU_Reduce(const int iRefMap, const int iOrient, const int iConv, + const int maxParallelConv, const myfloat_t *lCC, + const myparam5_t *comp_params, + const myblockGPU_t *comp_block, bioem_Probability pProb, + const bioem_param_device param, const bioem_RefMap RefMap, + const int maxRef, const int dispC) { - if (myBlockIdxX >= NumberMaps) return; - const mycuComplex_t* myin = (mycuComplex_t*) &refmap[(myBlockIdxX + Offset) * MapSize]; - const mycuComplex_t* myconv = (mycuComplex_t*) convmap; - mycuComplex_t* myout = &out[myBlockIdxX * MapSize]; - for(int i = myThreadIdxX; i < NumberPixelsTotal; i += myBlockDimX) - { - mycuComplex_t val; - const mycuComplex_t conv = myconv[i]; - const mycuComplex_t in = myin[i]; - - val.x = conv.x * in.x + conv.y * in.y; - val.y = conv.y * in.x - conv.x * in.y; - myout[i] = val; - } + + __shared__ myprob_t bestLogpro[CUDA_THREAD_MAX]; + __shared__ int bestId[CUDA_THREAD_MAX]; + __shared__ myprob_t sumExp[CUDA_THREAD_MAX]; + __shared__ myprob_t sumAngles[CUDA_THREAD_MAX]; + + // if it is the last block + int nTotalThreads = myBlockDimX; + int halfPoint = (nTotalThreads + 1) >> 1; // divide by two + + bioem_Probability_map &pProbMap = pProb.getProbMap(iRefMap); + + bestLogpro[myThreadIdxX] = comp_block[myThreadIdxX].logpro; + bestId[myThreadIdxX] = comp_block[myThreadIdxX].id; + sumExp[myThreadIdxX] = comp_block[myThreadIdxX].sumExp; + if (param.writeAngles) + { + sumAngles[myThreadIdxX] = comp_block[myThreadIdxX].sumAngles; + } + __syncthreads(); + while (nTotalThreads > 1) + { + if (myThreadIdxX < (nTotalThreads >> 1)) + { + // Get the shared value stored by another thread + myfloat_t temp = bestLogpro[myThreadIdxX + halfPoint]; + if (temp > bestLogpro[myThreadIdxX]) + { + bestLogpro[myThreadIdxX] = temp; + bestId[myThreadIdxX] = bestId[myThreadIdxX + halfPoint]; + } + sumExp[myThreadIdxX] += sumExp[myThreadIdxX + halfPoint]; + if (param.writeAngles) + { + sumAngles[myThreadIdxX] += sumAngles[myThreadIdxX + halfPoint]; + } + } + __syncthreads(); + nTotalThreads = halfPoint; // divide by two. + halfPoint = (nTotalThreads + 1) >> 1; // divide by two + // only the first half of the threads will be active. + } + + if (myThreadIdxX == 0) + { + pProbMap.Total += sumExp[0]; + if (pProbMap.Constoadd < bestLogpro[0]) + { + pProbMap.Total *= exp(-bestLogpro[0] + pProbMap.Constoadd); + pProbMap.Constoadd = bestLogpro[0]; + + // ********** Getting parameters that maximize the probability *********** + int myGlobalId = bestId[0]; + int myConv = myGlobalId / param.NtotDisp; + myGlobalId -= myConv * param.NtotDisp; + int myX = myGlobalId / param.NxDisp; + myGlobalId -= myX * param.NxDisp; + int myY = myGlobalId; + + int cent_x = (myX * param.GridSpaceCenter + dispC) % param.NumberPixels; + int cent_y = (myY * param.GridSpaceCenter + dispC) % param.NumberPixels; + int address = + (myConv * maxRef * param.NumberPixels * param.NumberPixels) + + (cent_x * param.NumberPixels + cent_y); + myfloat_t value = (myfloat_t) lCC[address] / + (myfloat_t)(param.NumberPixels * param.NumberPixels); + + pProbMap.max.max_prob_cent_x = + -((myX * param.GridSpaceCenter + dispC) - param.NumberPixels); + pProbMap.max.max_prob_cent_y = + -((myY * param.GridSpaceCenter + dispC) - param.NumberPixels); + pProbMap.max.max_prob_orient = iOrient; + pProbMap.max.max_prob_conv = iConv + myConv; + pProbMap.max.max_prob_norm = + -(-comp_params[myConv].sumC * RefMap.sum_RefMap[iRefMap] + + param.Ntotpi * value) / + (comp_params[myConv].sumC * comp_params[myConv].sumC - + comp_params[myConv].sumsquareC * param.Ntotpi); + pProbMap.max.max_prob_mu = + -(-comp_params[myConv].sumC * value + + comp_params[myConv].sumsquareC * RefMap.sum_RefMap[iRefMap]) / + (comp_params[myConv].sumC * comp_params[myConv].sumC - + comp_params[myConv].sumsquareC * param.Ntotpi); + +#ifdef DEBUG_PROB + printf("\tProbabilities change: iRefMap %d, iOrient %d, iConv %d, " + "Total %f, Const %f, bestlogpro %f, sumExp %f, bestId %d\n", + iRefMap, iOrient, iConv + myConv, pProbMap.Total, + pProbMap.Constoadd, bestLogpro[0], sumExp[0], bestId[0]); + printf("\tParameters: myConv %d, myX %d, myY %d, cent_x %d, cent_y %d, " + "probX %d, probY %d\n", + myConv, myX, myY, cent_x, cent_y, pProbMap.max.max_prob_cent_x, + pProbMap.max.max_prob_cent_y); +#endif + } +#ifdef DEBUG_PROB + printf("\t\tProbabilities after Reduce: iRefMap %d, iOrient %d, iConv " + "%d, Total %f, Const %f, bestlogpro %f, sumExp %f, bestId %d\n", + iRefMap, iOrient, iConv, pProbMap.Total, pProbMap.Constoadd, + bestLogpro[0], sumExp[0], bestId[0]); +#endif + + if (param.writeAngles) + { + bioem_Probability_angle &pProbAngle = + pProb.getProbAngle(iRefMap, iOrient); + pProbAngle.forAngles += sumAngles[0]; + if (pProbAngle.ConstAngle < bestLogpro[0]) + { + pProbAngle.forAngles *= exp(-bestLogpro[0] + pProbAngle.ConstAngle); + pProbAngle.ConstAngle = bestLogpro[0]; + } + } + } } -__global__ void cuDoRefMapsFFT(const int iOrient, const int iConv, const myfloat_t amp, const myfloat_t pha, const myfloat_t env, const myfloat_t* lCC, const myfloat_t sumC, const myfloat_t sumsquareC, bioem_Probability pProb, const bioem_param_device param, const bioem_RefMap RefMap, const int maxRef, const int Offset) +__global__ void +init_Constoadd(const int iRefMap, const int iOrient, const myfloat_t *lCC, + const myparam5_t *comp_params, bioem_Probability pProb, + const bioem_param_device param, const bioem_RefMap RefMap, + const int initialized_const) { - if (myBlockIdxX * myBlockDimX + myThreadIdxX >= maxRef) return; - const int iRefMap = myBlockIdxX * myBlockDimX + myThreadIdxX + Offset; - const myfloat_t* mylCC = &lCC[(myBlockIdxX * myBlockDimX + myThreadIdxX) * param.NumberPixels * param.NumberPixels]; - doRefMapFFT(iRefMap, iOrient, iConv, amp, pha, env, mylCC, sumC, sumsquareC, pProb, param, RefMap); + myfloat_t value = + (myfloat_t) lCC[0] / (myfloat_t)(param.NumberPixels * param.NumberPixels); + + myfloat_t logpro = + calc_logpro(param, comp_params->amp, comp_params->pha, comp_params->env, + comp_params->sumC, comp_params->sumsquareC, value, + RefMap.sum_RefMap[iRefMap], RefMap.sumsquare_RefMap[iRefMap]); + + bioem_Probability_map &pProbMap = pProb.getProbMap(iRefMap); + + // Needed only once, in the first projection + if (!initialized_const) + { + pProbMap.Constoadd = logpro; + } + // Needed for every projection + if (param.writeAngles) + { + bioem_Probability_angle &pProbAngle = pProb.getProbAngle(iRefMap, iOrient); + pProbAngle.ConstAngle = logpro; + } + +#ifdef DEBUG_GPU + printf("\tInitialized pProbMap.Constoadd of refmap %d to %f\n", iRefMap, + pProbMap.Constoadd); +#endif } -template static inline T divup(T num, T divider) {return((num + divider - 1) / divider);} -static inline bool IsPowerOf2(int x) {return ((x > 0) && ((x & (x - 1)) == 0));} -#if defined(_WIN32) -static inline int ilog2 (int value) +template static inline T divup(T num, T divider) { - DWORD index; - _BitScanReverse (&index, value); - return(value); + return ((num + divider - 1) / divider); } -#else -static inline int ilog2(int value) {return 31 - __builtin_clz(value);} -#endif -int bioem_cuda::compareRefMaps(int iOrient, int iConv, myfloat_t amp, myfloat_t pha, myfloat_t env, const myfloat_t* conv_map, mycomplex_t* localmultFFT, myfloat_t sumC, myfloat_t sumsquareC, const int startMap) +int bioem_cuda::compareRefMaps(int iPipeline, int iOrient, int iConv, + int maxParallelConv, mycomplex_t *conv_mapsFFT, + myparam5_t *comp_params, const int startMap) { - if (startMap) - { - cout << "Error startMap not implemented for GPU Code\n"; - exit(1); - } -#ifdef DEBUG_GPU - float time; - cudaEvent_t start, stop; - checkCudaErrors(cudaEventCreate(&start)); - checkCudaErrors(cudaEventCreate(&stop)); - checkCudaErrors(cudaEventRecord(start, 0)); -#endif - if (GPUAsync) - { - checkCudaErrors(cudaEventSynchronize(cudaEvent[iConv & 1])); - } -#ifdef DEBUG_GPU - checkCudaErrors(cudaEventRecord(stop, 0)); - checkCudaErrors(cudaEventSynchronize(stop)); - checkCudaErrors(cudaEventElapsedTime(&time, start, stop)); - printf("\t\t\tGPU: time to synch projections %1.6f sec\n", time/1000); - checkCudaErrors(cudaEventRecord(start, 0)); -#endif - if (FFTAlgo) - { - memcpy(&pConvMapFFT_Host[(iConv & 1) * param.FFTMapSize], localmultFFT, param.FFTMapSize * sizeof(mycomplex_t)); - checkCudaErrors(cudaMemcpyAsync(&pConvMapFFT[(iConv & 1) * param.FFTMapSize], &pConvMapFFT_Host[(iConv & 1) * param.FFTMapSize], param.FFTMapSize * sizeof(mycomplex_t), cudaMemcpyHostToDevice, cudaStream[GPUAsync ? 2 : 0])); -#ifdef DEBUG_GPU - checkCudaErrors(cudaEventRecord(stop, 0)); - checkCudaErrors(cudaEventSynchronize(stop)); - checkCudaErrors(cudaEventElapsedTime(&time, start, stop)); - printf("\t\t\tGPU: time for memcpy %1.6f sec\n", time/1000); - checkCudaErrors(cudaEventRecord(start, 0)); -#endif - if (GPUAsync) - { - checkCudaErrors(cudaEventRecord(cudaEvent[2], cudaStream[2])); - checkCudaErrors(cudaStreamWaitEvent(cudaStream[0], cudaEvent[2], 0)); - } - if (GPUDualStream) - { - checkCudaErrors(cudaEventRecord(cudaFFTEvent[0], cudaStream[0])); - checkCudaErrors(cudaStreamWaitEvent(cudaStream[1], cudaFFTEvent[0], 0)); - } - for (int i = 0, j = 0; i < maxRef; i += CUDA_FFTS_AT_ONCE, j++) - { - if (!GPUDualStream) j = 0; - const int num = min(CUDA_FFTS_AT_ONCE, maxRef - i); - multComplexMap<<>>(&pConvMapFFT[(iConv & 1) * param.FFTMapSize], pRefMapsFFT, pFFTtmp2[j & 1], param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D, param.FFTMapSize, num, i); - cufftResult err = mycufftExecC2R(i + CUDA_FFTS_AT_ONCE > maxRef ? plan[1][j & 1] : plan[0][j & 1], pFFTtmp2[j & 1], pFFTtmp[j & 1]); - if (err != CUFFT_SUCCESS) - { - cout << "Error running CUFFT " << cufftGetErrorStrung(err) << "\n"; - exit(1); - } - cuDoRefMapsFFT<<>>(iOrient, iConv, amp, pha, env, pFFTtmp[j & 1], sumC, sumsquareC, pProb_device, param.param_device, *gpumap, num, i); - } - checkCudaErrors(cudaPeekAtLastError()); - if (GPUDualStream) - { - checkCudaErrors(cudaEventRecord(cudaFFTEvent[1], cudaStream[1])); - checkCudaErrors(cudaStreamWaitEvent(cudaStream[0], cudaFFTEvent[1], 0)); - } - } - else - { - checkCudaErrors(cudaMemcpyAsync(pConvMap_device[iConv & 1], conv_map, sizeof(myfloat_t) * RefMap.refMapSize, cudaMemcpyHostToDevice, cudaStream[0])); -#ifdef DEBUG_GPU - checkCudaErrors(cudaEventRecord(stop, 0)); - checkCudaErrors(cudaEventSynchronize(stop)); - checkCudaErrors(cudaEventElapsedTime(&time, start, stop)); - printf("\t\t\tGPU: time for memcpy %1.6f sec\n", time/1000); - checkCudaErrors(cudaEventRecord(start, 0) ); -#endif - if (GPUAlgo == 2) //Loop over shifts - { - const int nShifts = 2 * param.param_device.maxDisplaceCenter / param.param_device.GridSpaceCenter + 1; - if (!IsPowerOf2(nShifts)) - { - cout << "Invalid number of displacements, no power of two\n"; - exit(1); - } - if (CUDA_THREAD_COUNT % (nShifts * nShifts)) - { - cout << "CUDA Thread count (" << CUDA_THREAD_COUNT << ") is no multiple of number of shifts (" << (nShifts * nShifts) << ")\n"; - exit(1); - } - if (nShifts > CUDA_MAX_SHIFT_REDUCE) - { - cout << "Too many displacements for CUDA reduction\n"; - exit(1); - } - const int nShiftBits = ilog2(nShifts); - size_t totalBlocks = divup((size_t) maxRef * (size_t) nShifts * (size_t) nShifts, (size_t) CUDA_THREAD_COUNT); - size_t nBlocks = CUDA_BLOCK_COUNT; - for (size_t i = 0; i < totalBlocks; i += nBlocks) - { - compareRefMapLoopShifts_kernel<<>> (iOrient, iConv, amp, pha, env, sumC, sumsquareC, pConvMap_device[iConv & 1], pProb_device, param.param_device, *gpumap, i, nShifts, nShiftBits, maxRef); - } - } - else if (GPUAlgo == 1) //Split shifts in multiple kernels - { - for (int cent_x = -param.param_device.maxDisplaceCenter; cent_x <= param.param_device.maxDisplaceCenter; cent_x = cent_x + param.param_device.GridSpaceCenter) - { - for (int cent_y = -param.param_device.maxDisplaceCenter; cent_y <= param.param_device.maxDisplaceCenter; cent_y = cent_y + param.param_device.GridSpaceCenter) - { - compareRefMap_kernel<<>> (iOrient, iConv, amp, pha, env, sumC, sumsquareC, pConvMap_device[iConv & 1], pProb_device, param.param_device, *pRefMap_device_Mod, cent_x, cent_y, maxRef); - } - } - } - else if (GPUAlgo == 0) //All shifts in one kernel - { - compareRefMapShifted_kernel<<>> (iOrient, iConv, amp, pha, env, sumC, sumsquareC, pConvMap_device[iConv & 1], pProb_device, param.param_device, *pRefMap_device_Mod, maxRef); - } - else - { - cout << "Invalid GPU Algorithm selected\n"; - exit(1); - } - } -#ifdef DEBUG_GPU - checkCudaErrors(cudaEventRecord(stop, 0)); - checkCudaErrors(cudaEventSynchronize(stop)); - checkCudaErrors(cudaEventElapsedTime(&time, start, stop)); - printf("\t\t\tGPU: time to run CUDA %1.6f sec\n", time/1000); - checkCudaErrors(cudaEventRecord(start, 0)); -#endif - if (GPUWorkload < 100) - { - bioem::compareRefMaps(iOrient, iConv, amp, pha, env, conv_map, localmultFFT, sumC, sumsquareC, maxRef); - } -#ifdef DEBUG_GPU - checkCudaErrors(cudaEventRecord(stop, 0)); - checkCudaErrors(cudaEventSynchronize(stop)); - checkCudaErrors(cudaEventElapsedTime(&time, start, stop)); - printf("\t\t\tGPU: time to run OMP %1.6f sec\n", time/1000); -#endif - if (GPUAsync) - { - checkCudaErrors(cudaEventRecord(cudaEvent[iConv & 1], cudaStream[0])); - } - else - { - checkCudaErrors(cudaStreamSynchronize(cudaStream[0])); - } - return(0); + if (startMap) + { + cout << "Error startMap not implemented for GPU Code\n"; + exit(1); + } + printCudaDebugStart(); + if (GPUAsync) + { + checkCudaErrors(cudaEventSynchronize(cudaEvent[iPipeline & 1])); + printCudaDebug("time to synch projections"); + } + + int k = (iPipeline & 1) * param.nTotParallelConv; + memcpy(&pConvMapFFT_Host[k * param.FFTMapSize], + conv_mapsFFT[k * param.FFTMapSize], + param.FFTMapSize * maxParallelConv * sizeof(mycomplex_t)); + printCudaDebug("time for memcpy"); + checkCudaErrors( + cudaMemcpyAsync(&pConvMapFFT[k * param.FFTMapSize], + &pConvMapFFT_Host[k * param.FFTMapSize], + param.FFTMapSize * maxParallelConv * sizeof(mycomplex_t), + cudaMemcpyHostToDevice, cudaStream[GPUAsync ? 2 : 0])); + // If one wants just a single tranfer, without memcpy: + // checkCudaErrors(cudaMemcpyAsync(&pConvMapFFT[k * param.FFTMapSize], + // conv_mapsFFT[k * param.FFTMapSize], param.FFTMapSize * maxParallelConv * + // sizeof(mycomplex_t), cudaMemcpyHostToDevice, cudaStream[GPUAsync ? 2 : + // 0])); + checkCudaErrors(cudaMemcpyAsync(&pTmp_comp_params[k], &comp_params[k], + maxParallelConv * sizeof(myparam5_t), + cudaMemcpyHostToDevice, + cudaStream[GPUAsync ? 2 : 0])); + printCudaDebug("time for asyncmemcpy"); + if (GPUAsync) + { + checkCudaErrors(cudaEventRecord(cudaEvent[2], cudaStream[2])); + checkCudaErrors(cudaStreamWaitEvent(cudaStream[0], cudaEvent[2], 0)); + } + if (GPUDualStream) + { + checkCudaErrors(cudaEventRecord(cudaFFTEvent[0], cudaStream[0])); + checkCudaErrors(cudaStreamWaitEvent(cudaStream[1], cudaFFTEvent[0], 0)); + } + for (int offset = 0, stream = 0; offset < maxRef; + offset += param.nTotParallelMaps, stream++) + { + if (!GPUDualStream) + stream = 0; + const int nRef = min(param.nTotParallelMaps, maxRef - offset); + multComplexMap<<>>( + &pConvMapFFT[k * param.FFTMapSize], pRefMapsFFT, pFFTtmp2[stream & 1], + param.FFTMapSize, maxParallelConv, nRef, offset); + printCudaDebug("time for multComplexMap kernel"); + cufftResult err = mycufftExecC2R(offset + param.nTotParallelMaps > maxRef ? + plan[1][stream & 1] : + plan[0][stream & 1], + pFFTtmp2[stream & 1], pFFTtmp[stream & 1]); + if (err != CUFFT_SUCCESS) + { + cout << "Error running CUFFT " << cufftGetErrorStrung(err) << "\n"; + exit(1); + } + printCudaDebug("time for mycufftExecC2R kernel"); + if (BioEMAlgo == 1) + { + for (int conv = 0; conv < maxParallelConv; conv++) + { + cuDoRefMapsFFT<<>>( + iOrient, iConv + conv, + pFFTtmp[stream & 1] + + conv * nRef * param.param_device.NumberPixels * + param.param_device.NumberPixels, + &pTmp_comp_params[k + conv], pProb_device, param.param_device, + *gpumap, nRef, offset); + printCudaDebug("time for cuDoRefMapsFFT kernel"); + } + } + else + { + for (int refmap = offset; refmap < nRef + offset; refmap++) + { + // First iteration needs to initialize Constoadd with the first valid + // value to avoid overflow due to high sumExp values + if ((initialized_const[refmap] == false) || + (param.param_device.writeAngles && iConv == 0)) + { + init_Constoadd<<<1, 1, 0, cudaStream[stream & 1]>>>( + refmap, iOrient, + pFFTtmp[stream & 1] + + (refmap - offset) * param.param_device.NumberPixels * + param.param_device.NumberPixels, + &pTmp_comp_params[k], pProb_device, param.param_device, *gpumap, + (int) initialized_const[refmap]); + initialized_const[refmap] = true; + printCudaDebug("time for init_Constoadd kernel"); + } + + doRefMap_GPU_Parallel<<>>( + refmap, iOrient, iConv, maxParallelConv, + pFFTtmp[stream & 1] + + (refmap - offset) * param.param_device.NumberPixels * + param.param_device.NumberPixels, + &pTmp_comp_params[k], &pTmp_comp_blocks[refmap * Ncomp_blocks], + pProb_device, param.param_device, *gpumap, nRef, + param.param_device.NumberPixels - + param.param_device.maxDisplaceCenter); + printCudaDebug("time for doRefMaps_GPU_Parallel kernel"); + + doRefMap_GPU_Reduce<<<1, divup(maxParallelConv * + param.param_device.NtotDisp, + CudaThreadCount), + 0, cudaStream[stream & 1]>>>( + refmap, iOrient, iConv, maxParallelConv, + pFFTtmp[stream & 1] + + (refmap - offset) * param.param_device.NumberPixels * + param.param_device.NumberPixels, + &pTmp_comp_params[k], &pTmp_comp_blocks[refmap * Ncomp_blocks], + pProb_device, param.param_device, *gpumap, nRef, + param.param_device.NumberPixels - + param.param_device.maxDisplaceCenter); + printCudaDebug("time for doRefMaps_GPU_Reduce kernel"); + } + } + } + checkCudaErrors(cudaPeekAtLastError()); + + if (GPUDualStream) + { + checkCudaErrors(cudaEventRecord(cudaFFTEvent[1], cudaStream[1])); + checkCudaErrors(cudaStreamWaitEvent(cudaStream[0], cudaFFTEvent[1], 0)); + } + + if ((BioEMAlgo == 1) && (GPUWorkload < 100)) + { + bioem::compareRefMaps(iPipeline, iOrient, iConv, maxParallelConv, + conv_mapsFFT, comp_params, maxRef); + printCudaDebug("time to run OMP"); + } + if (GPUAsync) + { + checkCudaErrors(cudaEventRecord(cudaEvent[iPipeline & 1], cudaStream[0])); + } + else + { + checkCudaErrors(cudaStreamSynchronize(cudaStream[0])); + printCudaDebug("time to synch at the end"); + } + return (0); } int bioem_cuda::selectCudaDevice() { - int count; - int bestDevice = 0; - cudaDeviceProp deviceProp; - - /* Initializing CUDA driver API */ - cuErrorCheck(cuInit(0)); - - /* Get number of available CUDA devices */ - checkCudaErrors(cudaGetDeviceCount(&count)); - if (count == 0) - { - printf("No CUDA device detected\n"); - return(1); - } - - /* Find the best GPU */ - long long int bestDeviceSpeed = -1, deviceSpeed = -1; - for (int i = 0; i < count; i++) - { - cudaGetDeviceProperties(&deviceProp, i); - deviceSpeed = (long long int) deviceProp.multiProcessorCount * (long long int) deviceProp.clockRate * (long long int) deviceProp.warpSize; - if (deviceSpeed > bestDeviceSpeed) - { - bestDevice = i; - bestDeviceSpeed = deviceSpeed; - } - } - - /* Get user-specified GPU choice */ - if (getenv("GPUDEVICE")) - { - int device = atoi(getenv("GPUDEVICE")); - if (device > count) - { - printf("Invalid CUDA device specified, max device number is %d\n", count); - exit(1); - } + int count; + int bestDevice = 0; + cudaDeviceProp deviceProp; + + /* Initializing CUDA driver API */ + cuErrorCheck(cuInit(0)); + + /* Get number of available CUDA devices */ + checkCudaErrors(cudaGetDeviceCount(&count)); + if (count == 0) + { + printf("No CUDA device detected\n"); + return (1); + } + + /* Find the best GPU */ + long long int bestDeviceSpeed = -1, deviceSpeed = -1; + for (int i = 0; i < count; i++) + { + cudaGetDeviceProperties(&deviceProp, i); + deviceSpeed = (long long int) deviceProp.multiProcessorCount * + (long long int) deviceProp.clockRate * + (long long int) deviceProp.warpSize; + if (deviceSpeed > bestDeviceSpeed) + { + bestDevice = i; + bestDeviceSpeed = deviceSpeed; + } + } + + /* Get user-specified GPU choice */ + if (getenv("GPUDEVICE")) + { + int device = atoi(getenv("GPUDEVICE")); + if (device > count) + { + printf("Invalid CUDA device specified, max device number is %d\n", count); + exit(1); + } #ifdef WITH_MPI - if (device == -1) - { - device = mpi_rank % count; - } + if (device == -1) + { + device = mpi_rank % count; + } #endif - if (device < 0) - { - printf("Negative CUDA device specified: %d, invalid!\n", device); - exit(1); - } - bestDevice = device; - } - - /* Set CUDA processes to appropriate devices */ - cudaGetDeviceProperties(&deviceProp, bestDevice); - if (deviceProp.computeMode == 0) - { - checkCudaErrors(cudaSetDevice(bestDevice)); - } - else - { - if (DebugOutput >= 1) - { - printf("CUDA device %d is not set in DEFAULT mode, make sure that CUDA processes are pinned as planned!\n", bestDevice); - printf("Pinning process %d to CUDA device %d\n", mpi_rank, bestDevice); - } - checkCudaErrors(cudaSetDevice(bestDevice)); - /* This synchronization is needed in order to detect bogus silent errors from cudaSetDevice call */ - checkCudaErrors(cudaDeviceSynchronize()); - } - - /* Debugging information about CUDA devices used by the current process */ - if (DebugOutput >= 3) - { - printf("Using CUDA Device %s with Properties:\n", deviceProp.name); - printf("totalGlobalMem = %lld\n", (unsigned long long int) deviceProp.totalGlobalMem); - printf("sharedMemPerBlock = %lld\n", (unsigned long long int) deviceProp.sharedMemPerBlock); - printf("regsPerBlock = %d\n", deviceProp.regsPerBlock); - printf("warpSize = %d\n", deviceProp.warpSize); - printf("memPitch = %lld\n", (unsigned long long int) deviceProp.memPitch); - printf("maxThreadsPerBlock = %d\n", deviceProp.maxThreadsPerBlock); - printf("maxThreadsDim = %d %d %d\n", deviceProp.maxThreadsDim[0], deviceProp.maxThreadsDim[1], deviceProp.maxThreadsDim[2]); - printf("maxGridSize = %d %d %d\n", deviceProp.maxGridSize[0], deviceProp.maxGridSize[1], deviceProp.maxGridSize[2]); - printf("totalConstMem = %lld\n", (unsigned long long int) deviceProp.totalConstMem); - printf("major = %d\n", deviceProp.major); - printf("minor = %d\n", deviceProp.minor); - printf("clockRate = %d\n", deviceProp.clockRate); - printf("memoryClockRate = %d\n", deviceProp.memoryClockRate); - printf("multiProcessorCount = %d\n", deviceProp.multiProcessorCount); - printf("textureAlignment = %lld\n", (unsigned long long int) deviceProp.textureAlignment); - printf("computeMode = %d\n", deviceProp.computeMode); + if (device < 0) + { + printf("Negative CUDA device specified: %d, invalid!\n", device); + exit(1); + } + bestDevice = device; + } + + /* Set CUDA processes to appropriate devices */ + cudaGetDeviceProperties(&deviceProp, bestDevice); + if (deviceProp.computeMode == 0) + { + checkCudaErrors(cudaSetDevice(bestDevice)); + } + else + { + if (DebugOutput >= 1) + { + printf("CUDA device %d is not set in DEFAULT mode, make sure that CUDA " + "processes are pinned as planned!\n", + bestDevice); + printf("Pinning process %d to CUDA device %d\n", mpi_rank, bestDevice); + } + checkCudaErrors(cudaSetDevice(bestDevice)); + /* This synchronization is needed in order to detect bogus silent errors + * from cudaSetDevice call */ + checkCudaErrors(cudaDeviceSynchronize()); + } + + /* Debugging information about CUDA devices used by the current process */ + if (DebugOutput >= 2) + { + printf("Using CUDA Device %s with Properties:\n", deviceProp.name); + printf("totalGlobalMem = %lld\n", + (unsigned long long int) deviceProp.totalGlobalMem); + printf("sharedMemPerBlock = %lld\n", + (unsigned long long int) deviceProp.sharedMemPerBlock); + printf("regsPerBlock = %d\n", deviceProp.regsPerBlock); + printf("warpSize = %d\n", deviceProp.warpSize); + printf("memPitch = %lld\n", (unsigned long long int) deviceProp.memPitch); + printf("maxThreadsPerBlock = %d\n", deviceProp.maxThreadsPerBlock); + printf("maxThreadsDim = %d %d %d\n", deviceProp.maxThreadsDim[0], + deviceProp.maxThreadsDim[1], deviceProp.maxThreadsDim[2]); + printf("maxGridSize = %d %d %d\n", deviceProp.maxGridSize[0], + deviceProp.maxGridSize[1], deviceProp.maxGridSize[2]); + printf("totalConstMem = %lld\n", + (unsigned long long int) deviceProp.totalConstMem); + printf("major = %d\n", deviceProp.major); + printf("minor = %d\n", deviceProp.minor); + printf("clockRate = %d\n", deviceProp.clockRate); + printf("memoryClockRate = %d\n", deviceProp.memoryClockRate); + printf("multiProcessorCount = %d\n", deviceProp.multiProcessorCount); + printf("textureAlignment = %lld\n", + (unsigned long long int) deviceProp.textureAlignment); + printf("computeMode = %d\n", deviceProp.computeMode); #if CUDA_VERSION > 3010 - size_t free, total; + size_t free, total; #else - unsigned int free, total; + unsigned int free, total; #endif - if (deviceProp.computeMode == 0) - { - CUdevice tmpDevice; - cuErrorCheck(cuDeviceGet(&tmpDevice, bestDevice)); - CUcontext tmpContext; - cuErrorCheck(cuCtxCreate(&tmpContext, 0, tmpDevice)); - cuErrorCheck(cuMemGetInfo(&free, &total)); - cuErrorCheck(cuCtxDestroy(tmpContext)); - } - else - { - cuErrorCheck(cuMemGetInfo(&free, &total)); - } - printf("free memory = %lld; total memory = %lld\n", free, total); - } - - if (DebugOutput >= 1) - { - printf("BioEM for CUDA initialized (MPI Rank %d), %d GPUs found, using GPU %d\n", mpi_rank, count, bestDevice); - } - - return(0); + if (deviceProp.computeMode == 0) + { + CUdevice tmpDevice; + cuErrorCheck(cuDeviceGet(&tmpDevice, bestDevice)); + CUcontext tmpContext; + cuErrorCheck(cuCtxCreate(&tmpContext, 0, tmpDevice)); + cuErrorCheck(cuMemGetInfo(&free, &total)); + cuErrorCheck(cuCtxDestroy(tmpContext)); + } + else + { + cuErrorCheck(cuMemGetInfo(&free, &total)); + } + printf("free memory = %lld; total memory = %lld\n", free, total); + } + + if (DebugOutput >= 1) + { + printf("BioEM for CUDA initialized (MPI Rank %d), %d GPUs found, using GPU " + "%d\n", + mpi_rank, count, bestDevice); + } + + return (0); } int bioem_cuda::deviceInit() { - deviceExit(); - - selectCudaDevice(); - - if (FFTAlgo) GPUAlgo = 2; - - gpumap = new bioem_RefMap; - memcpy(gpumap, &RefMap, sizeof(bioem_RefMap)); - if (FFTAlgo == 0) - { - checkCudaErrors(cudaMalloc(&maps, sizeof(myfloat_t) * RefMap.ntotRefMap * RefMap.refMapSize)); - - if (GPUAlgo == 0 || GPUAlgo == 1) - { - pRefMap_device_Mod = (bioem_RefMap_Mod*) gpumap; - bioem_RefMap_Mod* RefMapGPU = new bioem_RefMap_Mod; - RefMapGPU->init(RefMap); - checkCudaErrors(cudaMemcpy(maps, RefMapGPU->maps, sizeof(myfloat_t) * RefMap.ntotRefMap * RefMap.refMapSize, cudaMemcpyHostToDevice)); - delete RefMapGPU; - } - else - { - checkCudaErrors(cudaMemcpy(maps, RefMap.maps, sizeof(myfloat_t) * RefMap.ntotRefMap * RefMap.refMapSize, cudaMemcpyHostToDevice)); - } - } - checkCudaErrors(cudaMalloc(&sum, sizeof(myfloat_t) * RefMap.ntotRefMap)); - checkCudaErrors(cudaMemcpy(sum, RefMap.sum_RefMap, sizeof(myfloat_t) * RefMap.ntotRefMap, cudaMemcpyHostToDevice)); - checkCudaErrors(cudaMalloc(&sumsquare, sizeof(myfloat_t) * RefMap.ntotRefMap)); - checkCudaErrors(cudaMemcpy(sumsquare, RefMap.sumsquare_RefMap, sizeof(myfloat_t) * RefMap.ntotRefMap, cudaMemcpyHostToDevice)); - gpumap->maps = maps; - gpumap->sum_RefMap = sum; - gpumap->sumsquare_RefMap = sumsquare; - - checkCudaErrors(cudaMalloc(&pProb_memory, pProb_device.get_size(RefMap.ntotRefMap, param.nTotGridAngles, param.nTotCC, param.param_device.writeAngles, param.param_device.writeCC))); - - for (int i = 0; i < 2; i++) - { - checkCudaErrors(cudaStreamCreate(&cudaStream[i])); - checkCudaErrors(cudaEventCreate(&cudaEvent[i])); - checkCudaErrors(cudaEventCreate(&cudaFFTEvent[i])); - checkCudaErrors(cudaMalloc(&pConvMap_device[i], sizeof(myfloat_t) * RefMap.refMapSize)); - } - if (GPUAsync) - { - checkCudaErrors(cudaStreamCreate(&cudaStream[2])); - checkCudaErrors(cudaEventCreate(&cudaEvent[2])); - } - - if (FFTAlgo) - { - checkCudaErrors(cudaMalloc(&pRefMapsFFT, RefMap.ntotRefMap * param.FFTMapSize * sizeof(mycomplex_t))); - checkCudaErrors(cudaMalloc(&pFFTtmp2[0], CUDA_FFTS_AT_ONCE * param.FFTMapSize * 2 * sizeof(mycomplex_t))); - checkCudaErrors(cudaMalloc(&pFFTtmp[0], CUDA_FFTS_AT_ONCE * param.param_device.NumberPixels * param.param_device.NumberPixels * 2 * sizeof(myfloat_t))); - pFFTtmp2[1] = pFFTtmp2[0] + CUDA_FFTS_AT_ONCE * param.FFTMapSize; - pFFTtmp[1] = pFFTtmp[0] + CUDA_FFTS_AT_ONCE * param.param_device.NumberPixels * param.param_device.NumberPixels; - checkCudaErrors(cudaMalloc(&pConvMapFFT, param.FFTMapSize * sizeof(mycomplex_t) * 2)); - checkCudaErrors(cudaHostAlloc(&pConvMapFFT_Host, param.FFTMapSize * sizeof(mycomplex_t) * 2, 0)); - checkCudaErrors(cudaMemcpy(pRefMapsFFT, RefMap.RefMapsFFT, RefMap.ntotRefMap * param.FFTMapSize * sizeof(mycomplex_t), cudaMemcpyHostToDevice)); - } - - deviceInitialized = 1; - return(0); + deviceExit(); + + selectCudaDevice(); + + gpumap = new bioem_RefMap; + memcpy(gpumap, &RefMap, sizeof(bioem_RefMap)); + + checkCudaErrors(cudaMalloc(&sum, sizeof(myfloat_t) * RefMap.ntotRefMap)); + checkCudaErrors(cudaMemcpy(sum, RefMap.sum_RefMap, + sizeof(myfloat_t) * RefMap.ntotRefMap, + cudaMemcpyHostToDevice)); + checkCudaErrors( + cudaMalloc(&sumsquare, sizeof(myfloat_t) * RefMap.ntotRefMap)); + checkCudaErrors(cudaMemcpy(sumsquare, RefMap.sumsquare_RefMap, + sizeof(myfloat_t) * RefMap.ntotRefMap, + cudaMemcpyHostToDevice)); + gpumap->sum_RefMap = sum; + gpumap->sumsquare_RefMap = sumsquare; + + checkCudaErrors( + cudaMalloc(&pProb_memory, + pProb_device.get_size(RefMap.ntotRefMap, param.nTotGridAngles, + param.param_device.writeAngles))); + + for (int i = 0; i < PIPELINE_LVL; i++) + { + checkCudaErrors(cudaStreamCreate(&cudaStream[i])); + checkCudaErrors(cudaEventCreate(&cudaEvent[i])); + } + for (int i = 0; i < MULTISTREAM_LVL; i++) + { + checkCudaErrors(cudaEventCreate(&cudaFFTEvent[i])); + } + if (GPUAsync) + { + checkCudaErrors(cudaStreamCreate(&cudaStream[2])); + checkCudaErrors(cudaEventCreate(&cudaEvent[2])); + } + + checkCudaErrors( + cudaMalloc(&pRefMapsFFT, + RefMap.ntotRefMap * param.FFTMapSize * sizeof(mycomplex_t))); + checkCudaErrors( + cudaMalloc(&pFFTtmp2[0], param.nTotParallelConv * param.nTotParallelMaps * + param.FFTMapSize * MULTISTREAM_LVL * + sizeof(mycomplex_t))); + checkCudaErrors( + cudaMalloc(&pFFTtmp[0], param.nTotParallelConv * param.nTotParallelMaps * + param.param_device.NumberPixels * + param.param_device.NumberPixels * + MULTISTREAM_LVL * sizeof(myfloat_t))); + for (int i = 1; i < MULTISTREAM_LVL; i++) + { + pFFTtmp2[i] = + pFFTtmp2[0] + + i * param.nTotParallelConv * param.nTotParallelMaps * param.FFTMapSize; + pFFTtmp[i] = pFFTtmp[0] + + i * param.nTotParallelConv * param.nTotParallelMaps * + param.param_device.NumberPixels * + param.param_device.NumberPixels; + } + checkCudaErrors(cudaMalloc(&pConvMapFFT, param.nTotParallelConv * + param.FFTMapSize * PIPELINE_LVL * + sizeof(mycomplex_t))); + checkCudaErrors(cudaHostAlloc(&pConvMapFFT_Host, + param.nTotParallelConv * param.FFTMapSize * + PIPELINE_LVL * sizeof(mycomplex_t), + 0)); + checkCudaErrors( + cudaMemcpy(pRefMapsFFT, RefMap.RefMapsFFT, + RefMap.ntotRefMap * param.FFTMapSize * sizeof(mycomplex_t), + cudaMemcpyHostToDevice)); + checkCudaErrors( + cudaMalloc(&pTmp_comp_params, + param.nTotParallelConv * PIPELINE_LVL * sizeof(myparam5_t))); + Ncomp_blocks = divup(param.nTotParallelConv * param.param_device.NtotDisp, + CudaThreadCount); + if (Ncomp_blocks > CudaThreadCount) + { + cout << "Error with input parameters. Check CudaThreadCount, " + "displacements and max number of parallel comparisons\n"; + exit(1); + } + checkCudaErrors( + cudaMalloc(&pTmp_comp_blocks, + Ncomp_blocks * RefMap.ntotRefMap * sizeof(myblockGPU_t))); + + initialized_const = new bool[RefMap.ntotRefMap]; + for (int i = 0; i < RefMap.ntotRefMap; i++) + initialized_const[i] = false; + + deviceInitialized = 1; + return (0); } int bioem_cuda::deviceExit() { - if (deviceInitialized == 0) return(0); - - - cudaFree(pProb_memory); - cudaFree(sum); - cudaFree(sumsquare); - for (int i = 0; i < 2; i++) - { - cudaStreamDestroy(cudaStream[i]); - cudaEventDestroy(cudaEvent[i]); - cudaEventDestroy(cudaFFTEvent[i]); - cudaFree(pConvMap_device[i]); - } - if (FFTAlgo) - { - cudaFree(pRefMapsFFT); - cudaFree(pConvMapFFT); - cudaFreeHost(pConvMapFFT_Host); - cudaFree(pFFTtmp[0]); - cudaFree(pFFTtmp2[0]); - } - else - { - cudaFree(maps); - } - if (GPUAlgo == 0 || GPUAlgo == 1) - { - cudaFree(pRefMap_device_Mod); - } - if (GPUAsync) - { - cudaStreamDestroy(cudaStream[2]); - cudaEventDestroy(cudaEvent[2]); - } - - delete gpumap; - cudaThreadExit(); - - deviceInitialized = 0; - return(0); + if (deviceInitialized == 0) + return (0); + + cudaFree(pProb_memory); + cudaFree(sum); + cudaFree(sumsquare); + for (int i = 0; i < PIPELINE_LVL; i++) + { + cudaStreamDestroy(cudaStream[i]); + cudaEventDestroy(cudaEvent[i]); + } + for (int i = 0; i < MULTISTREAM_LVL; i++) + { + cudaEventDestroy(cudaFFTEvent[i]); + } + + cudaFree(pRefMapsFFT); + cudaFree(pConvMapFFT); + cudaFreeHost(pConvMapFFT_Host); + cudaFree(pFFTtmp[0]); + cudaFree(pFFTtmp2[0]); + cudaFree(pTmp_comp_params); + cudaFree(pTmp_comp_blocks); + + if (GPUAsync) + { + cudaStreamDestroy(cudaStream[2]); + cudaEventDestroy(cudaEvent[2]); + } + + delete gpumap; + delete initialized_const; + cudaThreadExit(); + + deviceInitialized = 0; + return (0); } int bioem_cuda::deviceStartRun() { - if (GPUWorkload >= 100) - { - maxRef = RefMap.ntotRefMap; - pProb_host = &pProb; - } - else - { - maxRef = RefMap.ntotRefMap == 1 ? (size_t) RefMap.ntotRefMap : (size_t) RefMap.ntotRefMap * (size_t) GPUWorkload / 100; - pProb_host = new bioem_Probability; - pProb_host->init(maxRef, param.nTotGridAngles, param.nTotCC, *this); - pProb_host->copyFrom(&pProb, *this); - } - - pProb_device = *pProb_host; - pProb_device.ptr = pProb_memory; - pProb_device.set_pointers(); - checkCudaErrors(cudaMemcpyAsync(pProb_device.ptr, pProb_host->ptr, pProb_host->get_size(maxRef, param.nTotGridAngles, param.nTotCC, param.param_device.writeAngles, param.param_device.writeCC), cudaMemcpyHostToDevice, cudaStream[0])); - - if (FFTAlgo) - { - for (int j = 0;j < 2;j++) - { - for (int i = 0; i < 2; i++) - { - if (i && maxRef % CUDA_FFTS_AT_ONCE == 0) continue; - int n[2] = {param.param_device.NumberPixels, param.param_device.NumberPixels}; - if (cufftPlanMany(&plan[i][j], 2, n, NULL, 1, param.FFTMapSize, NULL, 1, 0, MY_CUFFT_C2R, i ? (maxRef % CUDA_FFTS_AT_ONCE) : CUDA_FFTS_AT_ONCE) != CUFFT_SUCCESS) - { - cout << "Error planning CUFFT\n"; - exit(1); - } - if (cufftSetCompatibilityMode(plan[i][j], CUFFT_COMPATIBILITY_FFTW_PADDING) != CUFFT_SUCCESS) - { - cout << "Error planning CUFFT compatibility\n"; - exit(1); - } - if (cufftSetStream(plan[i][j], cudaStream[j]) != CUFFT_SUCCESS) - { - cout << "Error setting CUFFT stream\n"; - exit(1); - } - } - if (!GPUDualStream) break; - } - } - return(0); + if (GPUWorkload >= 100) + { + maxRef = RefMap.ntotRefMap; + pProb_host = &pProb; + } + else + { + maxRef = ((size_t) RefMap.ntotRefMap * (size_t) GPUWorkload / 100) < 1 ? + (size_t) RefMap.ntotRefMap : + (size_t) RefMap.ntotRefMap * (size_t) GPUWorkload / 100; + pProb_host = new bioem_Probability; + pProb_host->init(maxRef, param.nTotGridAngles, *this); + pProb_host->copyFrom(&pProb, *this); + } + + pProb_device = *pProb_host; + pProb_device.ptr = pProb_memory; + pProb_device.set_pointers(); + checkCudaErrors( + cudaMemcpyAsync(pProb_device.ptr, pProb_host->ptr, + pProb_host->get_size(maxRef, param.nTotGridAngles, + param.param_device.writeAngles), + cudaMemcpyHostToDevice, cudaStream[0])); + + if (maxRef / (param.nTotParallelMaps * param.nTotParallelConv) > + (double) SPLIT_MAPS_LVL) + { + cout << "Error planning CUFFT dimensions\n"; + exit(1); + } + for (int j = 0; j < MULTISTREAM_LVL; j++) + { + for (int i = 0; i < SPLIT_MAPS_LVL; i++) + { + if (i && maxRef % param.nTotParallelMaps == 0) + continue; + int n[2] = {param.param_device.NumberPixels, + param.param_device.NumberPixels}; + if (cufftPlanMany( + &plan[i][j], 2, n, NULL, 1, param.FFTMapSize, NULL, 1, 0, + MY_CUFFT_C2R, + i ? ((maxRef % param.nTotParallelMaps) * param.nTotParallelConv) : + (param.nTotParallelMaps * param.nTotParallelConv)) != + CUFFT_SUCCESS) + { + cout << "Error planning CUFFT\n"; + exit(1); + } + if (cufftSetCompatibilityMode( + plan[i][j], CUFFT_COMPATIBILITY_FFTW_PADDING) != CUFFT_SUCCESS) + { + cout << "Error planning CUFFT compatibility\n"; + exit(1); + } + if (cufftSetStream(plan[i][j], cudaStream[j]) != CUFFT_SUCCESS) + { + cout << "Error setting CUFFT stream\n"; + exit(1); + } + } + if (!GPUDualStream) + break; + } + + return (0); } int bioem_cuda::deviceFinishRun() { - if (GPUAsync) cudaStreamSynchronize(cudaStream[0]); - checkCudaErrors(cudaMemcpyAsync(pProb_host->ptr, pProb_device.ptr, pProb_host->get_size(maxRef, param.nTotGridAngles, param.nTotCC, param.param_device.writeAngles, param.param_device.writeCC), cudaMemcpyDeviceToHost, cudaStream[0])); - - if (FFTAlgo) - { - for (int j = 0;j < 2;j++) - { - for (int i = 0; i < 2; i++) - { - if (i && maxRef % CUDA_FFTS_AT_ONCE == 0) continue; - cufftDestroy(plan[i][j]); - } - if (!GPUDualStream) break; - } - } - cudaThreadSynchronize(); - if (GPUWorkload < 100) - { - pProb.copyFrom(pProb_host, *this); - free_device_host(pProb_host->ptr); - delete[] pProb_host; - } - - return(0); -} + if (GPUAsync) + cudaStreamSynchronize(cudaStream[0]); + checkCudaErrors( + cudaMemcpyAsync(pProb_host->ptr, pProb_device.ptr, + pProb_host->get_size(maxRef, param.nTotGridAngles, + param.param_device.writeAngles), + cudaMemcpyDeviceToHost, cudaStream[0])); + + for (int j = 0; j < MULTISTREAM_LVL; j++) + { + for (int i = 0; i < SPLIT_MAPS_LVL; i++) + { + if (i && maxRef % param.nTotParallelMaps == 0) + continue; + cufftDestroy(plan[i][j]); + } + if (!GPUDualStream) + break; + } -void* bioem_cuda::malloc_device_host(size_t size) -{ - void* ptr; - checkCudaErrors(cudaHostAlloc(&ptr, size, 0)); - return(ptr); + cudaThreadSynchronize(); + if (GPUWorkload < 100) + { + pProb.copyFrom(pProb_host, *this); + free_device_host(pProb_host->ptr); + delete[] pProb_host; + } + + return (0); } -void bioem_cuda::free_device_host(void* ptr) +void *bioem_cuda::malloc_device_host(size_t size) { - cudaFreeHost(ptr); + void *ptr; + checkCudaErrors(cudaHostAlloc(&ptr, size, 0)); + return (ptr); } +void bioem_cuda::free_device_host(void *ptr) { cudaFreeHost(ptr); } + void bioem_cuda::rebalance(int workload) { - if ((workload < 0) || (workload > 100) || (workload == GPUWorkload)) return; + if ((workload < 0) || (workload > 100) || (workload == GPUWorkload)) + return; - deviceFinishRun(); + deviceFinishRun(); - if (DebugOutput >= 2) - { - printf("\t\tSetting GPU workload to %d%% (rank %d)\n", workload, mpi_rank); - } + if (DebugOutput >= 2) + { + printf("\t\tSetting GPU workload to %d%% (rank %d)\n", workload, mpi_rank); + } - GPUWorkload = workload; - maxRef = (size_t) RefMap.ntotRefMap * (size_t) GPUWorkload / 100; + GPUWorkload = workload; + maxRef = (size_t) RefMap.ntotRefMap * (size_t) GPUWorkload / 100; - deviceStartRun(); + deviceStartRun(); } -bioem* bioem_cuda_create() +bioem *bioem_cuda_create() { - int count; - - if (cudaGetDeviceCount(&count) != cudaSuccess) count = 0; - if (count == 0) - { - printf("No CUDA device available, using fallback to CPU version\n"); - return new bioem; - } - - return new bioem_cuda; + int count; + + if (cudaGetDeviceCount(&count) != cudaSuccess) + count = 0; + if (count == 0) + { + printf("No CUDA device available, using fallback to CPU version\n"); + return new bioem; + } + + return new bioem_cuda; } diff --git a/include/autotuner.h b/include/autotuner.h index 10db9ca8d21810f883d4d3bbf74dd9895a9e1498..64ad3ae071a6133da6153233f38e0a0a8166d767 100644 --- a/include/autotuner.h +++ b/include/autotuner.h @@ -1,9 +1,11 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, Markus Rampp, Luka Stanisic and Gerhard + Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. + Max Planck Computing and Data Facility, Garching, Germany. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -11,52 +13,58 @@ #ifndef AUTOTUNER_H #define AUTOTUNER_H -class Autotuner { +class Autotuner +{ public: - Autotuner() {stopTuning = true;} + Autotuner() { stopTuning = true; } - /* Setting variables to initial values */ - inline void Initialize(int alg=3, int st=7) {algo = alg; stable=st; Reset(); } + /* Setting variables to initial values */ + inline void Initialize(int alg = 3, int st = 7) + { + algo = alg; + stable = st; + Reset(); + } - /* Resetting variables to initial values */ - void Reset(); + /* Resetting variables to initial values */ + void Reset(); - /* Check if autotuning is needed, depending on which comparison is finished */ - bool Needed(int iteration); + /* Check if autotuning is needed, depending on which comparison is finished */ + bool Needed(int iteration); - /* Check if optimal workload value has been computed */ - bool Finished(); + /* Check if optimal workload value has been computed */ + bool Finished(); - /* Set a new workload value to test, depending on the algorithm */ - void Tune(double compTime); + /* Set a new workload value to test, depending on the algorithm */ + void Tune(double compTime); - /* Return workload value */ - inline int Workload() {return workload;} + /* Return workload value */ + inline int Workload() { return workload; } private: - int algo; - int stable; - - bool stopTuning; - int workload; - - /* Variables needed for AlgoSimple and AlgoRatio */ - double best_time; - int best_workload; - - /* Variables needed for AlgoBisection */ - int a; - int b; - int c; - int x; - int limit; - double fb, fx; - - /* Autotuning algorithms */ - void AlgoSimple(double compTime); - void AlgoRatio(double compTime); - void AlgoBisection(double compTime); + int algo; + int stable; + + bool stopTuning; + int workload; + + /* Variables needed for AlgoSimple and AlgoRatio */ + double best_time; + int best_workload; + + /* Variables needed for AlgoBisection */ + int a; + int b; + int c; + int x; + int limit; + double fb, fx; + + /* Autotuning algorithms */ + void AlgoSimple(double compTime); + void AlgoRatio(double compTime); + void AlgoBisection(double compTime); }; #endif diff --git a/include/bioem.h b/include/bioem.h index 813acec26c2bcaeaa78459402d1f8eec0d8997c1..8aa3f3faa1201923fc640483a30304dc2d398d0a 100644 --- a/include/bioem.h +++ b/include/bioem.h @@ -1,12 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -14,66 +15,87 @@ #ifndef BIOEM_H #define BIOEM_H -#include "defs.h" #include "bioem.h" -#include "model.h" +#include "defs.h" #include "map.h" +#include "model.h" #include "param.h" class bioem { - friend class bioem_RefMap; - friend class bioem_Probability; + friend class bioem_RefMap; + friend class bioem_Probability; public: - bioem(); - virtual ~bioem(); - - int configure(int ac, char* av[]); - void cleanup(); //Cleanup everything happening during configure - - int precalculate(); // Is it better to pass directly the input File names? - int dopreCalCrossCorrelation(int iRefMap, int iRefMapLocal); - int run(); - int doProjections(int iMap); - int createConvolutedProjectionMap(int iOreint, int iMap, mycomplex_t* lproj, myfloat_t* Mapconv, mycomplex_t* localmultFFT, myfloat_t& sumC, myfloat_t& sumsquareC); - - virtual int compareRefMaps(int iOrient, int iConv, myfloat_t amp, myfloat_t pha, myfloat_t env, const myfloat_t* conv_map, mycomplex_t* localmultFFT, myfloat_t sumC, myfloat_t sumsquareC, const int startMap = 0); - - virtual void* malloc_device_host(size_t size); - virtual void free_device_host(void* ptr); - virtual void rebalance(int workload); //Rebalance GPUWorkload - void rebalanceWrapper(int workload); //Rebalance wrapper - - int createProjection(int iMap, mycomplex_t* map); - int calcross_cor(myfloat_t* localmap, myfloat_t& sum, myfloat_t& sumsquare); - void calculateCCFFT(int iMap, int iOrient, int iConv, myfloat_t amp, myfloat_t pha, myfloat_t env, myfloat_t sumC, myfloat_t sumsquareC, mycomplex_t* localConvFFT, mycomplex_t* localCCT, myfloat_t* lCC); - - bioem_Probability pProb; - - string OutfileName; - bool yesoutfilename; - + bioem(); + virtual ~bioem(); + + void printOptions(myoption_t *myoptions, int myoptions_length); + int readOptions(int ac, char *av[]); + int configure(int ac, char *av[]); + void cleanup(); // Cleanup everything happening during configure + + int precalculate(); // Is it better to pass directly the input File names? + inline int needToPrintModel() { return param.printModel; } + int printModel(); + int run(); + int doProjections(int iMap); + int createConvolutedProjectionMap(int iOreint, int iMap, mycomplex_t *lproj, + mycomplex_t *localmultFFT, myfloat_t &sumC, + myfloat_t &sumsquareC); + int createConvolutedProjectionMap_noFFT(mycomplex_t *lproj, + myfloat_t *Mapconv, + mycomplex_t *localmultFFT, + myfloat_t &sumC, + myfloat_t &sumsquareC); + + virtual int compareRefMaps(int iPipeline, int iOrient, int iConv, + int maxParallelConv, mycomplex_t *localmultFFT, + myparam5_t *comp_params, const int startMap = 0); + + virtual void *malloc_device_host(size_t size); + virtual void free_device_host(void *ptr); + virtual void rebalance(int workload); // Rebalance GPUWorkload + void rebalanceWrapper(int workload); // Rebalance wrapper + + int createProjection(int iMap, mycomplex_t *map); + int calcross_cor(myfloat_t *localmap, myfloat_t &sum, myfloat_t &sumsquare); + void calculateCCFFT(int iMap, mycomplex_t *localConvFFT, + mycomplex_t *localCCT, myfloat_t *lCC); + void doRefMap_CPU_Parallel(int iRefMap, int iOrient, int iConv, + myfloat_t *lCC, myparam5_t *comp_params, + myblockCPU_t *comp_block); + void doRefMap_CPU_Reduce(int iRefMap, int iOrient, int iConvStart, + int maxParallelConv, myparam5_t *comp_params, + myblockCPU_t *comp_block); + + bioem_Probability pProb; + + string OutfileName; protected: - virtual int deviceInit(); - virtual int deviceStartRun(); - virtual int deviceFinishRun(); - - bioem_param param; - bioem_model Model; - bioem_RefMap RefMap; - - int nReferenceMaps; //Maps in memory at a time - int nReferenceMapsTotal; //Maps in total - - int nProjectionMaps; //Maps in memory at a time - int nProjectionMapsTotal; //Maps in total - - int FFTAlgo; //Use the FFT Algorithm (Default 1) - int DebugOutput; //Debug Output Level (Default 2) - int nProjectionsAtOnce; //Number of projections to do at once via OpenMP (Default 1) - bool Autotuning; //Do the autotuning of the load-balancing between CPUs and GPUs + virtual int deviceInit(); + virtual int deviceStartRun(); + virtual int deviceFinishRun(); + + bioem_param param; + bioem_model Model; + bioem_RefMap RefMap; + + int nReferenceMaps; // Maps in memory at a time + int nReferenceMapsTotal; // Maps in total + + int nProjectionMaps; // Maps in memory at a time + int nProjectionMapsTotal; // Maps in total + + int BioEMAlgo; // BioEM algorithm used to do comparison (Default 1) + int CudaThreadCount; // Number of CUDA threads used in each block (Default + // depends on the BioEM algorithm) + int DebugOutput; // Debug Output Level (Default 0) + int nProjectionsAtOnce; // Number of projections to do at once via OpenMP + // (Default number of OMP threads) + bool Autotuning; // Do the autotuning of the load-balancing between CPUs and + // GPUs (Default 1, if GPUs are used and GPUWORKLOAD is not specified) }; #endif diff --git a/include/bioem_cuda.h b/include/bioem_cuda.h index 99add42be1576028c88d7f66b209656de7797041..6a4552a11c6beeab13e4b1e53f10aae5678b144f 100644 --- a/include/bioem_cuda.h +++ b/include/bioem_cuda.h @@ -1,12 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -16,6 +17,6 @@ #include "bioem.h" -extern bioem* bioem_cuda_create(); +extern bioem *bioem_cuda_create(); #endif diff --git a/include/bioem_cuda_internal.h b/include/bioem_cuda_internal.h index 708b40fb3e9a2a10b265965baaa224244159b975..1b269a393bc28b5e79f69fa6211f770c62f02e1e 100644 --- a/include/bioem_cuda_internal.h +++ b/include/bioem_cuda_internal.h @@ -1,12 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -17,7 +18,7 @@ #include #include -//Hack to make nvcc compiler accept fftw.h, float128 is not used anyway +// Hack to make nvcc compiler accept fftw.h, float128 is not used anyway #define __float128 double #include #undef __float128 @@ -27,51 +28,60 @@ class bioem_cuda : public bioem { public: - bioem_cuda(); - virtual ~bioem_cuda(); + bioem_cuda(); + virtual ~bioem_cuda(); - virtual int compareRefMaps(int iOrient, int iConv, myfloat_t amp, myfloat_t pha, myfloat_t env, const myfloat_t* conv_map, mycomplex_t* localmultFFT, myfloat_t sumC, myfloat_t sumsquareC, const int startMap = 0); - virtual void* malloc_device_host(size_t size); - virtual void free_device_host(void* ptr); - virtual void rebalance(int workload); //Rebalance GPUWorkload + virtual int compareRefMaps(int iPipeline, int iOrient, int iConv, + int maxParallelConv, mycomplex_t *localmultFFT, + myparam5_t *comp_params, const int startMap = 0); + virtual void *malloc_device_host(size_t size); + virtual void free_device_host(void *ptr); + virtual void rebalance(int workload); // Rebalance GPUWorkload protected: - virtual int deviceInit(); - virtual int deviceStartRun(); - virtual int deviceFinishRun(); - int deviceExit(); - + virtual int deviceInit(); + virtual int deviceStartRun(); + virtual int deviceFinishRun(); + int deviceExit(); + private: - int selectCudaDevice(); - - int deviceInitialized; - - cudaStream_t cudaStream[3]; - cudaEvent_t cudaEvent[3]; - cudaEvent_t cudaFFTEvent[2]; - bioem_RefMap_Mod* pRefMap_device_Mod; - bioem_RefMap* gpumap; - bioem_Probability* pProb_host; - bioem_Probability pProb_device; - void* pProb_memory; - myfloat_t* pConvMap_device[2]; - - mycomplex_t* pRefMapsFFT; - mycomplex_t* pConvMapFFT; - mycomplex_t* pConvMapFFT_Host; - mycuComplex_t* pFFTtmp2[2]; - myfloat_t* pFFTtmp[2]; - cufftHandle plan[2][2]; - - myfloat_t *maps, *sum, *sumsquare; - - int GPUAlgo; //GPU Algorithm to use, 0: parallelize over maps, 1: as 0 but work split in multiple kernels (better), 2: also parallelize over shifts (best) - int GPUAsync; //Run GPU Asynchronously, do the convolutions on the host in parallel. - int GPUDualStream; //Use two streams to improve paralelism - int GPUWorkload; //Percentage of workload to perform on GPU. Default 100. Rest is done on processor in parallel. - - int maxRef; + int selectCudaDevice(); + + int deviceInitialized; + + cudaStream_t cudaStream[PIPELINE_LVL + 1]; // Streams are used for both + // PIPELINE and MULTISTREAM control + cudaEvent_t cudaEvent[PIPELINE_LVL + 1]; + cudaEvent_t cudaFFTEvent[MULTISTREAM_LVL]; + bioem_RefMap *gpumap; + bioem_Probability *pProb_host; + bioem_Probability pProb_device; + void *pProb_memory; + + mycomplex_t *pRefMapsFFT; + mycomplex_t *pConvMapFFT; + mycomplex_t *pConvMapFFT_Host; + mycuComplex_t *pFFTtmp2[MULTISTREAM_LVL]; + myfloat_t *pFFTtmp[MULTISTREAM_LVL]; + cufftHandle plan[SPLIT_MAPS_LVL][MULTISTREAM_LVL]; + + myparam5_t *pTmp_comp_params; + + myblockGPU_t *pTmp_comp_blocks; + int Ncomp_blocks; + + bool *initialized_const; // In order to make sure Constoadd is initialized to + // the first value + + myfloat_t *sum, *sumsquare; + + int GPUAsync; // Run GPU Asynchronously, do the convolutions on the host in + // parallel. + int GPUDualStream; // Use two streams to improve paralelism + int GPUWorkload; // Percentage of workload to perform on GPU. Default 100. + // Rest is done on processor in parallel. + + int maxRef; }; #endif - diff --git a/include/defs.h b/include/defs.h index b7338ca8246126becf8cebce6191b0fa7ca86ec6..70438dd27ad804c763a36e255beb9439bad8aa09 100644 --- a/include/defs.h +++ b/include/defs.h @@ -1,12 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -14,11 +15,22 @@ #ifndef BIOEM_DEFS_H #define BIOEM_DEFS_H +#define BIOEM_PROB_DOUBLE //#define BIOEM_USE_DOUBLE +//#define DEBUG +//#define DEBUG_GPU +//#define DEBUG_PROB -//#define PILAR_DEBUG +#ifndef BIOEM_PROB_DOUBLE +typedef float myprob_t; +#define MY_MPI_FLOAT MPI_FLOAT +#else +typedef double myprob_t; +#define MY_MPI_FLOAT MPI_DOUBLE +#endif #ifndef BIOEM_USE_DOUBLE +#define MIN_PROB -999999. typedef float myfloat_t; #define myfftw_malloc fftwf_malloc #define myfftw_free fftwf_free @@ -35,9 +47,9 @@ typedef float myfloat_t; #define MY_CUFFT_C2R CUFFT_C2R #define mycufftExecC2R cufftExecC2R #define mycuComplex_t cuComplex -#define MY_MPI_FLOAT MPI_FLOAT #else typedef double myfloat_t; +#define MIN_PROB -999999. #define myfftw_malloc fftw_malloc #define myfftw_free fftw_free #define myfftw_destroy_plan fftw_destroy_plan @@ -53,17 +65,62 @@ typedef double myfloat_t; #define mycufftExecC2R cufftExecZ2D #define mycuComplex_t cuDoubleComplex #define MY_CUFFT_C2R CUFFT_Z2D -#define MY_MPI_FLOAT MPI_DOUBLE #endif typedef myfloat_t mycomplex_t[2]; -#define BIOEM_FLOAT_3_PHYSICAL_SIZE 3 //Possible set to 4 for GPU +#define BIOEM_FLOAT_3_PHYSICAL_SIZE 3 // Possible set to 4 for GPU struct myfloat3_t { - myfloat_t pos[BIOEM_FLOAT_3_PHYSICAL_SIZE]; - myfloat_t quat4; - // myfloat_t prior; + myfloat_t pos[BIOEM_FLOAT_3_PHYSICAL_SIZE]; + myfloat_t quat4; + // myfloat_t prior; +}; + +/* myoptions +Structure for saving options, in order to mimic old Boost program_options +behaviour +*/ +struct myoption_t +{ + const char *name; + int arg; + const char *desc; + bool hidden; +}; + +/* comp_params +Put all parameters needed for each comparison in a single structure +This makes code cleaner and requires less GPU transfers +*/ +struct myparam5_t +{ + myfloat_t amp; + myfloat_t pha; + myfloat_t env; + myfloat_t sumC; + myfloat_t sumsquareC; +}; + +/* comp_block +Put all parameters created by each inside-block comparison +This makes code cleaner +*/ +// For GPUs +struct myblockGPU_t +{ + myprob_t logpro; + int id; + myprob_t sumExp; + myprob_t sumAngles; +}; +// For CPUs (easier to save value as well) +struct myblockCPU_t +{ + myprob_t logpro; + int id; + myprob_t sumExp; + myfloat_t value; }; #ifdef BIOEM_GPUCODE @@ -85,44 +142,53 @@ struct myfloat3_t #define myBlockIdxY 0 #endif -#define CUDA_THREAD_COUNT 256 -#define CUDA_BLOCK_COUNT 1024 * 16 -#define CUDA_MAX_SHIFT_REDUCE 1024 +#define OUTPUT_PRECISION 4 + +#define CUDA_THREAD_COUNT_ALGO1 256 +#define CUDA_THREAD_COUNT_ALGO2 512 +#define CUDA_THREAD_MAX 1024 #define CUDA_FFTS_AT_ONCE 1024 -//#define BIOEM_USE_NVTX + +#define PIPELINE_LVL 2 +#define MULTISTREAM_LVL 2 +#define SPLIT_MAPS_LVL 2 /* Autotuning Autotuning algorithms: - 1. AlgoSimple = 1; Testing workload values between 100 and 30, all multiples of 5. Taking the value with the best timing. - 2. AlgoRatio = 2; Comparisons where GPU handles 100% or only 1% of the workload are timed, and then the optimal workload balance is computed. - 3. AlgoBisection = 3; Based on bisection, multiple workload values are tested until the optimal one is found. + 1. AlgoSimple = 1; Testing workload values between 100 and 30, all multiples + of 5. Taking the value with the best timing. + 2. AlgoRatio = 2; Comparisons where GPU handles 100% or only 1% of the + workload are timed, and then the optimal workload balance is computed. + 3. AlgoBisection = 3; Based on bisection, multiple workload values are + tested until the optimal one is found. */ #define AUTOTUNING_ALGORITHM 3 -/* Recalibrate every X projections. Put to a very high value, i.e., 99999, to de facto disable recalibration */ +/* Recalibrate every X projections. Put to a very high value, i.e., 99999, to de + * facto disable recalibration */ #define RECALIB_FACTOR 200 /* After how many comparison iterations, comparison duration becomes stable */ #define FIRST_STABLE 7 -static inline void* mallocchk(size_t size) +static inline void *mallocchk(size_t size) { - void* ptr = malloc(size); - if (ptr == 0) - { - std::cout << "Memory allocation error\n"; - exit(1); - } - return(ptr); + void *ptr = malloc(size); + if (ptr == 0) + { + std::cout << "Memory allocation error\n"; + exit(1); + } + return (ptr); } -static inline void* reallocchk(void* oldptr, size_t size) +static inline void *reallocchk(void *oldptr, size_t size) { - void* ptr = realloc(oldptr, size); - if (ptr == 0) - { - std::cout << "Memory allocation error\n"; - exit(1); - } - return(ptr); + void *ptr = realloc(oldptr, size); + if (ptr == 0) + { + std::cout << "Memory allocation error\n"; + exit(1); + } + return (ptr); } #ifndef WITH_OPENMP diff --git a/include/map.h b/include/map.h index 88ad682c709abfeaeec11159da73b96f98a7b1ea..9081a332495dd1026634a9fb5a72ae018398d43b 100644 --- a/include/map.h +++ b/include/map.h @@ -1,12 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -18,7 +19,6 @@ #include "param.h" #include #include -#include class bioem_param; class bioem; @@ -26,137 +26,147 @@ class bioem; class bioem_RefMap { public: - bioem_RefMap() - { - maps = NULL; - RefMapsFFT = NULL; - sum_RefMap = NULL; - sumsquare_RefMap = NULL; - } - - void freePointers() - { - if (maps) free(maps); - if (sum_RefMap) free(sum_RefMap); - if (sumsquare_RefMap) free(sumsquare_RefMap); - if (RefMapsFFT) delete[] RefMapsFFT; - maps = NULL; - sum_RefMap = NULL; - sumsquare_RefMap = NULL; - RefMapsFFT = NULL; - } - int readRefMaps(bioem_param& param, const char* filemap); - int precalculate(bioem_param& param, bioem& bio); - int PreCalculateMapsFFT(bioem_param& param); - - int read_int(int *currlong, FILE *fin, int swap); - int read_float(float *currfloat, FILE *fin, int swap); - int read_float_empty (FILE *fin); - int read_char_float (float *currfloat, FILE *fin) ; - int test_mrc (const char *vol_file, int swap); - int read_MRC(const char* filename,bioem_param& param); - - mycomplex_t* RefMapsFFT; - - bool readMRC,readMultMRC; - - int ntotRefMap; - int numPixels; - int refMapSize; - myfloat_t* maps; - myfloat_t* sum_RefMap; - myfloat_t* sumsquare_RefMap; - - __host__ __device__ inline myfloat_t get(int map, int x, int y) const {return(maps[map * refMapSize + x * numPixels + y]);} - __host__ __device__ inline const myfloat_t* getp(int map, int x, int y) const {return(&maps[map * refMapSize + x * numPixels]);} - __host__ __device__ inline myfloat_t* getmap(int map) {return(&maps[map * refMapSize]);} + bioem_RefMap() + { + maps = NULL; + RefMapsFFT = NULL; + sum_RefMap = NULL; + sumsquare_RefMap = NULL; + } + + void freePointers() + { + if (maps) + free(maps); + if (sum_RefMap) + free(sum_RefMap); + if (sumsquare_RefMap) + free(sumsquare_RefMap); + if (RefMapsFFT) + delete[] RefMapsFFT; + maps = NULL; + sum_RefMap = NULL; + sumsquare_RefMap = NULL; + RefMapsFFT = NULL; + } + int readRefMaps(bioem_param ¶m, const char *filemap); + int precalculate(bioem_param ¶m, bioem &bio); + int PreCalculateMapsFFT(bioem_param ¶m); + + int read_int(int *currlong, FILE *fin, int swap); + int read_float(float *currfloat, FILE *fin, int swap); + int read_float_empty(FILE *fin); + int read_char_float(float *currfloat, FILE *fin); + int test_mrc(const char *vol_file, int swap); + int read_MRC(const char *filename, bioem_param ¶m); + + mycomplex_t *RefMapsFFT; + + bool readMRC, readMultMRC; + + int ntotRefMap; + int numPixels; + int refMapSize; + myfloat_t *maps; + myfloat_t *sum_RefMap; + myfloat_t *sumsquare_RefMap; + + __host__ __device__ inline myfloat_t get(int map, int x, int y) const + { + return (maps[map * refMapSize + x * numPixels + y]); + } + __host__ __device__ inline const myfloat_t *getp(int map, int x, int y) const + { + return (&maps[map * refMapSize + x * numPixels]); + } + __host__ __device__ inline myfloat_t *getmap(int map) + { + return (&maps[map * refMapSize]); + } }; class bioem_RefMap_Mod : public bioem_RefMap { public: - __host__ __device__ inline myfloat_t get(int map, int x, int y) const {return(maps[(x * numPixels + y) * ntotRefMap + map]);} - - void init(const bioem_RefMap& map) - { - maps = (myfloat_t*) malloc(map.refMapSize * map.ntotRefMap * sizeof(myfloat_t)); - #pragma omp parallel for - for (int i = 0; i < map.ntotRefMap; i++) - { - for (int j = 0; j < map.numPixels; j++) - { - for (int k = 0; k < map.numPixels; k++) - { - maps[(j * map.numPixels + k) * map.ntotRefMap + i] = map.get(i, j, k); - } - } - } - } + __host__ __device__ inline myfloat_t get(int map, int x, int y) const + { + return (maps[(x * numPixels + y) * ntotRefMap + map]); + } + + void init(const bioem_RefMap &map) + { + maps = (myfloat_t *) malloc(map.refMapSize * map.ntotRefMap * + sizeof(myfloat_t)); +#pragma omp parallel for + for (int i = 0; i < map.ntotRefMap; i++) + { + for (int j = 0; j < map.numPixels; j++) + { + for (int k = 0; k < map.numPixels; k++) + { + maps[(j * map.numPixels + k) * map.ntotRefMap + i] = map.get(i, j, k); + } + } + } + } }; class bioem_Probability_map { public: - myfloat_t Total; - myfloat_t Constoadd; - - class bioem_Probability_map_max - { - public: - int max_prob_cent_x, max_prob_cent_y, max_prob_orient, max_prob_conv; - myfloat_t max_prob_norm,max_prob_mu; - } max; + myprob_t Total; + myprob_t Constoadd; + + class bioem_Probability_map_max + { + public: + int max_prob_cent_x, max_prob_cent_y, max_prob_orient, max_prob_conv; + myfloat_t max_prob_norm, max_prob_mu; + } max; }; class bioem_Probability_angle { public: - myfloat_t forAngles; - myfloat_t ConstAngle; - myfloat_t priorang; -}; - -class bioem_Probability_cc -{ -public: - myfloat_t forCC; - myfloat_t ConstCC; + myprob_t forAngles; + myprob_t ConstAngle; }; class bioem_Probability { public: - int nMaps; - int nAngles; - int nCC; - - __device__ __host__ bioem_Probability_map& getProbMap(int map) {return(ptr_map[map]);} - __device__ __host__ bioem_Probability_angle& getProbAngle(int map, int angle) {return(ptr_angle[angle * nMaps + map]);} - __device__ __host__ bioem_Probability_cc& getProbCC(int map, int cc) {return(ptr_cc[cc * nMaps + map]);} - - void* ptr; - bioem_Probability_map* ptr_map; - bioem_Probability_angle* ptr_angle; - bioem_Probability_cc* ptr_cc; - - static size_t get_size(size_t maps, size_t angles, size_t cc, bool writeAngles, bool writeCC) - { - size_t size = sizeof(bioem_Probability_map); - if (writeAngles) size += angles * sizeof(bioem_Probability_angle); - if (writeCC) size += cc * sizeof(bioem_Probability_cc); - return(maps * size); - } - - void init(size_t maps, size_t angles, size_t cc, bioem& bio); - void copyFrom(bioem_Probability* from, bioem& bio); - - void set_pointers() - { - ptr_map = (bioem_Probability_map*) ptr; - ptr_angle = (bioem_Probability_angle*) (&ptr_map[nMaps]); -// ptr_cc = (bioem_Probability_cc*) (&ptr_angle[nMaps * nAngles]); - ptr_cc = (bioem_Probability_cc*) (&ptr_map[nMaps]); - } + int nMaps; + int nAngles; + + __device__ __host__ bioem_Probability_map &getProbMap(int map) + { + return (ptr_map[map]); + } + __device__ __host__ bioem_Probability_angle &getProbAngle(int map, int angle) + { + return (ptr_angle[angle * nMaps + map]); + } + + void *ptr; + bioem_Probability_map *ptr_map; + bioem_Probability_angle *ptr_angle; + + static size_t get_size(size_t maps, size_t angles, int writeAngles) + { + size_t size = sizeof(bioem_Probability_map); + if (writeAngles) + size += angles * sizeof(bioem_Probability_angle); + return (maps * size); + } + + void init(size_t maps, size_t angles, bioem &bio); + void copyFrom(bioem_Probability *from, bioem &bio); + + void set_pointers() + { + ptr_map = (bioem_Probability_map *) ptr; + ptr_angle = (bioem_Probability_angle *) (&ptr_map[nMaps]); + } }; #endif diff --git a/include/model.h b/include/model.h index fcfafa29a743f9b6af656aa8e2d5674eefc871a6..46736f9776fe01a64b6fafa46e55e97e52919140 100644 --- a/include/model.h +++ b/include/model.h @@ -1,12 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -16,32 +17,31 @@ #include "defs.h" #include "param.h" -#include class bioem_model { public: - class bioem_model_point - { - public: - myfloat3_t point; - myfloat_t radius; - myfloat_t density; - }; - - bioem_model(); - ~bioem_model(); - - int readModel(bioem_param& param, const char* filemodel); - - bool readPDB; - - myfloat_t getAminoAcidRad(char *name); - myfloat_t getAminoAcidDensity(char *name); - myfloat_t NormDen; - - int nPointsModel; - bioem_model_point* points; + class bioem_model_point + { + public: + myfloat3_t point; + myfloat_t radius; + myfloat_t density; + }; + + bioem_model(); + ~bioem_model(); + + int readModel(bioem_param ¶m, const char *filemodel); + + bool readPDB; + + myfloat_t getAminoAcidRad(char *name); + myfloat_t getAminoAcidDensity(char *name); + myfloat_t NormDen; + + int nPointsModel; + bioem_model_point *points; }; #endif diff --git a/include/param.h b/include/param.h index 8a952a56fdad73d81bfed65621cc503fb2a2b3cb..5faf1b63f968607e3c22d7087a3dd20b0d3768ac 100644 --- a/include/param.h +++ b/include/param.h @@ -1,12 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -17,145 +18,139 @@ #include "defs.h" #include "map.h" #include -#include #include +#include using namespace std; class bioem_param_device { public: -// Grids in center assuming equidistance from 0,0 - int maxDisplaceCenter; - int GridSpaceCenter; - int NumberPixels; - int NumberFFTPixels1D; - int NtotDist; - - myfloat_t Ntotpi; - myfloat_t volu; - myfloat_t sigmaPriorbctf; - myfloat_t sigmaPriordefo; - myfloat_t Priordefcent; - - -// If to write Probabilities of Angles from Model - bool writeAngles; - bool writeCC; - bool flipped; - bool debugterm; - int CCdisplace; - bool CCwithBayes; - bool tousepsf; - - + // Grids in center assuming equidistance from 0,0 + int maxDisplaceCenter; + int GridSpaceCenter; + int NumberPixels; + int NumberFFTPixels1D; + int NxDisp; + int NtotDisp; + + myfloat_t Ntotpi; + myfloat_t volu; + myfloat_t sigmaPriorbctf; + myfloat_t sigmaPriordefo; + myfloat_t Priordefcent; + myfloat_t sigmaPrioramp; + myfloat_t Priorampcent; + // If to write Probabilities of Angles from Model + int writeAngles; + bool tousepsf; }; class bioem_param { public: - bioem_param(); - ~bioem_param(); - - - int readParameters(const char* fileinput); - int CalculateGridsParam(const char* fileangles); - int CalculateRefCTF(); - int forprintBest(const char* fileinput); - void PrepareFFTs(); - bool doaaradius; - bool writeCTF; - bool ignoreCCoff; - bool nocentermass; - bool printrotmod; - bool readquatlist; - bool showrotatemod; - bool notsqure; - bool notnormmap; - bool usepsf; - bool ignorepointsout; - bool ignorePDB; - - myfloat_t elecwavel; - - bioem_param_device param_device; - - int FFTMapSize; - int Alignment; - mycomplex_t* refCTF; - myfloat3_t* CtfParam; - size_t getRefCtfCount() {return nTotCTFs * FFTMapSize;} - size_t getCtfParamCount() {return nTotCTFs;} - - myfloat_t pixelSize; -// Priors - myfloat_t priorMod; - bool yespriorAngles; - myfloat_t* angprior; - -// Grid Points in Euler angles, assuming uniform sampling d_alpha=d_gamma (in 2pi) & cos(beta)=-1,1 - int angleGridPointsAlpha; - int angleGridPointsBeta; - - int GridPointsQuatern; - bool doquater; - - myfloat_t voluang; - bool notuniformangles; - int NotUn_angles; - - bool withnoise; - myfloat_t stnoise; -// std::string inanglef; -// std::string quatfile; - - int numberGridPointsDisplaceCenter; -// Grid sampling for the convolution kernel - -// CTF - myfloat_t startBfactor, endBfactor; - int numberBfactor; - myfloat_t startDefocus, endDefocus; - int numberDefocus; - - //ENVELOPE - myfloat_t startGridEnvelop; - myfloat_t endGridEnvelop; - int numberGridPointsEnvelop; - myfloat_t gridEnvelop; - //CTF=Amp*cos(phase*x)-sqrt(1-Amp**2)*sin(phase*x) - myfloat_t startGridCTF_phase; - myfloat_t endGridCTF_phase; - int numberGridPointsCTF_phase; - myfloat_t gridCTF_phase; - myfloat_t startGridCTF_amp; - myfloat_t endGridCTF_amp; - int numberGridPointsCTF_amp; - myfloat_t gridCTF_amp; - // Others - myfloat3_t* angles; - int nTotGridAngles; - int nTotCTFs; - int nTotCC; - int shiftX,shiftY; - - bool printModel; - int printModelOrientation; - int printModelConvolution; - - int fft_plans_created; - myfftw_plan fft_plan_c2c_forward, fft_plan_c2c_backward, fft_plan_r2c_forward, fft_plan_c2r_backward; - - mycomplex_t** fft_scratch_complex; - myfloat_t** fft_scratch_real; - - bool dumpMap, loadMap; - - int ddx,ddy; - myfloat_t bestnorm,bestoff; + bioem_param(); + ~bioem_param(); + + int readParameters(const char *fileinput); + int CalculateGridsParam(const char *fileangles); + int CalculateRefCTF(); + int forprintBest(const char *fileinput); + void PrepareFFTs(); + bool doaaradius; + bool writeCTF; + bool nocentermass; + bool printrotmod; + bool readquatlist; + bool showrotatemod; + bool notnormmap; + bool usepsf; + bool ignorepointsout; + bool ignorePDB; + + myfloat_t elecwavel; + + bioem_param_device param_device; + + int FFTMapSize; + int Alignment; + mycomplex_t *refCTF; + myfloat3_t *CtfParam; + size_t getRefCtfCount() { return nTotCTFs * FFTMapSize; } + size_t getCtfParamCount() { return nTotCTFs; } + + myfloat_t pixelSize; + // Priors + myfloat_t priorMod; + bool yespriorAngles; + myfloat_t *angprior; + + // Grid Points in Euler angles, assuming uniform sampling d_alpha=d_gamma (in + // 2pi) & cos(beta)=-1,1 + int angleGridPointsAlpha; + int angleGridPointsBeta; + + int GridPointsQuatern; + bool doquater; + + myfloat_t voluang; + bool notuniformangles; + int NotUn_angles; + + bool withnoise; + myfloat_t stnoise; + // std::string inanglef; + // std::string quatfile; + + int numberGridPointsDisplaceCenter; + // Grid sampling for the convolution kernel + + // CTF + myfloat_t startBfactor, endBfactor; + int numberBfactor; + myfloat_t startDefocus, endDefocus; + int numberDefocus; + + // ENVELOPE + myfloat_t startGridEnvelop; + myfloat_t endGridEnvelop; + int numberGridPointsEnvelop; + myfloat_t gridEnvelop; + // CTF=Amp*cos(phase*x)-sqrt(1-Amp**2)*sin(phase*x) + myfloat_t startGridCTF_phase; + myfloat_t endGridCTF_phase; + int numberGridPointsCTF_phase; + myfloat_t gridCTF_phase; + myfloat_t startGridCTF_amp; + myfloat_t endGridCTF_amp; + int numberGridPointsCTF_amp; + myfloat_t gridCTF_amp; + // Others + myfloat3_t *angles; + int nTotGridAngles; + int nTotCTFs; + int shiftX, shiftY; + + int nTotParallelConv; + int nTotParallelMaps; + + bool printModel; + bool BestmapCalcCC; + + int fft_plans_created; + myfftw_plan fft_plan_c2c_forward, fft_plan_c2c_backward, fft_plan_r2c_forward, + fft_plan_c2r_backward; + + mycomplex_t **fft_scratch_complex; + myfloat_t **fft_scratch_real; + + bool dumpMap, loadMap; + + int ddx, ddy; + myfloat_t bestnorm, bestoff; private: - void releaseFFTPlans(); + void releaseFFTPlans(); }; #endif diff --git a/include/timer.h b/include/timer.h index 2875aad47f906cc066bdcd0d49d070097609e31c..06d5b2b6924f79362b1be242c0ae9b36588f6f52 100644 --- a/include/timer.h +++ b/include/timer.h @@ -1,9 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -11,68 +15,82 @@ #ifndef TIMER_H #define TIMER_H +#include +#include +#include #include #include -#include #include -#include -#include using namespace std; -class HighResTimer { +class HighResTimer +{ public: - HighResTimer(); - ~HighResTimer(); - void Start(); - void Stop(); - void Reset(); - void ResetStart(); - double GetElapsedTime(); - double GetCurrentElapsedTime(); + HighResTimer(); + ~HighResTimer(); + void Start(); + void Stop(); + void Reset(); + void ResetStart(); + double GetElapsedTime(); + double GetCurrentElapsedTime(); private: - static double Frequency; - static double GetFrequency(); + static double Frequency; + static double GetFrequency(); - double ElapsedTime; - double StartTime; - int running; + double ElapsedTime; + double StartTime; + int running; }; /* Structure for saving a vector of timings */ -typedef struct _TimeLog { - vector vec; - - double sum; - double stdev; - - string name; -}TimeLog; -enum TS_NAMES{TS_TPROJECTION, TS_PROJECTION, TS_CONVOLUTION, TS_COMPARISON}; +typedef struct _TimeLog +{ + vector vec; + + double sum; + double stdev; + + string name; +} TimeLog; +enum TS_NAMES +{ + TS_TPROJECTION, + TS_PROJECTION, + TS_CONVOLUTION, + TS_COMPARISON +}; -/* Structure for saving timings of different parts of code and doing basic statistics on them */ -class TimeStat { +/* Structure for saving timings of different parts of code and doing basic + * statistics on them */ +class TimeStat +{ public: - TimeStat(int Angles, int CTFs) : time(0),tl(NULL) {angles = Angles; ctfs = CTFs;}; - ~TimeStat() {EmptyTimeStat();}; - void InitTimeLog(int log, int size, string s); - void InitTimeStat(int nlogs); - void EmptyTimeStat(); - void inline Add(int log) {tl[log].vec.push_back(time);}; - void ComputeTimeStat(); - void PrintTimeStat(int mpi_rank); - - /* Variable for storing times during the execution */ - double time; + TimeStat(int Angles, int CTFs) : time(0), tl(NULL) + { + angles = Angles; + ctfs = CTFs; + }; + ~TimeStat() { EmptyTimeStat(); }; + void InitTimeLog(int log, int size, string s); + void InitTimeStat(int nlogs); + void EmptyTimeStat(); + void inline Add(int log) { tl[log].vec.push_back(time); }; + void ComputeTimeStat(); + void PrintTimeStat(int mpi_rank); + + /* Variable for storing times during the execution */ + double time; private: - TimeLog* tl; - int total_logs; - int angles; - int ctfs; + TimeLog *tl; + int total_logs; + int angles; + int ctfs; }; #endif diff --git a/main.cpp b/main.cpp index 565be80f4018de3c9b288445a8f8a3c9f31b8a6f..6929a95a31bc46bee5ab49bd16310860933e4bd3 100644 --- a/main.cpp +++ b/main.cpp @@ -1,13 +1,13 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. - + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ @@ -15,27 +15,28 @@ #ifdef WITH_MPI #include -#define MPI_CHK(expr) \ - if (expr != MPI_SUCCESS) \ - { \ - fprintf(stderr, "Error in MPI function %s: %d\n", __FILE__, __LINE__); \ - } +#define MPI_CHK(expr) \ + if (expr != MPI_SUCCESS) \ + { \ + fprintf(stderr, "Error in MPI function %s: %d\n", __FILE__, __LINE__); \ + } #endif +#include #include #include #include #include -#include #ifdef _WIN32 -#include #include +#include #endif -#include #include +#include #include + #include "bioem.h" #include "bioem_cuda.h" @@ -53,58 +54,82 @@ int mpi_size = 1; #include "timer.h" -int main(int argc, char* argv[]) +int main(int argc, char *argv[]) { - // ************************************************************************************** - // ********************************* Main BioEM code ********************************** - // ************************************************************************************ +// ************************************************************************************** +// ********************************* Main BioEM code +// ********************************** +// ************************************************************************************ #ifdef WITH_MPI - MPI_CHK(MPI_Init(&argc, &argv)); - MPI_CHK(MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank)); - MPI_CHK(MPI_Comm_size(MPI_COMM_WORLD, &mpi_size)); + MPI_CHK(MPI_Init(&argc, &argv)); + MPI_CHK(MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank)); + MPI_CHK(MPI_Comm_size(MPI_COMM_WORLD, &mpi_size)); #endif #ifdef _MM_DENORMALS_ZERO_ON - #pragma omp parallel - { - _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON); //Flush denormals to zero in all OpenMP threads - } +#pragma omp parallel + { + _MM_SET_DENORMALS_ZERO_MODE( + _MM_DENORMALS_ZERO_ON); // Flush denormals to zero in all OpenMP threads + } #endif - HighResTimer timer; + HighResTimer timer; - bioem* bio; + bioem *bio; #ifdef WITH_CUDA - if (getenv("GPU") && atoi(getenv("GPU"))) - { - bio = bioem_cuda_create(); - } - else + if (getenv("GPU") && atoi(getenv("GPU"))) + { + bio = bioem_cuda_create(); + } + else #endif - { - bio = new bioem; - } - - // ************ Configuration and Pre-calculating necessary objects ***************** -// if (mpi_rank == 0) printf("Configuring\n"); - if (bio->configure(argc, argv) == 0) - { - - // ******************************* Run BioEM routine ****************************** - if (mpi_rank == 0) printf("Running\n"); - timer.Start(); - bio->run(); - timer.Stop(); - - // ************************************ End ********************************** - printf ("The code ran for %f seconds (rank %d).\n", timer.GetElapsedTime(), mpi_rank); - bio->cleanup(); - } - delete bio; + { + bio = new bioem; + } + + // ************ Configuration and Pre-calculating necessary objects + // ***************** + if (mpi_rank == 0) + printf("Configuring\n"); + if (bio->configure(argc, argv) == 0) + { + if (bio->needToPrintModel()) + { + if (mpi_size == 1) + { + bio->printModel(); + } + else + { + printf("ERROR: Model printing can be performed only if using a single " + "MPI process. Please change your execution to use a single MPI " + "process or no MPI at all.\n"); + exit(1); + } + } + else + { + // ******************************* Run BioEM routine + // ****************************** + if (mpi_rank == 0) + printf("Running\n"); + timer.Start(); + bio->run(); + timer.Stop(); + + // ************************************ End + // ********************************** + printf("The code ran for %f seconds (rank %d).\n", timer.GetElapsedTime(), + mpi_rank); + bio->cleanup(); + } + } + delete bio; #ifdef WITH_MPI - MPI_Finalize(); + MPI_Finalize(); #endif - return(0); + return (0); } diff --git a/map.cpp b/map.cpp index dbdd7c0043a7b5e891958f4a816af27654390c32..6d155251ee4e067e2436221f737afe1b498c70d5 100644 --- a/map.cpp +++ b/map.cpp @@ -1,399 +1,424 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. - Note: This program contains subroutine "read_MRC" of the Situs 2.7.2 program. - Ref: Willy Wriggers. Using Situs for the Integration of Multi-Resolution Structures. + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + Note: This program contains subroutine "read_MRC" of the Situs 2.7.2 program. + Ref: Willy Wriggers. Using Situs for the Integration of Multi-Resolution + Structures. Biophysical Reviews, 2010, Vol. 2, pp. 21-27. with a GPL lisences version 3. - ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +#include +#include #include #include +#include #include #include -#include -#include -#include #ifdef WITH_OPENMP #include #endif +#include "bioem.h" #include "map.h" #include "param.h" -#include "bioem.h" using namespace std; -int bioem_RefMap::readRefMaps(bioem_param& param, const char* filemap) +int bioem_RefMap::readRefMaps(bioem_param ¶m, const char *filemap) { numPixels = param.param_device.NumberPixels; - refMapSize = param.param_device.NumberPixels * param.param_device.NumberPixels; + refMapSize = + param.param_device.NumberPixels * param.param_device.NumberPixels; // ************************************************************************************** - // ***********************Reading reference Particle Maps************************ + // ***********************Reading reference Particle + // Maps************************ // ************************************************************************************** int allocsize = 0; if (param.loadMap) + { + //************** Loading Map from Binary file ******* + FILE *fp = fopen("maps.dump", "rb"); + if (fp == NULL) { - //************** Loading Map from Binary file ******* - FILE* fp = fopen("maps.dump", "rb"); - if (fp == NULL) - { - cout << "Error opening dump file\n"; - exit(1); - } - size_t elements_read; - elements_read = fread(&ntotRefMap, sizeof(ntotRefMap), 1, fp); - if (elements_read != 1) - { - cout << "Error reading file\n"; - exit(1); - } - maps = (myfloat_t*) mallocchk(ntotRefMap * refMapSize * sizeof(myfloat_t)); - elements_read = fread(maps, sizeof(myfloat_t) * refMapSize, ntotRefMap, fp); - if (elements_read != (size_t) ntotRefMap) - { - cout << "Error reading file\n"; - exit(1); - } - - fclose(fp); - - cout << "Particle Maps read from Map Dump\n"; + cout << "Error opening dump file\n"; + exit(1); + } + size_t elements_read; + elements_read = fread(&ntotRefMap, sizeof(ntotRefMap), 1, fp); + if (elements_read != 1) + { + cout << "Error reading file\n"; + exit(1); } - else if(readMRC) + maps = (myfloat_t *) mallocchk(ntotRefMap * refMapSize * sizeof(myfloat_t)); + elements_read = fread(maps, sizeof(myfloat_t) * refMapSize, ntotRefMap, fp); + if (elements_read != (size_t) ntotRefMap) { - //************** Reading MRC file ******* - ntotRefMap=0; + cout << "Error reading file\n"; + exit(1); + } - if(readMultMRC) - { + fclose(fp); - //************** Reading Multiple MRC files ************* - cout << "Opening File with MRC list names: " << filemap << "\n"; - ifstream input(filemap); + cout << "Particle Maps read from Map Dump\n"; + } + else if (readMRC) + { + //************** Reading MRC file ******* + ntotRefMap = 0; - if (!input.good()) - { - cout << "Failed to open file contaning MRC names: " << filemap << "\n"; - exit(1); - } + if (readMultMRC) + { - char line[512] = {0}; - char mapname[100]; - char tmpm[10] = {0}; - const char* indifile; + //************** Reading Multiple MRC files ************* + cout << "Opening File with MRC list names: " << filemap << "\n"; + ifstream input(filemap); - while (!input.eof()) - { - input.getline(line,511); - char tmpVals[100] = {0}; + if (!input.good()) + { + cout << "Failed to open file contaning MRC names: " << filemap << "\n"; + exit(1); + } - string strline(line); + char line[512] = {0}; + char mapname[100]; + char tmpm[10] = {0}; + const char *indifile; - // cout << "MRC File name:" << strline << "\n"; + while (!input.eof()) + { + input.getline(line, 511); + char tmpVals[100] = {0}; + string strline(line); - strncpy (tmpVals,line,99); - sscanf (tmpVals,"%99c",mapname); + // cout << "MRC File name:" << strline << "\n"; - // Check for last line - strncpy (tmpm,mapname,3); + strncpy(tmpVals, line, 99); + sscanf(tmpVals, "%99c", mapname); - if(strcmp(tmpm,"XXX")!=0) - { - indifile=strline.c_str(); - - // size_t foundpos= strline.find("mrc"); - // size_t endpos = strline.find_last_not_of(" \t"); - + // Check for last line + strncpy(tmpm, mapname, 3); - //Reading Multiple MRC - read_MRC(indifile,param); - } - for(int i=0;i<3;i++)mapname[i] = 'X'; - for(int i=3;i<100;i++)mapname[i] = 0; + if (strcmp(tmpm, "XXX") != 0) + { + indifile = strline.c_str(); - } - cout << "\n+++++++++++++++++++++++++++++++++++++++++++ \n"; - cout << "Particle Maps read from MULTIPLE MRC Files in: " << filemap << "\n" ; - } - else - { + // size_t foundpos= strline.find("mrc"); + // size_t endpos = strline.find_last_not_of(" \t"); - string strfilename(filemap); + // Reading Multiple MRC + read_MRC(indifile, param); + } + for (int i = 0; i < 3; i++) + mapname[i] = 'X'; + for (int i = 3; i < 100; i++) + mapname[i] = 0; + } + cout << "\n+++++++++++++++++++++++++++++++++++++++++++ \n"; + cout << "Particle Maps read from MULTIPLE MRC Files in: " << filemap + << "\n"; + } + else + { - size_t foundpos= strfilename.find("mrc"); - size_t endpos = strfilename.find_last_not_of(" \t"); + string strfilename(filemap); - if(foundpos > endpos){ - cout << "Warining:::: mrc extension NOT dectected in file name::" << filemap <<" \n"; - cout << "Warining:::: Are you sure you want to read an MRC? \n"; - } + size_t foundpos = strfilename.find("mrc"); + size_t endpos = strfilename.find_last_not_of(" \t"); - read_MRC(filemap,param); - cout << "\n++++++++++++++++++++++++++++++++++++++++++ \n"; - cout << "Particle Maps read from ONE MRC File: " << filemap << "\n" ; - } + if (foundpos > endpos) + { + cout << "Warining:::: mrc extension NOT dectected in file name::" + << filemap << " \n"; + cout << "Warining:::: Are you sure you want to read an MRC? \n"; + } + + read_MRC(filemap, param); + cout << "\n++++++++++++++++++++++++++++++++++++++++++ \n"; + cout << "Particle Maps read from ONE MRC File: " << filemap << "\n"; } + } else + { + //************** Reading Text file ************* + int nummap = -1; + int lasti = 0; + int lastj = 0; + ifstream input(filemap); + if (!input.good()) { - //************** Reading Text file ************* - int nummap = -1; - int lasti = 0; - int lastj = 0; - ifstream input(filemap); - if (!input.good()) - { - cout << "Particle Maps Failed to open file" << endl ; - exit(1); - } + cout << "Particle Maps Failed to open file" << endl; + exit(1); + } - char line[512] = {0}; - char tmpLine[512] = {0}; - bool first=true; + char line[512] = {0}; + char tmpLine[512] = {0}; + bool first = true; - int countpix=0; + int countpix = 0; - while (!input.eof()) - { - input.getline(line, 511); - - strncpy(tmpLine, line, strlen(line)); - char *token = strtok(tmpLine, " "); - - if(first){ - if (strcmp(token, "PARTICLE") != 0) { - cout << "Missing correct Standard Map Format: PARTICLE HEADER\n"<< endl ; - exit(1); - } - first=false; - } - - - if (strcmp(token, "PARTICLE") == 0) // to count the number of maps - { - nummap++; - countpix=0; - if (allocsize == 0) - { - allocsize = 64; - maps = (myfloat_t*) mallocchk(refMapSize * sizeof(myfloat_t) * allocsize); - } - else if (nummap + 1 >= allocsize) - { - allocsize *= 2; - maps = (myfloat_t*) reallocchk(maps, refMapSize * sizeof(myfloat_t) * allocsize); - } - if (nummap % 128 == 0) - { - cout << "..." << nummap << "\n"; - } - if(lasti+1 != param.param_device.NumberPixels && lastj+1 != param.param_device.NumberPixels && nummap > 0) - { - cout << "PROBLEM INCONSISTENT NUMBER OF PIXELS IN MAPS AND INPUTFILE ( " << param.param_device.NumberPixels << ", i " << lasti << ", j " << lastj << ")" << "\n"; - exit(1); - } - } - else - { - int i, j; - float z; - - char tmpVals[36] = {0}; - - strncpy (tmpVals, line, 8); - sscanf (tmpVals, "%d", &i); - - strncpy (tmpVals, line + 8, 8); - sscanf (tmpVals, "%d", &j); - - strncpy (tmpVals, line + 16, 16); - sscanf (tmpVals, "%f", &z); - //checking for Map limits - if(i > -1 && i < param.param_device.NumberPixels && j > -1 && j < param.param_device.NumberPixels) - { - countpix++; - maps[nummap * refMapSize + i * numPixels + j] = (myfloat_t) z; - lasti = i; - lastj = j; - // cout << countpix << " " << param.param_device.NumberPixels*param.param_device.NumberPixels << "\n"; - } - else - { - cout << "PROBLEM READING MAP (Map number " << nummap << ", i " << i << ", j " << j << ")" << "\n"; - exit(1); - } - } - } - if(lasti != param.param_device.NumberPixels-1 || lastj != param.param_device.NumberPixels-1 || countpix != param.param_device.NumberPixels*param.param_device.NumberPixels +1 ) - { - cout << "PROBLEM INCONSISTENT NUMBER OF PIXELS IN MAPS AND INPUTFILE ( " << param.param_device.NumberPixels << ", i " << lasti << ", j " << lastj << ")" << "\n"; - exit(1); - } - cout << "."; - ntotRefMap = nummap + 1; - maps = (myfloat_t*) reallocchk(maps, refMapSize * sizeof(myfloat_t) * ntotRefMap); - cout << "Particle Maps read from Standard File: " << ntotRefMap << "\n"; + while (!input.eof()) + { + input.getline(line, 511); + + strncpy(tmpLine, line, strlen(line)); + char *token = strtok(tmpLine, " "); + + if (first) + { + if (strcmp(token, "PARTICLE") != 0) + { + cout << "Missing correct Standard Map Format: PARTICLE HEADER\n" + << endl; + exit(1); + } + first = false; + } + + if (strcmp(token, "PARTICLE") == 0) // to count the number of maps + { + nummap++; + countpix = 0; + if (allocsize == 0) + { + allocsize = 64; + maps = (myfloat_t *) mallocchk(refMapSize * sizeof(myfloat_t) * + allocsize); + } + else if (nummap + 1 >= allocsize) + { + allocsize *= 2; + maps = (myfloat_t *) reallocchk(maps, refMapSize * sizeof(myfloat_t) * + allocsize); + } + if (nummap % 128 == 0) + { + cout << "..." << nummap << "\n"; + } + if (lasti + 1 != param.param_device.NumberPixels && + lastj + 1 != param.param_device.NumberPixels && nummap > 0) + { + cout << "PROBLEM INCONSISTENT NUMBER OF PIXELS IN MAPS AND INPUTFILE " + "( " + << param.param_device.NumberPixels << ", i " << lasti << ", j " + << lastj << ")" + << "\n"; + exit(1); + } + } + else + { + int i, j; + float z; + + char tmpVals[36] = {0}; + + strncpy(tmpVals, line, 8); + sscanf(tmpVals, "%d", &i); + + strncpy(tmpVals, line + 8, 8); + sscanf(tmpVals, "%d", &j); + + strncpy(tmpVals, line + 16, 16); + sscanf(tmpVals, "%f", &z); + // checking for Map limits + if (i > -1 && i < param.param_device.NumberPixels && j > -1 && + j < param.param_device.NumberPixels) + { + countpix++; + maps[nummap * refMapSize + i * numPixels + j] = (myfloat_t) z; + lasti = i; + lastj = j; + // cout << countpix << " " << + // param.param_device.NumberPixels*param.param_device.NumberPixels << + //"\n"; + } + else + { + cout << "PROBLEM READING MAP (Map number " << nummap << ", i " << i + << ", j " << j << ")" + << "\n"; + exit(1); + } + } } + if (lasti != param.param_device.NumberPixels - 1 || + lastj != param.param_device.NumberPixels - 1 || + countpix != + param.param_device.NumberPixels * param.param_device.NumberPixels + + 1) + { + cout << "PROBLEM INCONSISTENT NUMBER OF PIXELS IN MAPS AND INPUTFILE ( " + << param.param_device.NumberPixels << ", i " << lasti << ", j " + << lastj << ")" + << "\n"; + exit(1); + } + cout << "."; + ntotRefMap = nummap + 1; + maps = (myfloat_t *) reallocchk(maps, refMapSize * sizeof(myfloat_t) * + ntotRefMap); + cout << "Particle Maps read from Standard File: " << ntotRefMap << "\n"; + } //************* If Dumping Maps ********************* if (param.dumpMap) + { + FILE *fp = fopen("maps.dump", "w+b"); + if (fp == NULL) { - FILE* fp = fopen("maps.dump", "w+b"); - if (fp == NULL) - { - cout << "Error opening dump file\n"; - exit(1); - } - fwrite(&ntotRefMap, sizeof(ntotRefMap), 1, fp); - fwrite(maps, sizeof(myfloat_t) * refMapSize, ntotRefMap, fp); - fclose(fp); + cout << "Error opening dump file\n"; + exit(1); } + fwrite(&ntotRefMap, sizeof(ntotRefMap), 1, fp); + fwrite(maps, sizeof(myfloat_t) * refMapSize, ntotRefMap, fp); + fclose(fp); + } //*********** To Debug with few Maps ******************** if (getenv("BIOEM_DEBUG_NMAPS")) - { - ntotRefMap = atoi(getenv("BIOEM_DEBUG_NMAPS")); - } + { + ntotRefMap = atoi(getenv("BIOEM_DEBUG_NMAPS")); + } + param.nTotParallelMaps = min(CUDA_FFTS_AT_ONCE, ntotRefMap); cout << "Total Number of particles: " << ntotRefMap; cout << "\n+++++++++++++++++++++++++++++++++++++++++++ \n"; - return(0); + return (0); } -int bioem_RefMap::PreCalculateMapsFFT(bioem_param& param) +int bioem_RefMap::PreCalculateMapsFFT(bioem_param ¶m) { // ************************************************************************************** - // ********** Routine that pre-calculates Reference maps FFT for Convolution/ Comparison ********************** + // ********** Routine that pre-calculates Reference maps FFT for Convolution/ + // Comparison ********************** // ************************************************************************************ RefMapsFFT = new mycomplex_t[ntotRefMap * param.FFTMapSize]; #pragma omp parallel for - for (int iRefMap = 0; iRefMap < ntotRefMap ; iRefMap++) + for (int iRefMap = 0; iRefMap < ntotRefMap; iRefMap++) + { + const int num = omp_get_thread_num(); + myfloat_t *localMap = param.fft_scratch_real[num]; + mycomplex_t *localout = param.fft_scratch_complex[num]; + + // Assigning localMap values to padded Map + for (int i = 0; i < param.param_device.NumberPixels; i++) { - const int num = omp_get_thread_num(); - myfloat_t* localMap = param.fft_scratch_real[num]; - mycomplex_t* localout = param.fft_scratch_complex[num]; - - //Assigning localMap values to padded Map - for(int i = 0; i < param.param_device.NumberPixels; i++) - { - for(int j = 0; j < param.param_device.NumberPixels; j++) - { - localMap[i * param.param_device.NumberPixels + j] = maps[iRefMap * refMapSize + i * param.param_device.NumberPixels + j]; - } - } - - //Calling FFT_Forward - myfftw_execute_dft_r2c(param.fft_plan_r2c_forward, localMap, localout); - - //Saving the Reference CTFs (RefMap array possibly has incorrect alignment, so we copy here. Stupid but in fact does not matter.) - mycomplex_t* RefMap = &RefMapsFFT[iRefMap * param.FFTMapSize]; - - for(int i = 0; i < param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D ; i++ ) - { - RefMap[i][0] = localout[i][0]; - RefMap[i][1] = localout[i][1]; - } + for (int j = 0; j < param.param_device.NumberPixels; j++) + { + localMap[i * param.param_device.NumberPixels + j] = + maps[iRefMap * refMapSize + i * param.param_device.NumberPixels + + j]; + } } - return(0); + // Calling FFT_Forward + myfftw_execute_dft_r2c(param.fft_plan_r2c_forward, localMap, localout); + + // Saving the Reference CTFs (RefMap array possibly has incorrect alignment, + // so we copy here. Stupid but in fact does not matter.) + mycomplex_t *RefMap = &RefMapsFFT[iRefMap * param.FFTMapSize]; + + for (int i = 0; i < param.param_device.NumberPixels * + param.param_device.NumberFFTPixels1D; + i++) + { + RefMap[i][0] = localout[i][0]; + RefMap[i][1] = localout[i][1]; + } + } + + return (0); } -int bioem_RefMap::precalculate(bioem_param& param, bioem& bio) +int bioem_RefMap::precalculate(bioem_param ¶m, bioem &bio) { // ************************************************************************************** - // *******************************Precalculating Routine for Maps************************ + // *******************************Precalculating Routine for + // Maps************************ // ************************************************************************************** - sum_RefMap = (myfloat_t*) mallocchk(sizeof(myfloat_t) * ntotRefMap); - sumsquare_RefMap = (myfloat_t*) mallocchk(sizeof(myfloat_t) * ntotRefMap); + sum_RefMap = (myfloat_t *) mallocchk(sizeof(myfloat_t) * ntotRefMap); + sumsquare_RefMap = (myfloat_t *) mallocchk(sizeof(myfloat_t) * ntotRefMap); - //Precalculating cross-correlations of maps +// Precalculating cross-correlations of maps #pragma omp parallel for - for (int iRefMap = 0; iRefMap < ntotRefMap ; iRefMap++) - { - myfloat_t sum, sumsquare; - bio.calcross_cor(getmap(iRefMap), sum, sumsquare); - //Storing Crosscorrelations in Map class - sum_RefMap[iRefMap] = sum; - sumsquare_RefMap[iRefMap] = sumsquare; - } + for (int iRefMap = 0; iRefMap < ntotRefMap; iRefMap++) + { + myfloat_t sum, sumsquare; + bio.calcross_cor(getmap(iRefMap), sum, sumsquare); + // Storing Crosscorrelations in Map class + sum_RefMap[iRefMap] = sum; + sumsquare_RefMap[iRefMap] = sumsquare; + } // Precalculating Maps in Fourier space - if (bio.FFTAlgo) - { - PreCalculateMapsFFT(param); - free(maps); - maps = NULL; - } + PreCalculateMapsFFT(param); + free(maps); + maps = NULL; - return(0); + return (0); } -void bioem_Probability::init(size_t maps, size_t angles, size_t cc, bioem& bio) +void bioem_Probability::init(size_t maps, size_t angles, bioem &bio) { //********** Initializing pointers ******************* nMaps = maps; nAngles = angles; - nCC = cc; - ptr = bio.malloc_device_host(get_size(maps, angles, cc, bio.param.param_device.writeAngles, bio.param.param_device.writeCC)); - if (bio.DebugOutput >= 1) cout << "Allocation #Maps " << maps << " #Angles " << angles << " #cross.cor " << cc << "\n"; - //<< " == " << get_size(maps, angles, cc, bio.param.param_device.writeAngles, bio.param.param_device.writeCC)<< "\n"; + ptr = bio.malloc_device_host( + get_size(maps, angles, bio.param.param_device.writeAngles)); + if (bio.DebugOutput >= 1) + cout << "Allocation #Maps " << maps << " #Angles " << angles << "\n"; set_pointers(); } -void bioem_Probability::copyFrom(bioem_Probability* from, bioem& bio) +void bioem_Probability::copyFrom(bioem_Probability *from, bioem &bio) { - bioem_Probability_map& pProbMap = getProbMap(0); - bioem_Probability_map& pProbMapFrom = from->getProbMap(0); + bioem_Probability_map &pProbMap = getProbMap(0); + bioem_Probability_map &pProbMapFrom = from->getProbMap(0); memcpy(&pProbMap, &pProbMapFrom, from->nMaps * sizeof(bioem_Probability_map)); if (bio.param.param_device.writeAngles) + { + for (int iOrient = 0; iOrient < nAngles; iOrient++) { - for (int iOrient = 0; iOrient < nAngles; iOrient ++) - { - bioem_Probability_angle& pProbAngle = getProbAngle(0, iOrient); - bioem_Probability_angle& pProbAngleFrom = from->getProbAngle(0, iOrient); - memcpy(&pProbAngle, &pProbAngleFrom, from->nMaps * sizeof(bioem_Probability_angle)); - } - } - - if (bio.param.param_device.writeCC) - { - for (int iCC = 0; iCC < nCC; iCC ++) - { - bioem_Probability_cc& pProbCC = getProbCC(0, iCC); - bioem_Probability_cc& pProbCCFrom = from->getProbCC(0, iCC); - memcpy(&pProbCC, &pProbCCFrom, from->nMaps * sizeof(bioem_Probability_cc)); - } + bioem_Probability_angle &pProbAngle = getProbAngle(0, iOrient); + bioem_Probability_angle &pProbAngleFrom = from->getProbAngle(0, iOrient); + memcpy(&pProbAngle, &pProbAngleFrom, + from->nMaps * sizeof(bioem_Probability_angle)); } + } } -int bioem_RefMap::read_MRC(const char* filename,bioem_param& param) +int bioem_RefMap::read_MRC(const char *filename, bioem_param ¶m) { - /* subroutine "read_MRC" of the Situs 2.7.2 program. - Ref: Willy Wriggers. Using Situs for the Integration of Multi-Resolution Structures. - Biophysical Reviews, 2010, Vol. 2, pp. 21-27.*/ - + /* subroutine "read_MRC" of the Situs 2.7.2 program. + Ref: Willy Wriggers. Using Situs for the Integration of + Multi-Resolution Structures. + Biophysical Reviews, 2010, Vol. 2, pp. 21-27.*/ - myfloat_t st,st2; + myfloat_t st, st2; unsigned long count; FILE *fin; float currfloat; @@ -401,66 +426,78 @@ int bioem_RefMap::read_MRC(const char* filename,bioem_param& param) float xlen, ylen, zlen; int mode, ncstart, nrstart, nsstart, ispg, nsymbt, lskflg; float a_tmp, b_tmp, g_tmp; - int mx, my, mz,mapc, mapr, maps_local; + int mx, my, mz, mapc, mapr, maps_local; float dmin, dmax, dmean; int n_range_viol0, n_range_viol1; fin = fopen(filename, "rb"); - if( fin == NULL ) { + if (fin == NULL) + { cout << "ERROR opening MRC: " << filename; exit(1); } - n_range_viol0 = test_mrc(filename,0); - n_range_viol1 = test_mrc(filename,1); + n_range_viol0 = test_mrc(filename, 0); + n_range_viol1 = test_mrc(filename, 1); - if (n_range_viol0 < n_range_viol1) { //* guess endianism + if (n_range_viol0 < n_range_viol1) + { //* guess endianism swap = 0; - if (n_range_viol0 > 0) { - printf(" Warning: %i header field range violations detected in file %s \n", n_range_viol0,filename); + if (n_range_viol0 > 0) + { + printf( + " Warning: %i header field range violations detected in file %s \n", + n_range_viol0, filename); } - } else { + } + else + { swap = 1; - if (n_range_viol1 > 0) { - printf("Warning: %i header field range violations detected in file %s \n", n_range_viol1,filename); + if (n_range_viol1 > 0) + { + printf("Warning: %i header field range violations detected in file %s \n", + n_range_viol1, filename); } } printf("\n+++++++++++++++++++++++++++++++++++++++++++\n"); printf("Reading Information from MRC: %s \n", filename); - header_ok *= read_int(&nc,fin,swap); - header_ok *= read_int(&nr,fin,swap); - header_ok *= read_int(&ns,fin,swap); - header_ok *= read_int(&mode,fin,swap); - header_ok *= read_int(&ncstart,fin,swap); - header_ok *= read_int(&nrstart,fin,swap); - header_ok *= read_int(&nsstart,fin,swap); - header_ok *= read_int(&mx,fin,swap); - header_ok *= read_int(&my,fin,swap); - header_ok *= read_int(&mz,fin,swap); - header_ok *= read_float(&xlen,fin,swap); - header_ok *= read_float(&ylen,fin,swap); - header_ok *= read_float(&zlen,fin,swap); - header_ok *= read_float(&a_tmp,fin,swap); - header_ok *= read_float(&b_tmp,fin,swap); - header_ok *= read_float(&g_tmp,fin,swap); - header_ok *= read_int(&mapc,fin,swap); - header_ok *= read_int(&mapr,fin,swap); - header_ok *= read_int(&maps_local,fin,swap); - header_ok *= read_float(&dmin,fin,swap); - header_ok *= read_float(&dmax,fin,swap); - header_ok *= read_float(&dmean,fin,swap); - header_ok *= read_int(&ispg,fin,swap); - header_ok *= read_int(&nsymbt,fin,swap); - header_ok *= read_int(&lskflg,fin,swap); - - printf("Number Columns = %8d \n",nc); - printf("Number Rows = %8d \n",nr); - printf("Number Sections = %8d \n",ns); - printf("MODE = %4d (only data type mode 2: 32-bit)\n",mode); - printf("NSYMBT = %4d (# bytes symmetry operators)\n",nsymbt); - - /* printf(" NCSTART = %8d (index of first column, counting from 0)\n",ncstart); - printf("> NRSTART = %8d (index of first row, counting from 0)\n",nrstart); - printf(" NSSTART = %8d (index of first section, counting from 0)\n",nsstart); + header_ok *= read_int(&nc, fin, swap); + header_ok *= read_int(&nr, fin, swap); + header_ok *= read_int(&ns, fin, swap); + header_ok *= read_int(&mode, fin, swap); + header_ok *= read_int(&ncstart, fin, swap); + header_ok *= read_int(&nrstart, fin, swap); + header_ok *= read_int(&nsstart, fin, swap); + header_ok *= read_int(&mx, fin, swap); + header_ok *= read_int(&my, fin, swap); + header_ok *= read_int(&mz, fin, swap); + header_ok *= read_float(&xlen, fin, swap); + header_ok *= read_float(&ylen, fin, swap); + header_ok *= read_float(&zlen, fin, swap); + header_ok *= read_float(&a_tmp, fin, swap); + header_ok *= read_float(&b_tmp, fin, swap); + header_ok *= read_float(&g_tmp, fin, swap); + header_ok *= read_int(&mapc, fin, swap); + header_ok *= read_int(&mapr, fin, swap); + header_ok *= read_int(&maps_local, fin, swap); + header_ok *= read_float(&dmin, fin, swap); + header_ok *= read_float(&dmax, fin, swap); + header_ok *= read_float(&dmean, fin, swap); + header_ok *= read_int(&ispg, fin, swap); + header_ok *= read_int(&nsymbt, fin, swap); + header_ok *= read_int(&lskflg, fin, swap); + + printf("Number Columns = %8d \n", nc); + printf("Number Rows = %8d \n", nr); + printf("Number Sections = %8d \n", ns); + printf("MODE = %4d (only data type mode 2: 32-bit)\n", mode); + printf("NSYMBT = %4d (# bytes symmetry operators)\n", nsymbt); + + /* printf(" NCSTART = %8d (index of first column, counting from + 0)\n",ncstart); + printf("> NRSTART = %8d (index of first row, counting from + 0)\n",nrstart); + printf(" NSSTART = %8d (index of first section, counting from + 0)\n",nsstart); printf(" MX = %8d (# of X intervals in unit cell)\n",mx); printf(" MY = %8d (# of Y intervals in unit cell)\n",my); printf(" MZ = %8d (# of Z intervals in unit cell)\n",mz); @@ -478,136 +515,162 @@ int bioem_RefMap::read_MRC(const char* filename,bioem_param& param) printf(" DMEAN = %8.3f (mean density value - ignored)\n",dmean); printf(" ISPG = %8d (space group number - ignored)\n",ispg); printf(" NSYMBT = %8d (# bytes storing symmetry operators)\n",nsymbt); - printf(" LSKFLG = %8d (skew matrix flag: 0:none, 1:follows)\n",lskflg);*/ + printf(" LSKFLG = %8d (skew matrix flag: 0:none, + 1:follows)\n",lskflg);*/ - if (header_ok == 0) { + if (header_ok == 0) + { cout << "ERROR reading MRC header: " << filename; exit(1); } - if(nr!=param.param_device.NumberPixels || nc!=param.param_device.NumberPixels ) - { - cout << "PROBLEM INCONSISTENT NUMBER OF PIXELS IN MAPS AND INPUTFILE ( " << param.param_device.NumberPixels << ", i " << nc << ", j " << nr << ")" << "\n"; - if(!param.notsqure) exit(1); - } + if (nr != param.param_device.NumberPixels || + nc != param.param_device.NumberPixels) + { + cout << "PROBLEM INCONSISTENT NUMBER OF PIXELS IN MAPS AND INPUTFILE ( " + << param.param_device.NumberPixels << ", i " << nc << ", j " << nr + << ")" + << "\n"; + exit(1); + } if (ntotRefMap == 0) - { - maps = (myfloat_t*) mallocchk(refMapSize * sizeof(myfloat_t) * ns); - } + { + maps = (myfloat_t *) mallocchk(refMapSize * sizeof(myfloat_t) * ns); + } else - { - maps = (myfloat_t*) reallocchk(maps, refMapSize * sizeof(myfloat_t) * (ntotRefMap + ns)); - } + { + maps = (myfloat_t *) reallocchk(maps, refMapSize * sizeof(myfloat_t) * + (ntotRefMap + ns)); + } - if(mode!=2) - { - cout << "ERROR with MRC mode " << mode << "\n"; - cout << "Currently mode 2 is the only one allowed" << "\n"; - exit(1); - } + if (mode != 2) + { + cout << "ERROR with MRC mode " << mode << "\n"; + cout << "Currently mode 2 is the only one allowed" + << "\n"; + exit(1); + } else + { + rewind(fin); + for (count = 0; count < 256; ++count) + if (read_float_empty(fin) == 0) + { + cout << "ERROR Converting Data: " << filename; + exit(1); + } + + for (count = 0; count < (unsigned long) nsymbt; ++count) + if (read_char_float(&currfloat, fin) == 0) + { + cout << "ERROR Converting Data: " << filename; + exit(1); + } + + for (int nmap = 0; nmap < ns; nmap++) { - rewind (fin); - for (count=0; count<256; ++count) if (read_float_empty(fin)==0) { - cout << "ERROR Converting Data: " << filename; - exit(1); - } - - for (count=0; count<(unsigned long)nsymbt; ++count) if (read_char_float(&currfloat,fin)==0) { - cout << "ERROR Converting Data: " << filename; - exit(1); - } - - for ( int nmap = 0 ; nmap < ns ; nmap ++ ) - { - st=0.0; - st2=0.0; - for ( int j = 0 ; j < nr ; j ++ ) - for ( int i = 0 ; i < nc ; i ++ ) - { - if (read_float(&currfloat,fin,swap)==0) - { - cout << "ERROR Converting Data: " << filename; - exit(1); - } - else - { - if(!param.notsqure){ - maps[(nmap + ntotRefMap) * refMapSize + i * numPixels + j] = (myfloat_t) currfloat; - st += currfloat; - st2 += currfloat*currfloat; - } else { - if( i > 595 && i < 675 && j > 1250 && j< 1330 && nmap >230 && nmap <310)cout << "map1: " << i << " "<< j << " " << nmap << " " << currfloat <<"\n"; - } - } - } - if(param.notsqure)exit(1); - //Normaling maps to zero mean and unit standard deviation - if(!param.notnormmap){ - st /= float(nr*nc); - st2 = sqrt(st2 / float(nr * nc) - st * st); - for ( int j = 0 ; j < nr ; j ++ ) for ( int i = 0 ; i < nc ; i ++ ){ - maps[(nmap + ntotRefMap) * refMapSize + i * numPixels + j] = maps[(nmap + ntotRefMap) * refMapSize + i * numPixels + j] / st2 - st/st2; - //cout <<"MAP:: " << i << " " << j << " " << maps[(nmap + ntotRefMap) * refMapSize + i * numPixels + j] << "\n"; - } - } - } - ntotRefMap += ns ; - // cout << ntotRefMap << "\n"; + st = 0.0; + st2 = 0.0; + for (int j = 0; j < nr; j++) + for (int i = 0; i < nc; i++) + { + if (read_float(&currfloat, fin, swap) == 0) + { + cout << "ERROR Converting Data: " << filename; + exit(1); + } + else + { + maps[(nmap + ntotRefMap) * refMapSize + i * numPixels + j] = + (myfloat_t) currfloat; + st += currfloat; + st2 += currfloat * currfloat; + } + } + // Normaling maps to zero mean and unit standard deviation + if (!param.notnormmap) + { + st /= float(nr * nc); + st2 = sqrt(st2 / float(nr * nc) - st * st); + for (int j = 0; j < nr; j++) + for (int i = 0; i < nc; i++) + { + maps[(nmap + ntotRefMap) * refMapSize + i * numPixels + j] = + maps[(nmap + ntotRefMap) * refMapSize + i * numPixels + j] / + st2 - + st / st2; + // cout <<"MAP:: " << i << " " << j << " " << maps[(nmap + + // ntotRefMap) * refMapSize + i * numPixels + j] << "\n"; + } + } } - fclose (fin); + ntotRefMap += ns; + // cout << ntotRefMap << "\n"; + } + fclose(fin); - return(0); + return (0); } -int bioem_RefMap::read_float(float *currfloat, FILE *fin, int swap) { +int bioem_RefMap::read_float(float *currfloat, FILE *fin, int swap) +{ unsigned char *cptr, tmp; - if (fread(currfloat,4,1,fin)!=1) return 0; - if (swap == 1) { - cptr = (unsigned char *)currfloat; + if (fread(currfloat, 4, 1, fin) != 1) + return 0; + if (swap == 1) + { + cptr = (unsigned char *) currfloat; tmp = cptr[0]; - cptr[0]=cptr[3]; - cptr[3]=tmp; + cptr[0] = cptr[3]; + cptr[3] = tmp; tmp = cptr[1]; - cptr[1]=cptr[2]; - cptr[2]=tmp; + cptr[1] = cptr[2]; + cptr[2] = tmp; } return 1; } -int bioem_RefMap::read_int(int *currlong, FILE *fin, int swap) { +int bioem_RefMap::read_int(int *currlong, FILE *fin, int swap) +{ unsigned char *cptr, tmp; - if (fread(currlong,4,1,fin)!=1) return 0; - if (swap == 1) { - cptr = (unsigned char *)currlong; + if (fread(currlong, 4, 1, fin) != 1) + return 0; + if (swap == 1) + { + cptr = (unsigned char *) currlong; tmp = cptr[0]; - cptr[0]=cptr[3]; - cptr[3]=tmp; + cptr[0] = cptr[3]; + cptr[3] = tmp; tmp = cptr[1]; - cptr[1]=cptr[2]; - cptr[2]=tmp; + cptr[1] = cptr[2]; + cptr[2] = tmp; } return 1; } -int bioem_RefMap::read_float_empty (FILE *fin) { +int bioem_RefMap::read_float_empty(FILE *fin) +{ float currfloat; - if (fread(&currfloat,4,1,fin)!=1) return 0; + if (fread(&currfloat, 4, 1, fin) != 1) + return 0; return 1; } -int bioem_RefMap::read_char_float (float *currfloat, FILE *fin) { +int bioem_RefMap::read_char_float(float *currfloat, FILE *fin) +{ char currchar; - if (fread(&currchar,1,1,fin)!=1) return 0; - *currfloat=(float)currchar; + if (fread(&currchar, 1, 1, fin) != 1) + return 0; + *currfloat = (float) currchar; return 1; } -int bioem_RefMap::test_mrc (const char *vol_file, int swap) { +int bioem_RefMap::test_mrc(const char *vol_file, int swap) +{ FILE *fin; int nc, nr, ns, mx, my, mz; int mode, ncstart, nrstart, nsstart; @@ -618,56 +681,71 @@ int bioem_RefMap::test_mrc (const char *vol_file, int swap) { float dmin, dmax, dmean, dummy, xorigin, yorigin, zorigin; fin = fopen(vol_file, "rb"); - if( fin == NULL ) { + if (fin == NULL) + { cout << "ERROR opening MRC: " << vol_file; exit(1); } //* read header info - header_ok *= read_int(&nc,fin,swap); - header_ok *= read_int(&nr,fin,swap); - header_ok *= read_int(&ns,fin,swap); - header_ok *= read_int(&mode,fin,swap); - header_ok *= read_int(&ncstart,fin,swap); - header_ok *= read_int(&nrstart,fin,swap); - header_ok *= read_int(&nsstart,fin,swap); - header_ok *= read_int(&mx,fin,swap); - header_ok *= read_int(&my,fin,swap); - header_ok *= read_int(&mz,fin,swap); - header_ok *= read_float(&xlen,fin,swap); - header_ok *= read_float(&ylen,fin,swap); - header_ok *= read_float(&zlen,fin,swap); - header_ok *= read_float(&alpha,fin,swap); - header_ok *= read_float(&beta,fin,swap); - header_ok *= read_float(&gamma,fin,swap); - header_ok *= read_int(&mapc,fin,swap); - header_ok *= read_int(&mapr,fin,swap); - header_ok *= read_int(&maps_local,fin,swap); - header_ok *= read_float(&dmin,fin,swap); - header_ok *= read_float(&dmax,fin,swap); - header_ok *= read_float(&dmean,fin,swap); - for (i=23; i<50; ++i) header_ok *= read_float(&dummy,fin,swap); - header_ok *= read_float(&xorigin,fin,swap); - header_ok *= read_float(&yorigin,fin,swap); - header_ok *= read_float(&zorigin,fin,swap); - fclose (fin); - if (header_ok == 0) { + header_ok *= read_int(&nc, fin, swap); + header_ok *= read_int(&nr, fin, swap); + header_ok *= read_int(&ns, fin, swap); + header_ok *= read_int(&mode, fin, swap); + header_ok *= read_int(&ncstart, fin, swap); + header_ok *= read_int(&nrstart, fin, swap); + header_ok *= read_int(&nsstart, fin, swap); + header_ok *= read_int(&mx, fin, swap); + header_ok *= read_int(&my, fin, swap); + header_ok *= read_int(&mz, fin, swap); + header_ok *= read_float(&xlen, fin, swap); + header_ok *= read_float(&ylen, fin, swap); + header_ok *= read_float(&zlen, fin, swap); + header_ok *= read_float(&alpha, fin, swap); + header_ok *= read_float(&beta, fin, swap); + header_ok *= read_float(&gamma, fin, swap); + header_ok *= read_int(&mapc, fin, swap); + header_ok *= read_int(&mapr, fin, swap); + header_ok *= read_int(&maps_local, fin, swap); + header_ok *= read_float(&dmin, fin, swap); + header_ok *= read_float(&dmax, fin, swap); + header_ok *= read_float(&dmean, fin, swap); + for (i = 23; i < 50; ++i) + header_ok *= read_float(&dummy, fin, swap); + header_ok *= read_float(&xorigin, fin, swap); + header_ok *= read_float(&yorigin, fin, swap); + header_ok *= read_float(&zorigin, fin, swap); + fclose(fin); + if (header_ok == 0) + { cout << "ERROR reading MRC header: " << vol_file; exit(1); } - n_range_viols += (nc>5000); n_range_viols += (nc<0); - n_range_viols += (nr>5000); n_range_viols += (nr<0); - n_range_viols += (ns>5000); n_range_viols += (ns<0); - n_range_viols += (ncstart>5000); n_range_viols += (ncstart<-5000); - n_range_viols += (nrstart>5000); n_range_viols += (nrstart<-5000); - n_range_viols += (nsstart>5000); n_range_viols += (nsstart<-5000); - n_range_viols += (mx>5000); n_range_viols += (mx<0); - n_range_viols += (my>5000); n_range_viols += (my<0); - n_range_viols += (mz>5000); n_range_viols += (mz<0); - n_range_viols += (alpha>360.0f); n_range_viols += (alpha<-360.0f); - n_range_viols += (beta>360.0f); n_range_viols += (beta<-360.0f); - n_range_viols += (gamma>360.0f); n_range_viols += (gamma<-360.0f); + n_range_viols += (nc > 5000); + n_range_viols += (nc < 0); + n_range_viols += (nr > 5000); + n_range_viols += (nr < 0); + n_range_viols += (ns > 5000); + n_range_viols += (ns < 0); + n_range_viols += (ncstart > 5000); + n_range_viols += (ncstart < -5000); + n_range_viols += (nrstart > 5000); + n_range_viols += (nrstart < -5000); + n_range_viols += (nsstart > 5000); + n_range_viols += (nsstart < -5000); + n_range_viols += (mx > 5000); + n_range_viols += (mx < 0); + n_range_viols += (my > 5000); + n_range_viols += (my < 0); + n_range_viols += (mz > 5000); + n_range_viols += (mz < 0); + n_range_viols += (alpha > 360.0f); + n_range_viols += (alpha < -360.0f); + n_range_viols += (beta > 360.0f); + n_range_viols += (beta < -360.0f); + n_range_viols += (gamma > 360.0f); + n_range_viols += (gamma < -360.0f); return n_range_viols; } diff --git a/model.cpp b/model.cpp index 2e16b68e9c9369ccd3c79510467c1bfdd5b1d645..a0a42163b26800a2742a413dc68d8fbedf121250 100644 --- a/model.cpp +++ b/model.cpp @@ -1,317 +1,389 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ +#include #include #include #include #include -#include #include "model.h" #include "param.h" using namespace std; -bioem_model::bioem_model() -{ - points = NULL; -} +bioem_model::bioem_model() { points = NULL; } bioem_model::~bioem_model() { - if (points) free(points); + if (points) + free(points); } -int bioem_model::readModel(bioem_param& param, const char* filemodel) +int bioem_model::readModel(bioem_param ¶m, const char *filemodel) { // ************************************************************************************** - // ***************Reading reference Models either PDB or x,y,z,r,d format**************** + // ***************Reading reference Models either PDB or x,y,z,r,d + // format**************** // ************************************************************************************** ofstream exampleReadCoor; - exampleReadCoor.open ("COORDREAD"); + exampleReadCoor.open("COORDREAD"); - exampleReadCoor << "Text --- Number ---- x ---- y ---- z ---- radius ---- number of electron\n"; - + exampleReadCoor << "Text --- Number ---- x ---- y ---- z ---- radius ---- " + "number of electron\n"; int allocsize = 0; std::ifstream input(filemodel); - if(readPDB) + if (readPDB) + { + //************** Reading PDB files ********************** + + ifstream input(filemodel); + if (!input.good()) { - //************** Reading PDB files ********************** + cout << "PDB Failed to open file" + << endl; // pdbfilename << " ("< endpos) + { + cout << "Warining:::: .pdb extension NOT dectected in file name \n"; + cout << "Warining:::: Are you sure you want to read a PDB? \n"; + } - if(foundpos > endpos){ - cout << "Warining:::: .pdb extension NOT dectected in file name \n"; - cout << "Warining:::: Are you sure you want to read a PDB? \n"; - } + // cout << " HERE " << filemodel ; + // for eachline in the file + while (!input.eof()) + { + input.getline(line, 511); + strncpy(tmpLine, line, strlen(line)); + char *token = strtok(tmpLine, " "); - // cout << " HERE " << filemodel ; - // for eachline in the file - while (!input.eof()) - { - input.getline(line, 511); - - strncpy(tmpLine, line, strlen(line)); - char *token = strtok(tmpLine, " "); - - if (strcmp(token, "ATOM") == 0) // Optional,Mandatory if standard residues exist - { - /* - 1-6 "ATOM " - 7 - 11 Integer serial Atom serial number. - 13 - 16 Atom name Atom name. - 17 Character altLoc Alternate location indicator. - 18 - 20 Residue name resName Residue name. - 22 Character chainID Chain identifier. - 23 - 26 Integer resSeq Residue sequence number. - 27 AChar iCode Code for insertion of residues. - 31 - 38 Real(8.3) x Orthogonal coordinates for X in - 39 - 46 Real(8.3) y Orthogonal coordinates for Y in - 47 - 54 Real(8.3) z Orthogonal coordinates for Z in - */ - - char name[5] = {0}; - char resName[4] = {0}; - float x = 0.0; - float y = 0.0; - float z = 0.0; - char tmp[6] = {0}; - - // parse name - strncpy(tmp, line + 12, 4); - sscanf (tmp, "%s", name); - - // parse resName - strncpy(tmp, line + 17, 3); - sscanf (tmp, "%s", resName); - - // parse x, y, z - char tmpVals[36] = {0}; - - strncpy (tmpVals, line + 30, 8); - sscanf (tmpVals, "%f", &x); - - strncpy (tmpVals, line + 38, 8); - sscanf (tmpVals, "%f", &y); - - strncpy (tmpVals, line + 46, 8); - sscanf (tmpVals, "%f", &z); - - if (strcmp(name, "CA") == 0) - { - if (allocsize == 0) - { - allocsize = 64; - points = (bioem_model_point*) mallocchk(sizeof(bioem_model_point) * allocsize); - } - else if (numres + 1 >= allocsize) - { - allocsize *= 2; - points = (bioem_model_point*) reallocchk(points, sizeof(bioem_model_point) * allocsize); - } - - //Getting residue Radius and electron density - points[numres].radius = getAminoAcidRad(resName); - points[numres].density = getAminoAcidDensity(resName); - NormDen += points[numres].density; - - //Getting the coordinates - points[numres].point.pos[0] = (myfloat_t) x; - points[numres].point.pos[1] = (myfloat_t) y; - points[numres].point.pos[2] = (myfloat_t) z; - exampleReadCoor << "RESIDUE " << numres << " " << points[numres].point.pos[0] << " " << points[numres].point.pos[1] << " " << points[numres].point.pos[2] << " " << points[numres].radius << " " << points[numres].density << "\n"; - numres++; - } - } - - - } - nPointsModel = numres; - cout << "Protein structure read from PDB\n"; + if (strcmp(token, "ATOM") == + 0) // Optional,Mandatory if standard residues exist + { + /* + 1-6 "ATOM " + 7 - 11 Integer serial Atom + serial + number. + 13 - 16 Atom name Atom + name. + 17 Character altLoc Alternate + location indicator. + 18 - 20 Residue name resName Residue name. + 22 Character chainID Chain + identifier. + 23 - 26 Integer resSeq Residue + sequence number. + 27 AChar iCode Code + for + insertion of residues. + 31 - 38 Real(8.3) x Orthogonal + coordinates for X in + 39 - 46 Real(8.3) y Orthogonal + coordinates for Y in + 47 - 54 Real(8.3) z Orthogonal + coordinates for Z in + */ + + char name[5] = {0}; + char resName[4] = {0}; + float x = 0.0; + float y = 0.0; + float z = 0.0; + char tmp[6] = {0}; + + // parse name + strncpy(tmp, line + 12, 4); + sscanf(tmp, "%s", name); + + // parse resName + strncpy(tmp, line + 17, 3); + sscanf(tmp, "%s", resName); + + // parse x, y, z + char tmpVals[36] = {0}; + + strncpy(tmpVals, line + 30, 8); + sscanf(tmpVals, "%f", &x); + + strncpy(tmpVals, line + 38, 8); + sscanf(tmpVals, "%f", &y); + + strncpy(tmpVals, line + 46, 8); + sscanf(tmpVals, "%f", &z); + + if (strcmp(name, "CA") == 0) + { + if (allocsize == 0) + { + allocsize = 64; + points = (bioem_model_point *) mallocchk(sizeof(bioem_model_point) * + allocsize); + } + else if (numres + 1 >= allocsize) + { + allocsize *= 2; + points = (bioem_model_point *) reallocchk( + points, sizeof(bioem_model_point) * allocsize); + } + + // Getting residue Radius and electron density + points[numres].radius = getAminoAcidRad(resName); + points[numres].density = getAminoAcidDensity(resName); + NormDen += points[numres].density; + + // Getting the coordinates + points[numres].point.pos[0] = (myfloat_t) x; + points[numres].point.pos[1] = (myfloat_t) y; + points[numres].point.pos[2] = (myfloat_t) z; + exampleReadCoor << "RESIDUE " << numres << " " + << points[numres].point.pos[0] << " " + << points[numres].point.pos[1] << " " + << points[numres].point.pos[2] << " " + << points[numres].radius << " " + << points[numres].density << "\n"; + numres++; + } + } } - else //Reading model from FILE FORMAT x,y,z,rad,density - { - //**************** Reading Text FILES *********************** + nPointsModel = numres; + cout << "Protein structure read from PDB\n"; + } + else // Reading model from FILE FORMAT x,y,z,rad,density + { + //**************** Reading Text FILES *********************** - char line[128]; - int numres = 0; - NormDen = 0.0; + char line[128]; + int numres = 0; + NormDen = 0.0; - string strfilename(filemodel); + string strfilename(filemodel); - size_t foundpos= strfilename.find(".pdb"); - size_t endpos = strfilename.find_last_not_of(" \t"); + size_t foundpos = strfilename.find(".pdb"); + size_t endpos = strfilename.find_last_not_of(" \t"); + + if (foundpos < endpos) + { + cout << "Warining:::: .pdb dectected in file name whilst using text read " + "\n"; + cout << "Warining:::: Are you sure you do not need --ReadPDB? \n"; + cout << "If so then you must include the keyword IGNORE_PDB in " + "inputfile\n"; + if (not param.ignorePDB) + exit(1); + } - if(foundpos < endpos){ - cout << "Warining:::: .pdb dectected in file name whilst using text read \n"; - cout << "Warining:::: Are you sure you do not need --ReadPDB? \n"; - cout << "If so then you must include the keyword IGNORE_PDB in inputfile\n"; - if(not param.ignorePDB)exit(1); + FILE *file = fopen(filemodel, "r"); + if (file == NULL) + { + cout << "Error opening file " << filemodel << "\n"; + exit(1); + } + while (fgets(line, sizeof line, file) != NULL) + { + if (allocsize == 0) + { + allocsize = 64; + points = (bioem_model_point *) mallocchk(sizeof(bioem_model_point) * + allocsize); + } + else if (numres + 1 >= allocsize) + { + allocsize *= 2; + points = (bioem_model_point *) reallocchk( + points, sizeof(bioem_model_point) * allocsize); } - - FILE *file = fopen ( filemodel , "r" ); - if (file == NULL) - { - cout << "Error opening file " << filemodel << "\n"; - exit(1); - } - while ( fgets ( line, sizeof line, file ) != NULL ) - { - if (allocsize == 0) - { - allocsize = 64; - points = (bioem_model_point*) mallocchk(sizeof(bioem_model_point) * allocsize); - } - else if (numres + 1 >= allocsize) - { - allocsize *= 2; - points = (bioem_model_point*) reallocchk(points, sizeof(bioem_model_point) * allocsize); - } - - float tmpval[5]; - sscanf(line, "%f %f %f %f %f", &tmpval[0], &tmpval[1], &tmpval[2], &tmpval[3], &tmpval[4]); - points[numres].point.pos[0] = (myfloat_t) tmpval[0]; - points[numres].point.pos[1] = (myfloat_t) tmpval[1]; - points[numres].point.pos[2] = (myfloat_t) tmpval[2]; - points[numres].radius = (myfloat_t) tmpval[3]; - points[numres].density = (myfloat_t) tmpval[4]; - - exampleReadCoor << "RESIDUE " << numres << " " << points[numres].point.pos[0] << " " << points[numres].point.pos[1] << " " << points[numres].point.pos[2] << " " << points[numres].radius << " " << points[numres].density << "\n"; - NormDen += points[numres].density; - numres++; - } - fclose(file); - nPointsModel = numres; - cout << "Protein structure read from Standard File\n"; + + float tmpval[5]; + sscanf(line, "%f %f %f %f %f", &tmpval[0], &tmpval[1], &tmpval[2], + &tmpval[3], &tmpval[4]); + points[numres].point.pos[0] = (myfloat_t) tmpval[0]; + points[numres].point.pos[1] = (myfloat_t) tmpval[1]; + points[numres].point.pos[2] = (myfloat_t) tmpval[2]; + points[numres].radius = (myfloat_t) tmpval[3]; + points[numres].density = (myfloat_t) tmpval[4]; + + exampleReadCoor << "RESIDUE " << numres << " " + << points[numres].point.pos[0] << " " + << points[numres].point.pos[1] << " " + << points[numres].point.pos[2] << " " + << points[numres].radius << " " << points[numres].density + << "\n"; + NormDen += points[numres].density; + numres++; } - points = (bioem_model_point*) reallocchk(points, sizeof(bioem_model_point) * nPointsModel); - cout << "Total Number of Voxels " << nPointsModel ; - cout << "\nTotal Number of Electrons " << NormDen ; + fclose(file); + nPointsModel = numres; + cout << "Protein structure read from Standard File\n"; + } + points = (bioem_model_point *) reallocchk(points, sizeof(bioem_model_point) * + nPointsModel); + cout << "Total Number of Voxels " << nPointsModel; + cout << "\nTotal Number of Electrons " << NormDen; cout << "\n+++++++++++++++++++++++++++++++++++++++++ \n"; - exampleReadCoor.close(); + exampleReadCoor.close(); //******************** Moving to Model to its center of density mass: myfloat3_t r_cm; - if(not(param.nocentermass)){ //by default it is normally done + if (not(param.nocentermass)) + { // by default it is normally done - for(int n = 0; n < 3; n++)r_cm.pos[n] = 0.0; + for (int n = 0; n < 3; n++) + r_cm.pos[n] = 0.0; - for(int n = 0; n < nPointsModel; n++) - { - r_cm.pos[0] += points[n].point.pos[0]*points[n].density; - r_cm.pos[1] += points[n].point.pos[1]*points[n].density; - r_cm.pos[2] += points[n].point.pos[2]*points[n].density; - } - r_cm.pos[0] = r_cm.pos[0] / NormDen ; - r_cm.pos[1] = r_cm.pos[1] / NormDen ; + for (int n = 0; n < nPointsModel; n++) + { + r_cm.pos[0] += points[n].point.pos[0] * points[n].density; + r_cm.pos[1] += points[n].point.pos[1] * points[n].density; + r_cm.pos[2] += points[n].point.pos[2] * points[n].density; + } + r_cm.pos[0] = r_cm.pos[0] / NormDen; + r_cm.pos[1] = r_cm.pos[1] / NormDen; r_cm.pos[2] = r_cm.pos[2] / NormDen; - for(int n = 0; n < nPointsModel; n++) - { - points[n].point.pos[0] -= r_cm.pos[0]; - points[n].point.pos[1] -= r_cm.pos[1]; - points[n].point.pos[2] -= r_cm.pos[2]; - - } + for (int n = 0; n < nPointsModel; n++) + { + points[n].point.pos[0] -= r_cm.pos[0]; + points[n].point.pos[1] -= r_cm.pos[1]; + points[n].point.pos[2] -= r_cm.pos[2]; + } } - return(0); + return (0); } myfloat_t bioem_model::getAminoAcidRad(char *name) { - // *************** Function that gets the radius for each amino acid **************** + // *************** Function that gets the radius for each amino acid + // **************** myfloat_t iaa = 0; - if(std::strcmp(name, "CYS") == 0)iaa = 2.75; - else if(std::strcmp(name, "PHE") == 0)iaa = 3.2; - else if(std::strcmp(name, "LEU") == 0)iaa = 3.1; - else if(std::strcmp(name, "TRP") == 0)iaa = 3.4; - else if(std::strcmp(name, "VAL") == 0)iaa = 2.95; - else if(std::strcmp(name, "ILE") == 0)iaa = 3.1; - else if(std::strcmp(name, "MET") == 0)iaa = 3.1; - else if(std::strcmp(name, "HIS") == 0)iaa = 3.05; - else if(std::strcmp(name, "TYR") == 0)iaa = 3.25; - else if(std::strcmp(name, "ALA") == 0)iaa = 2.5; - else if(std::strcmp(name, "GLY") == 0)iaa = 2.25; - else if(std::strcmp(name, "PRO") == 0)iaa = 2.8; - else if(std::strcmp(name, "ASN") == 0)iaa = 2.85; - else if(std::strcmp(name, "THR") == 0)iaa = 2.8; - else if(std::strcmp(name, "SER") == 0)iaa = 2.6; - else if(std::strcmp(name, "ARG") == 0)iaa = 3.3; - else if(std::strcmp(name, "GLN") == 0)iaa = 3.0; - else if(std::strcmp(name, "ASP") == 0)iaa = 2.8; - else if(std::strcmp(name, "LYS") == 0)iaa = 3.2; - else if(std::strcmp(name, "GLU") == 0)iaa = 2.95; - - if(iaa == 0) - { - cout << "PROBLEM WITH AMINO ACID " << name << endl; - exit(1); - } + if (std::strcmp(name, "CYS") == 0) + iaa = 2.75; + else if (std::strcmp(name, "PHE") == 0) + iaa = 3.2; + else if (std::strcmp(name, "LEU") == 0) + iaa = 3.1; + else if (std::strcmp(name, "TRP") == 0) + iaa = 3.4; + else if (std::strcmp(name, "VAL") == 0) + iaa = 2.95; + else if (std::strcmp(name, "ILE") == 0) + iaa = 3.1; + else if (std::strcmp(name, "MET") == 0) + iaa = 3.1; + else if (std::strcmp(name, "HIS") == 0) + iaa = 3.05; + else if (std::strcmp(name, "TYR") == 0) + iaa = 3.25; + else if (std::strcmp(name, "ALA") == 0) + iaa = 2.5; + else if (std::strcmp(name, "GLY") == 0) + iaa = 2.25; + else if (std::strcmp(name, "PRO") == 0) + iaa = 2.8; + else if (std::strcmp(name, "ASN") == 0) + iaa = 2.85; + else if (std::strcmp(name, "THR") == 0) + iaa = 2.8; + else if (std::strcmp(name, "SER") == 0) + iaa = 2.6; + else if (std::strcmp(name, "ARG") == 0) + iaa = 3.3; + else if (std::strcmp(name, "GLN") == 0) + iaa = 3.0; + else if (std::strcmp(name, "ASP") == 0) + iaa = 2.8; + else if (std::strcmp(name, "LYS") == 0) + iaa = 3.2; + else if (std::strcmp(name, "GLU") == 0) + iaa = 2.95; + + if (iaa == 0) + { + cout << "PROBLEM WITH AMINO ACID " << name << endl; + exit(1); + } return iaa; - } myfloat_t bioem_model::getAminoAcidDensity(char *name) { - // *************** Function that gets the number of electrons for each amino acid **************** + // *************** Function that gets the number of electrons for each amino + // acid **************** myfloat_t iaa = 0.0; - if(std::strcmp(name, "CYS") == 0)iaa = 64.0; - else if(std::strcmp(name, "PHE") == 0)iaa = 88.0; - else if(std::strcmp(name, "LEU") == 0)iaa = 72.0; - else if(std::strcmp(name, "TRP") == 0)iaa = 108.0; - else if(std::strcmp(name, "VAL") == 0)iaa = 64.0; - else if(std::strcmp(name, "ILE") == 0)iaa = 72.0; - else if(std::strcmp(name, "MET") == 0)iaa = 80.0; - else if(std::strcmp(name, "HIS") == 0)iaa = 82.0; - else if(std::strcmp(name, "TYR") == 0)iaa = 96.0; - else if(std::strcmp(name, "ALA") == 0)iaa = 48.0; - else if(std::strcmp(name, "GLY") == 0)iaa = 40.0; - else if(std::strcmp(name, "PRO") == 0)iaa = 62.0; - else if(std::strcmp(name, "ASN") == 0)iaa = 66.0; - else if(std::strcmp(name, "THR") == 0)iaa = 64.0; - else if(std::strcmp(name, "SER") == 0)iaa = 56.0; - else if(std::strcmp(name, "ARG") == 0)iaa = 93.0; - else if(std::strcmp(name, "GLN") == 0)iaa = 78.0; - else if(std::strcmp(name, "ASP") == 0)iaa = 59.0; - else if(std::strcmp(name, "LYS") == 0)iaa = 79.0; - else if(std::strcmp(name, "GLU") == 0)iaa = 53.0; - - if(iaa == 0.0) - { - cout << "PROBLEM WITH AMINO ACID " << name << endl; - exit(1); - } + if (std::strcmp(name, "CYS") == 0) + iaa = 64.0; + else if (std::strcmp(name, "PHE") == 0) + iaa = 88.0; + else if (std::strcmp(name, "LEU") == 0) + iaa = 72.0; + else if (std::strcmp(name, "TRP") == 0) + iaa = 108.0; + else if (std::strcmp(name, "VAL") == 0) + iaa = 64.0; + else if (std::strcmp(name, "ILE") == 0) + iaa = 72.0; + else if (std::strcmp(name, "MET") == 0) + iaa = 80.0; + else if (std::strcmp(name, "HIS") == 0) + iaa = 82.0; + else if (std::strcmp(name, "TYR") == 0) + iaa = 96.0; + else if (std::strcmp(name, "ALA") == 0) + iaa = 48.0; + else if (std::strcmp(name, "GLY") == 0) + iaa = 40.0; + else if (std::strcmp(name, "PRO") == 0) + iaa = 62.0; + else if (std::strcmp(name, "ASN") == 0) + iaa = 66.0; + else if (std::strcmp(name, "THR") == 0) + iaa = 64.0; + else if (std::strcmp(name, "SER") == 0) + iaa = 56.0; + else if (std::strcmp(name, "ARG") == 0) + iaa = 93.0; + else if (std::strcmp(name, "GLN") == 0) + iaa = 78.0; + else if (std::strcmp(name, "ASP") == 0) + iaa = 59.0; + else if (std::strcmp(name, "LYS") == 0) + iaa = 79.0; + else if (std::strcmp(name, "GLU") == 0) + iaa = 53.0; + + if (iaa == 0.0) + { + cout << "PROBLEM WITH AMINO ACID " << name << endl; + exit(1); + } return iaa; } - diff --git a/param.cpp b/param.cpp index a6437bd6f3fb3b42d27caa604432709581cb576a..ec5d1515d8e2ee58b2ccfc2f57d6b6bf70926fe1 100644 --- a/param.cpp +++ b/param.cpp @@ -1,47 +1,48 @@ /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ < BioEM software for Bayesian inference of Electron Microscopy images> - Copyright (C) 2016 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, - Volker Lindenstruth and Gerhard Hummer. + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. Max Planck Institute of Biophysics, Frankfurt, Germany. - Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, Germany. - Max Planck Computing and Data Facility, Garching, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. - Released under the GNU Public License, v3. + Released under the GNU Public License, v3. See license statement for terms of distribution. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ -#include -#include -#include -#include #include -#include #include +#include +#include +#include +#include +#include #ifdef WITH_OPENMP #include #endif -#include "param.h" #include "map.h" +#include "param.h" using namespace std; bioem_param::bioem_param() { - + //**************** Initializing Variables and defaults **************** - //Number of Pixels + // Number of Pixels param_device.NumberPixels = 0; param_device.NumberFFTPixels1D = 0; // Euler angle grid spacing angleGridPointsAlpha = 0; angleGridPointsBeta = 0; - //Envelop function paramters + // Envelop function paramters numberGridPointsEnvelop = 0; - //Contrast transfer function paramters + // Contrast transfer function paramters numberGridPointsCTF_amp = 0; numberGridPointsCTF_phase = 0; @@ -57,61 +58,60 @@ bioem_param::bioem_param() angprior = NULL; printModel = false; + BestmapCalcCC = false; } -int bioem_param::readParameters(const char* fileinput) -{ // ************************************************************************************** - // ***************************** Reading Input Parameters ****************************** - // ************************************************************************************** +int bioem_param::readParameters(const char *fileinput) +{ // ************************************************************************************** + // ***************************** Reading Input Parameters + // ****************************** + // ************************************************************************************** - // Control for Parameters + // Control for Parameters bool yesPixSi = false; bool yesNumPix = false; bool yesGPal = false; bool yesGPbe = false; - bool yesMDC = false ; - bool yesBFact=false; - bool yesDefocus=false; - bool yesAMP=false; - bool yesPSFenv=false; - bool yesPSFpha=false; - bool yesquatgrid=false; + bool yesMDC = false; + bool yesBFact = false; + bool yesDefocus = false; + bool yesAMP = false; + bool yesPSFenv = false; + bool yesPSFpha = false; + bool yesquatgrid = false; //***************** Default VALUES - param_device.flipped=false; - param_device.debugterm=false; - param_device.writeCC=false; - param_device.tousepsf=false; - param_device.CCwithBayes=true; - writeCTF=false; - elecwavel=0.019866; - ignoreCCoff=false; - doquater=false; - nocentermass=false; - printrotmod=false; - readquatlist=false; - doaaradius=true; - notnormmap=false; - usepsf=false; - yespriorAngles=false; - ignorepointsout=false; - printrotmod=false; - ignorePDB=false; - - NotUn_angles=0; - priorMod=1; //Default - shiftX=0; - shiftY=0; - param_device.sigmaPriorbctf=100.; - param_device.sigmaPriordefo=1.0; - param_device.Priordefcent=3.0; + param_device.tousepsf = false; + writeCTF = false; + elecwavel = 0.019866; + doquater = false; + nocentermass = false; + printrotmod = false; + readquatlist = false; + doaaradius = true; + notnormmap = false; + usepsf = false; + yespriorAngles = false; + ignorepointsout = false; + printrotmod = false; + ignorePDB = false; + + NotUn_angles = 0; + priorMod = 1; // Default + shiftX = 0; + shiftY = 0; + param_device.sigmaPriorbctf = 100.; + param_device.sigmaPriordefo = 2.0; + param_device.Priordefcent = 3.0; + param_device.sigmaPrioramp = 0.5; + param_device.Priorampcent = 0.; ifstream input(fileinput); if (!input.good()) - { - cout << "Failed to open file: " << fileinput << "\n"; - exit(1); - } + { + cout << "Failed to open file: " << fileinput << "\n"; + exit(1); + } char line[512] = {0}; char saveline[512]; @@ -119,1016 +119,1343 @@ int bioem_param::readParameters(const char* fileinput) cout << "\n +++++++++++++++++++++++++++++++++++++++++ \n"; cout << "\n READING BioEM PARAMETERS \n\n"; cout << " +++++++++++++++++++++++++++++++++++++++++ \n"; - - while (!input.eof()) - { - input.getline(line, 512); - strcpy(saveline, line); - char *token = strtok(line, " "); - - if (token == NULL || line[0] == '#' || strlen(token) == 0) - { - // comment or blank line - } - else if (strcmp(token, "PIXEL_SIZE") == 0) - { - token = strtok(NULL, " "); - pixelSize = atof(token); - if (pixelSize < 0 ) { cout << "*** Error: Negative pixelSize "; exit(1);} - cout << "Pixel Sixe " << pixelSize << "\n"; - yesPixSi= true; - } - else if (strcmp(token, "NOT_SQUARE_IMAGE") == 0) - { - notsqure=true; - } - else if (strcmp(token, "NUMBER_PIXELS") == 0) - { - token = strtok(NULL, " "); - param_device.NumberPixels = int(atoi(token)); - if (param_device.NumberPixels < 0 ) { cout << "*** Error: Negative Number of Pixels "; exit(1);} - cout << "Number of Pixels " << param_device.NumberPixels << "\n"; - yesNumPix= true ; - } - else if (strcmp(token, "GRIDPOINTS_ALPHA") == 0) - { - token = strtok(NULL, " "); - angleGridPointsAlpha = int(atoi(token)); - if (angleGridPointsAlpha < 0 ) { cout << "*** Error: Negative GRIDPOINTS_ALPHA "; exit(1);} - cout << "Grid points alpha " << angleGridPointsAlpha << "\n"; - yesGPal= true; - } - else if (strcmp(token, "GRIDPOINTS_BETA") == 0) - { - token = strtok(NULL, " "); - angleGridPointsBeta = int(atoi(token)); - if (angleGridPointsBeta < 0 ) { cout << "*** Error: Negative GRIDPOINTS_BETA "; exit(1);} - cout << "Grid points in Cosine ( beta ) " << angleGridPointsBeta << "\n"; - yesGPbe= true; - } - else if (strcmp(token, "USE_QUATERNIONS") == 0) - // else if (token=="USE_QUATERNIONS") - { - cout << "Orientations with Quaternions. \n"; - doquater= true; - } - else if (strcmp(token, "GRIDPOINTS_QUATERNION") == 0) - { - if(!notuniformangles){ - token = strtok(NULL, " "); - GridPointsQuatern = int(atoi(token)); - cout << "Gridpoints Quaternions " << GridPointsQuatern << "\n"; - }else{ - cout << "Inconsitent Input: Grid or List with Quaternions?\n"; - exit(1);} - yesquatgrid=true; - doquater= true; - } - //CTF PARAMETERS - else if (strcmp(token, "CTF_B_ENV") == 0) - { - token = strtok(NULL, " "); - startBfactor = atof(token); - if (startBfactor < 0 ) { cout << "*** Error: Negative START B Env "; exit(1);} - token = strtok(NULL, " "); - endBfactor = atof(token); - if (endBfactor < 0 ) { cout << "*** Error: Negative END B Env "; exit(1);} - token = strtok(NULL, " "); - numberGridPointsEnvelop = int(atoi(token)); - if (numberGridPointsEnvelop < 0 ) { cout << "*** Error: Negative Number of Grid points BEnv "; exit(1);} - cout << "Grid CTF B-ENV: " << startBfactor << " " << endBfactor <<" " << numberGridPointsEnvelop<< "\n"; - if(startBfactor > endBfactor){ cout << "Error: Grid ill defined END > START\n"; exit(1);}; - yesBFact = true; - } - else if (strcmp(token,"CTF_DEFOCUS")==0) - { - token = strtok(NULL, " "); - startDefocus = atof(token); - if (startDefocus < 0 ) { cout << "*** Error: Negative START Defocus "; exit(1);} - token = strtok(NULL, " "); - endDefocus = atof(token); - if (endDefocus < 0 ) { cout << "*** Error: Negative END Defocus "; exit(1);} - token = strtok(NULL, " "); - numberGridPointsCTF_phase = int(atoi(token)); - if (numberGridPointsCTF_phase < 0 ) { cout << "*** Error: Negative Number of Grid points Defocus "; exit(1);} - cout << "Grid CTF Defocus: " << startDefocus << " " << endDefocus <<" " << numberGridPointsCTF_phase << "\n"; - if(startDefocus > endDefocus){ cout << "Error: Grid ill defined END > START\n"; exit(1);}; - if(endDefocus> 8.){cout << "Defocus beyond 8micro-m range is not allowed \n"; exit(1);} - yesDefocus = true; - } - else if (strcmp(token,"CTF_AMPLITUDE")==0) - { - token = strtok(NULL, " "); - startGridCTF_amp = atof(token); - if (startGridCTF_amp < 0 ) { cout << "*** Error: Negative START Amplitude "; exit(1);} - token = strtok(NULL, " "); - endGridCTF_amp = atof(token); - if (endGridCTF_amp < 0 ) { cout << "*** Error: Negative END Amplitude"; exit(1);} - token = strtok(NULL, " "); - numberGridPointsCTF_amp=int(atoi(token)); - if (numberGridPointsCTF_amp < 0 ) { cout << "*** Error: Negative Number of grid points amplitude "; exit(1);} - cout << "Grid Amplitude: " << startGridCTF_amp << " " << endGridCTF_amp <<" " << numberGridPointsCTF_amp << "\n"; - if(startGridCTF_amp > endGridCTF_amp){ cout << "Error: Grid ill defined END > START\n"; exit(1);}; - yesAMP = true; - } - else if (strcmp(token,"ELECTRON_WAVELENGTH")==0) - { - token = strtok(NULL," "); - elecwavel=atof(token); - if(elecwavel < 0.0150 ){ - cout << "Wrong electron wave length " << elecwavel << "\n"; - cout << "Has to be in Angstrom (A)\n"; - exit(1);} - cout << "Electron wave length in (A) is: " << elecwavel << "\n"; - } - //PSF PARAMETERS - else if (strcmp(token, "USE_PSF") == 0) - { - usepsf=true; - param_device.tousepsf=true; - cout << "IMPORTANT: Using Point Spread Function. Thus, all parameters are in Real Space. \n"; - } - else if (strcmp(token,"PSF_AMPLITUDE")==0) - { - token = strtok(NULL, " "); - startGridCTF_amp = atof(token); - if (startGridCTF_amp < 0 ) { cout << "*** Error: Negative START Amplitude "; exit(1);} - token = strtok(NULL, " "); - endGridCTF_amp = atof(token); - if (endGridCTF_amp < 0 ) { cout << "*** Error: Negative END Amplitude"; exit(1);} - token = strtok(NULL, " "); - numberGridPointsCTF_amp= int(atoi(token)); - if (numberGridPointsCTF_amp < 0 ) { cout << "*** Error: Negative Number of grid points amplitude "; exit(1);} - cout << "Grid Amplitude: " << startGridCTF_amp << " " << endGridCTF_amp <<" " << numberGridPointsCTF_amp << "\n"; - if(startGridCTF_amp > endGridCTF_amp){ cout << "Error: Grid ill defined END > START\n"; exit(1);}; - yesAMP = true; - } - else if (strcmp(token,"PSF_ENVELOPE")==0) - { - token = strtok(NULL, " "); - startGridEnvelop = atof(token); - if (startGridEnvelop < 0 ) { cout << "*** Error: Negative START PSF Env. "; exit(1);} - token = strtok(NULL, " "); - endGridEnvelop = atof(token); - if (endGridEnvelop < 0 ) { cout << "*** Error: Negative END PSF Env. "; exit(1);} - token = strtok(NULL, " "); - numberGridPointsEnvelop=int(atoi(token)); - if (numberGridPointsEnvelop < 0 ) { cout << "*** Error: Negative Number of grid points PSF Env. "; exit(1);} - cout << "Grid PSF Envelope: " << startGridEnvelop << " " << endGridEnvelop <<" " << numberGridPointsEnvelop << "\n"; - if(startGridEnvelop > endGridEnvelop){ cout << "Error: Grid ill defined END > START\n"; exit(1);}; - yesPSFenv = true; - } - else if (strcmp(token,"PSF_PHASE")==0) - { - token = strtok(NULL, " "); - startGridCTF_phase = atof(token); - if (startGridCTF_phase < 0 ) { cout << "*** Error: Negative START Amplitud "; exit(1);} - token = strtok(NULL, " "); - endGridCTF_phase = atof(token); - if (endGridCTF_phase < 0 ) { cout << "*** Error: Negative END Amplitud"; exit(1);} - token = strtok(NULL, " "); - numberGridPointsCTF_phase= int(atoi(token)); - if (numberGridPointsCTF_phase< 0 ) { cout << "*** Error: Negative Number of grid points amplitud "; exit(1);} - cout << "Grid PSF phase: " << startGridCTF_phase << " " << endGridCTF_phase <<" " << numberGridPointsCTF_phase << "\n"; - if(startGridCTF_phase > endGridCTF_phase){ cout << "Error: Grid ill defined END > START\n"; exit(1);}; - yesPSFpha = true; - } - else if (strcmp(token, "DISPLACE_CENTER") == 0) - { - token = strtok(NULL, " "); - param_device.maxDisplaceCenter = int(atoi(token)); - if (param_device.maxDisplaceCenter < 0 ) { cout << "*** Error: Negative MAX_D_CENTER "; exit(1);} - cout << "Maximum displacement Center " << param_device.maxDisplaceCenter << "\n"; - token = strtok(NULL, " "); - param_device.GridSpaceCenter = int(atoi(token)); - if (param_device.GridSpaceCenter < 0 ) { cout << "*** Error: Negative PIXEL_GRID_CENTER "; exit(1);} - cout << "Grid space displacement center " << param_device.GridSpaceCenter << "\n"; - yesMDC = true; - } - else if (strcmp(token, "WRITE_PROB_ANGLES") == 0) //Key word if writing down each angle probabilities - { - param_device.writeAngles = true; - cout << "Writing Probabilies of each angle \n"; - } - else if (strcmp(token, "WRITE_CROSSCOR") == 0)//Key word if writing down full micrograph cross correlation - { - param_device.writeCC = true; - param_device.CCdisplace=10; - cout << "Writing CrossCorrelations every 10 pixels\n"; - } - else if (strcmp(token, "#CROSSCOR_GRID_SPACE") == 0) - { - token = strtok(NULL, " "); - param_device.CCdisplace=int(atoi(token)); - if (param_device.CCdisplace < 0 ) { cout << "*** Error: Negative CROSSCOR_DISPLACE "; exit(1);} - cout << "Writing Cross Correlation Displacement " << param_device.CCdisplace << " \n"; - } - else if (strcmp(token, "CROSSCOR_NOTBAYESIAN") == 0) - { - param_device.CCwithBayes=false; - cout << "Not using Bayesian Analysis to write Cross Correlation \n"; - } - else if (strcmp(token, "FLIPPED") == 0) //Key word if images are flipped for cross-correlation - { - param_device.flipped = true; - cout << "Micrograph Flipped Intensities \n"; - } - else if (strcmp(token, "IGNORE_CROSSCORR_OFFSET") == 0) //Key word if images are flipped for cross-correlation - { - ignoreCCoff = true; - cout << "Ignoring Cross-Correlation offset \n"; - } - else if (strcmp(token, "IGNORE_PDB") == 0) //Ignore PDB extension - { - ignorePDB = true; - cout << "Ignoring PDB extension in model file \n"; - } - else if (strcmp(token, "NO_PROJECT_RADIUS") == 0) //If projecting CA with amino-acid radius - { - doaaradius = false; - cout << "Not Projecting corresponding radius \n"; - } - else if (strcmp(token, "DEBUG_INDI_PROB_TERM") == 0)//writing out each term of the probability - { - param_device.debugterm = true; - cout << "Debugging Individual Probability Terms \n"; - } - else if (strcmp(token, "WRITE_CTF_PARAM") == 0)//Number of Euler angle tripplets in non uniform Euler angle sampling - { - writeCTF=true; - token = strtok(NULL," "); - cout << "Writing CTF parameters from PSF parameters that maximize the posterior. \n"; - } - else if (strcmp(token, "NO_CENTEROFMASS") == 0)//Number of Euler angle tripplets in non uniform Euler angle sampling - { - nocentermass=true; - cout << "BE CAREFUL CENTER OF MASS IS NOT REMOVED \n Calculated images might be out of range \n"; - } - else if (strcmp(token, "PRINT_ROTATED_MODELS") == 0)//Number of Euler angle tripplets in non uniform Euler angle sampling - { - printrotmod=true; - cout << "PRINTING out rotatted models (best for debugging)\n"; - } - else if (strcmp(token, "NO_MAP_NORM") == 0) - { - notnormmap=true; - cout << "NOT NORMALIZING MAP\n" ; - } - else if (strcmp(token, "PRIOR_MODEL") == 0) - { - token = strtok(NULL, " "); - priorMod = atof(token); - cout << "MODEL PRIOR Probability " << priorMod << "\n" ; - } - else if (strcmp(token, "PRIOR_ANGLES") == 0) - { - yespriorAngles=true; - cout << "READING Priors for Orientations in additonal orientation file\n" ; - } - else if (strcmp(token, "SHIFT_X") == 0) - { - token = strtok(NULL, " "); - shiftX=atoi(token); - cout << "Shifting initial model X by "<< shiftX << "\n" ; - } - else if (strcmp(token, "SHIFT_Y") == 0) - { - token = strtok(NULL, " "); - shiftY=atoi(token); - cout << "Shifting initial model Y by "<< shiftY << "\n" ; - } - else if (strcmp(token, "SIGMA_PRIOR_B_CTF") == 0) - { - token = strtok(NULL, " "); - param_device.sigmaPriorbctf=atof(token); - cout << "Chainging Gaussian width in Prior of Envelope b parameter: " << param_device.sigmaPriorbctf << "\n"; - } - else if (strcmp(token, "SIGMA_PRIOR_DEFOCUS") == 0) - { - token = strtok(NULL, " "); - param_device.sigmaPriordefo=atof(token); - cout << "Gaussian Width in Prior of defocus parameter: " << param_device.sigmaPriordefo << "\n"; - } - else if (strcmp(token, "PRIOR_DEFOCUS_CENTER") == 0) - { - token = strtok(NULL, " "); - param_device.Priordefcent=atof(token); - cout << "Gaussian Center in Prior of defocus parameter: " << param_device.Priordefcent << "\n"; - } - else if (strcmp(token, "IGNORE_POINTSOUT") == 0) - { - ignorepointsout=true; - cout << "Ignoring model points outside the map\n" ; - } - else if (strcmp(token, "PRINT_ROTATED_MODELS") == 0)//Number of Euler angle tripplets in non uniform Euler angle sampling - { - printrotmod=true; - cout << "PRINTING out rotatted models (best for debugging)\n"; - } + while (!input.eof()) + { + input.getline(line, 512); + strcpy(saveline, line); + char *token = strtok(line, " "); + if (token == NULL || line[0] == '#' || strlen(token) == 0) + { + // comment or blank line + } + else if (strcmp(token, "PIXEL_SIZE") == 0) + { + token = strtok(NULL, " "); + pixelSize = atof(token); + if (pixelSize < 0) + { + cout << "*** Error: Negative pixelSize "; + exit(1); + } + cout << "Pixel Sixe " << pixelSize << "\n"; + yesPixSi = true; + } + else if (strcmp(token, "NUMBER_PIXELS") == 0) + { + token = strtok(NULL, " "); + param_device.NumberPixels = int(atoi(token)); + if (param_device.NumberPixels < 0) + { + cout << "*** Error: Negative Number of Pixels "; + exit(1); + } + cout << "Number of Pixels " << param_device.NumberPixels << "\n"; + yesNumPix = true; + } + else if (strcmp(token, "GRIDPOINTS_ALPHA") == 0) + { + token = strtok(NULL, " "); + angleGridPointsAlpha = int(atoi(token)); + if (angleGridPointsAlpha < 0) + { + cout << "*** Error: Negative GRIDPOINTS_ALPHA "; + exit(1); + } + cout << "Grid points alpha " << angleGridPointsAlpha << "\n"; + yesGPal = true; + } + else if (strcmp(token, "GRIDPOINTS_BETA") == 0) + { + token = strtok(NULL, " "); + angleGridPointsBeta = int(atoi(token)); + if (angleGridPointsBeta < 0) + { + cout << "*** Error: Negative GRIDPOINTS_BETA "; + exit(1); + } + cout << "Grid points in Cosine ( beta ) " << angleGridPointsBeta << "\n"; + yesGPbe = true; + } + else if (strcmp(token, "USE_QUATERNIONS") == 0) + // else if (token=="USE_QUATERNIONS") + { + cout << "Orientations with Quaternions. \n"; + doquater = true; + } + else if (strcmp(token, "GRIDPOINTS_QUATERNION") == 0) + { + if (!notuniformangles) + { + token = strtok(NULL, " "); + GridPointsQuatern = int(atoi(token)); + cout << "Gridpoints Quaternions " << GridPointsQuatern << "\n"; + } + else + { + cout << "Inconsitent Input: Grid or List with Quaternions?\n"; + exit(1); + } + yesquatgrid = true; + doquater = true; + } + // CTF PARAMETERS + else if (strcmp(token, "CTF_B_ENV") == 0) + { + token = strtok(NULL, " "); + startBfactor = atof(token); + if (startBfactor < 0) + { + cout << "*** Error: Negative START B Env "; + exit(1); + } + token = strtok(NULL, " "); + endBfactor = atof(token); + if (endBfactor < 0) + { + cout << "*** Error: Negative END B Env "; + exit(1); + } + token = strtok(NULL, " "); + numberGridPointsEnvelop = int(atoi(token)); + if (numberGridPointsEnvelop < 0) + { + cout << "*** Error: Negative Number of Grid points BEnv "; + exit(1); + } + cout << "Grid CTF B-ENV: " << startBfactor << " " << endBfactor << " " + << numberGridPointsEnvelop << "\n"; + if (startBfactor > endBfactor) + { + cout << "Error: Grid ill defined END > START\n"; + exit(1); + }; + yesBFact = true; + } + else if (strcmp(token, "CTF_DEFOCUS") == 0) + { + token = strtok(NULL, " "); + startDefocus = atof(token); + if (startDefocus < 0) + { + cout << "*** Error: Negative START Defocus "; + exit(1); + } + token = strtok(NULL, " "); + endDefocus = atof(token); + if (endDefocus < 0) + { + cout << "*** Error: Negative END Defocus "; + exit(1); + } + token = strtok(NULL, " "); + numberGridPointsCTF_phase = int(atoi(token)); + if (numberGridPointsCTF_phase < 0) + { + cout << "*** Error: Negative Number of Grid points Defocus "; + exit(1); + } + cout << "Grid CTF Defocus: " << startDefocus << " " << endDefocus << " " + << numberGridPointsCTF_phase << "\n"; + if (startDefocus > endDefocus) + { + cout << "Error: Grid ill defined END > START\n"; + exit(1); + }; + if (endDefocus > 8.) + { + cout << "Defocus beyond 8micro-m range is not allowed \n"; + exit(1); + } + yesDefocus = true; + } + else if (strcmp(token, "CTF_AMPLITUDE") == 0) + { + token = strtok(NULL, " "); + startGridCTF_amp = atof(token); + if (startGridCTF_amp < 0) + { + cout << "*** Error: Negative START Amplitude "; + exit(1); + } + token = strtok(NULL, " "); + endGridCTF_amp = atof(token); + if (endGridCTF_amp < 0) + { + cout << "*** Error: Negative END Amplitude"; + exit(1); + } + token = strtok(NULL, " "); + numberGridPointsCTF_amp = int(atoi(token)); + if (numberGridPointsCTF_amp < 0) + { + cout << "*** Error: Negative Number of grid points amplitude "; + exit(1); + } + cout << "Grid Amplitude: " << startGridCTF_amp << " " << endGridCTF_amp + << " " << numberGridPointsCTF_amp << "\n"; + if (startGridCTF_amp > endGridCTF_amp) + { + cout << "Error: Grid ill defined END > START\n"; + exit(1); + }; + yesAMP = true; + } + else if (strcmp(token, "ELECTRON_WAVELENGTH") == 0) + { + token = strtok(NULL, " "); + elecwavel = atof(token); + if (elecwavel < 0.0150) + { + cout << "Wrong electron wave length " << elecwavel << "\n"; + cout << "Has to be in Angstrom (A)\n"; + exit(1); + } + cout << "Electron wave length in (A) is: " << elecwavel << "\n"; + } + // PSF PARAMETERS + else if (strcmp(token, "USE_PSF") == 0) + { + usepsf = true; + param_device.tousepsf = true; + cout << "IMPORTANT: Using Point Spread Function. Thus, all parameters " + "are in Real Space. \n"; + } + else if (strcmp(token, "PSF_AMPLITUDE") == 0) + { + token = strtok(NULL, " "); + startGridCTF_amp = atof(token); + if (startGridCTF_amp < 0) + { + cout << "*** Error: Negative START Amplitude "; + exit(1); + } + token = strtok(NULL, " "); + endGridCTF_amp = atof(token); + if (endGridCTF_amp < 0) + { + cout << "*** Error: Negative END Amplitude"; + exit(1); + } + token = strtok(NULL, " "); + numberGridPointsCTF_amp = int(atoi(token)); + if (numberGridPointsCTF_amp < 0) + { + cout << "*** Error: Negative Number of grid points amplitude "; + exit(1); + } + cout << "Grid Amplitude: " << startGridCTF_amp << " " << endGridCTF_amp + << " " << numberGridPointsCTF_amp << "\n"; + if (startGridCTF_amp > endGridCTF_amp) + { + cout << "Error: Grid ill defined END > START\n"; + exit(1); + }; + yesAMP = true; + } + else if (strcmp(token, "PSF_ENVELOPE") == 0) + { + token = strtok(NULL, " "); + startGridEnvelop = atof(token); + if (startGridEnvelop < 0) + { + cout << "*** Error: Negative START PSF Env. "; + exit(1); + } + token = strtok(NULL, " "); + endGridEnvelop = atof(token); + if (endGridEnvelop < 0) + { + cout << "*** Error: Negative END PSF Env. "; + exit(1); + } + token = strtok(NULL, " "); + numberGridPointsEnvelop = int(atoi(token)); + if (numberGridPointsEnvelop < 0) + { + cout << "*** Error: Negative Number of grid points PSF Env. "; + exit(1); + } + cout << "Grid PSF Envelope: " << startGridEnvelop << " " << endGridEnvelop + << " " << numberGridPointsEnvelop << "\n"; + if (startGridEnvelop > endGridEnvelop) + { + cout << "Error: Grid ill defined END > START\n"; + exit(1); + }; + yesPSFenv = true; + } + else if (strcmp(token, "PSF_PHASE") == 0) + { + token = strtok(NULL, " "); + startGridCTF_phase = atof(token); + if (startGridCTF_phase < 0) + { + cout << "*** Error: Negative START Amplitud "; + exit(1); + } + token = strtok(NULL, " "); + endGridCTF_phase = atof(token); + if (endGridCTF_phase < 0) + { + cout << "*** Error: Negative END Amplitud"; + exit(1); + } + token = strtok(NULL, " "); + numberGridPointsCTF_phase = int(atoi(token)); + if (numberGridPointsCTF_phase < 0) + { + cout << "*** Error: Negative Number of grid points amplitud "; + exit(1); + } + cout << "Grid PSF phase: " << startGridCTF_phase << " " + << endGridCTF_phase << " " << numberGridPointsCTF_phase << "\n"; + if (startGridCTF_phase > endGridCTF_phase) + { + cout << "Error: Grid ill defined END > START\n"; + exit(1); + }; + yesPSFpha = true; + } + else if (strcmp(token, "DISPLACE_CENTER") == 0) + { + token = strtok(NULL, " "); + param_device.maxDisplaceCenter = int(atoi(token)); + if (param_device.maxDisplaceCenter < 0) + { + cout << "*** Error: Negative MAX_D_CENTER "; + exit(1); + } + cout << "Maximum displacement Center " << param_device.maxDisplaceCenter + << "\n"; + token = strtok(NULL, " "); + param_device.GridSpaceCenter = int(atoi(token)); + if (param_device.GridSpaceCenter < 0) + { + cout << "*** Error: Negative PIXEL_GRID_CENTER "; + exit(1); + } + cout << "Grid space displacement center " << param_device.GridSpaceCenter + << "\n"; + yesMDC = true; + } + else if (strcmp(token, "WRITE_PROB_ANGLES") == + 0) // Key word if writing down each angle probabilities + { + token = strtok(NULL, " "); + param_device.writeAngles = int(atoi(token)); + if (param_device.writeAngles < 0) + { + cout << "*** Error: Negative WRITE_PROB_ANGLES "; + exit(1); + } + cout << "Writing " << param_device.writeAngles + << " Probabilies of each angle \n"; + } + else if (strcmp(token, "IGNORE_PDB") == 0) // Ignore PDB extension + { + ignorePDB = true; + cout << "Ignoring PDB extension in model file \n"; + } + else if (strcmp(token, "NO_PROJECT_RADIUS") == + 0) // If projecting CA with amino-acid radius + { + doaaradius = false; + cout << "Not Projecting corresponding radius \n"; + } + else if (strcmp(token, "WRITE_CTF_PARAM") == 0) // Number of Euler angle + // tripplets in non uniform + // Euler angle sampling + { + writeCTF = true; + token = strtok(NULL, " "); + cout << "Writing CTF parameters from PSF parameters that maximize the " + "posterior. \n"; + } + else if (strcmp(token, "NO_CENTEROFMASS") == 0) // Number of Euler angle + // tripplets in non uniform + // Euler angle sampling + { + nocentermass = true; + cout << "BE CAREFUL CENTER OF MASS IS NOT REMOVED \n Calculated images " + "might be out of range \n"; + } + else if (strcmp(token, "PRINT_ROTATED_MODELS") == 0) // Number of Euler + // angle tripplets in + // non uniform Euler + // angle sampling + { + printrotmod = true; + cout << "PRINTING out rotatted models (best for debugging)\n"; + } + else if (strcmp(token, "NO_MAP_NORM") == 0) + { + notnormmap = true; + cout << "NOT NORMALIZING MAP\n"; + } + else if (strcmp(token, "PRIOR_MODEL") == 0) + { + token = strtok(NULL, " "); + priorMod = atof(token); + cout << "MODEL PRIOR Probability " << priorMod << "\n"; + } + else if (strcmp(token, "PRIOR_ANGLES") == 0) + { + yespriorAngles = true; + cout << "READING Priors for Orientations in additonal orientation file\n"; + } + else if (strcmp(token, "SHIFT_X") == 0) + { + token = strtok(NULL, " "); + shiftX = atoi(token); + cout << "Shifting initial model X by " << shiftX << "\n"; + } + else if (strcmp(token, "SHIFT_Y") == 0) + { + token = strtok(NULL, " "); + shiftY = atoi(token); + cout << "Shifting initial model Y by " << shiftY << "\n"; + } + else if (strcmp(token, "SIGMA_PRIOR_B_CTF") == 0) + { + token = strtok(NULL, " "); + param_device.sigmaPriorbctf = atof(token); + cout << "Chainging Gaussian width in Prior of Envelope b parameter: " + << param_device.sigmaPriorbctf << "\n"; + } + else if (strcmp(token, "SIGMA_PRIOR_DEFOCUS") == 0) + { + token = strtok(NULL, " "); + param_device.sigmaPriordefo = atof(token); + cout << "Gaussian Width in Prior of defocus parameter: " + << param_device.sigmaPriordefo << "\n"; + } + else if (strcmp(token, "PRIOR_DEFOCUS_CENTER") == 0) + { + token = strtok(NULL, " "); + param_device.Priordefcent = atof(token); + cout << "Gaussian Center in Prior of defocus parameter: " + << param_device.Priordefcent << "\n"; + } + else if (strcmp(token, "SIGMA_PRIOR_AMP_CTF") == 0) + { + token = strtok(NULL, " "); + param_device.sigmaPrioramp = atof(token); + cout << "Gaussian Width in Prior of defocus parameter: " + << param_device.sigmaPriordefo << "\n"; + } + else if (strcmp(token, "PRIOR_AMP_CTF_CENTER") == 0) + { + token = strtok(NULL, " "); + param_device.Priorampcent = atof(token); + cout << "Gaussian Center in Prior of defocus parameter: " + << param_device.Priordefcent << "\n"; + } + else if (strcmp(token, "IGNORE_POINTSOUT") == 0) + { + ignorepointsout = true; + cout << "Ignoring model points outside the map\n"; + } + else if (strcmp(token, "PRINT_ROTATED_MODELS") == 0) // Number of Euler + // angle tripplets in + // non uniform Euler + // angle sampling + { + printrotmod = true; + cout << "PRINTING out rotatted models (best for debugging)\n"; } + } input.close(); //************** Checks/Controlls for INPUT - if( not ( yesPixSi ) ){ cout << "**** INPUT MISSING: Please provide PIXEL_SIZE\n" ; exit (1);}; - if( not ( yesNumPix ) ){ cout << "**** INPUT MISSING: Please provide NUMBER_PIXELS \n" ; exit (1);}; - if(!notuniformangles){ - if(!doquater){ - if( not ( yesGPal) ) { cout << "**** INPUT MISSING: Please provide GRIDPOINTS_ALPHA \n" ; exit (1);}; - if( not ( yesGPbe )) { cout << "**** INPUT MISSING: Please provide GRIDPOINTS_BETA \n" ; exit (1);}; - }else if (!yesquatgrid){ - cout << "**** INPUT MISSING: Please provide GRIDPOINTS_QUATERNION \n" ; exit (1); + if (not(yesPixSi)) + { + cout << "**** INPUT MISSING: Please provide PIXEL_SIZE\n"; + exit(1); + }; + if (not(yesNumPix)) + { + + cout << "**** INPUT MISSING: Please provide NUMBER_PIXELS \n"; + exit(1); + }; + if (!notuniformangles) + { + if (!doquater) + { + if (not(yesGPal)) + { + cout << "**** INPUT MISSING: Please provide GRIDPOINTS_ALPHA \n"; + exit(1); + }; + if (not(yesGPbe)) + { + cout << "**** INPUT MISSING: Please provide GRIDPOINTS_BETA \n"; + exit(1); + }; + } + else if (!yesquatgrid) + { + cout << "**** INPUT MISSING: Please provide GRIDPOINTS_QUATERNION \n"; + exit(1); } } - if( not ( yesMDC ) ) { cout << "**** INPUT MISSING: Please provide GRID Displacement CENTER \n" ; exit (1);}; - if( param_device.writeCC && param_device.CCdisplace < 1 ){ cout << "**** INPUT MISSING: Please provide CROSSCOR_DISPLACE \n" ; exit (1);}; - if( param_device.writeCC) {if(!param_device.CCwithBayes ){ cout << "Remark:: Not Using Bayesian method to store Cross-Correlation.\n Only Printing out Maximum\n";} - if(param_device.flipped){ cout << "Remark:: Micrographs are Flipped = Particles are white\n";} else { cout << "Remark:: Micrographs are NOT Flipped = Particles are dark\n";} - if(param_device.writeAngles){cout << "Calculate Cross-cor and write prob angles are mutualy exclusive options\n"; exit(1);} - } - + if (not(yesMDC)) + { + cout << "**** INPUT MISSING: Please provide GRID Displacement CENTER \n"; + exit(1); + }; - cout << "To verify input of Priors:\n" ; + cout << "To verify input of Priors:\n"; cout << "Sigma Prior B-Env: " << param_device.sigmaPriorbctf << "\n"; cout << "Sigma Prior Defocus: " << param_device.sigmaPriordefo << "\n"; - cout << "Center Prior Defocus: " <1){cout << " Problem with quaternion "<< angles[0].quat4 << "\n";exit(1);} - if(angles[0].pos[0]*angles[0].pos[0]>1){cout << " Problem with quaternion "<< angles[0].pos[0] << "\n";exit(1);} - if(angles[0].pos[1]*angles[0].pos[1]>1){cout << " Problem with quaternion "<< angles[0].pos[1] << "\n";exit(1);} - if(angles[0].pos[2]*angles[0].pos[2]>1){cout << " Problem with quaternion "<< angles[0].pos[2] << "\n";exit(1);} - } + if (doquater) + { + if (angles[0].quat4 * angles[0].quat4 > 1) + { + cout << " Problem with quaternion " << angles[0].quat4 << "\n"; + exit(1); + } + if (angles[0].pos[0] * angles[0].pos[0] > 1) + { + cout << " Problem with quaternion " << angles[0].pos[0] << "\n"; + exit(1); + } + if (angles[0].pos[1] * angles[0].pos[1] > 1) + { + cout << " Problem with quaternion " << angles[0].pos[1] << "\n"; + exit(1); + } + if (angles[0].pos[2] * angles[0].pos[2] > 1) + { + cout << " Problem with quaternion " << angles[0].pos[2] << "\n"; + exit(1); + } + } input.close(); - if(usepsf && ctfparam){ - cout << "Inconsitent Input: Using both PSF and CTF ?\n"; exit(1); + if (usepsf && ctfparam) + { + cout << "Inconsitent Input: Using both PSF and CTF ?\n"; + exit(1); } - //Automatic definitions - numberGridPointsCTF_amp = 1 ; + // Automatic definitions + numberGridPointsCTF_amp = 1; gridCTF_amp = startGridCTF_amp; numberGridPointsCTF_phase = 1; gridCTF_phase = startGridCTF_phase; - numberGridPointsEnvelop = 1 ; + numberGridPointsEnvelop = 1; gridEnvelop = startGridEnvelop; - doquater=false; + // doquater = false; param_device.NumberFFTPixels1D = param_device.NumberPixels / 2 + 1; FFTMapSize = param_device.NumberPixels * param_device.NumberFFTPixels1D; - return 0; + nTotParallelMaps = CUDA_FFTS_AT_ONCE; + return 0; } void bioem_param::PrepareFFTs() { //********** PREPARING THE PLANS FOR THE FFTS ****************** - if (mpi_rank == 0) cout << "Preparing FFTs\n"; + if (mpi_rank == 0) + cout << "Preparing FFTs\n"; releaseFFTPlans(); mycomplex_t *tmp_map, *tmp_map2; - tmp_map = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param_device.NumberPixels * param_device.NumberPixels); - tmp_map2 = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param_device.NumberPixels * param_device.NumberPixels); + tmp_map = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * + param_device.NumberPixels * + param_device.NumberPixels); + tmp_map2 = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * + param_device.NumberPixels * + param_device.NumberPixels); Alignment = 64; - fft_plan_c2c_forward = myfftw_plan_dft_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, FFTW_FORWARD, FFTW_MEASURE | FFTW_DESTROY_INPUT); - fft_plan_c2c_backward = myfftw_plan_dft_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, FFTW_BACKWARD, FFTW_MEASURE | FFTW_DESTROY_INPUT); - fft_plan_r2c_forward = myfftw_plan_dft_r2c_2d(param_device.NumberPixels, param_device.NumberPixels, (myfloat_t*) tmp_map, tmp_map2, FFTW_MEASURE | FFTW_DESTROY_INPUT); - fft_plan_c2r_backward = myfftw_plan_dft_c2r_2d(param_device.NumberPixels, param_device.NumberPixels, tmp_map, (myfloat_t*) tmp_map2, FFTW_MEASURE | FFTW_DESTROY_INPUT); - - if (fft_plan_c2c_forward == 0 || fft_plan_c2c_backward == 0 || fft_plan_r2c_forward == 0 || fft_plan_c2r_backward == 0) - { - cout << "Error planing FFTs\n"; - exit(1); - } + fft_plan_c2c_forward = myfftw_plan_dft_2d( + param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, + FFTW_FORWARD, FFTW_MEASURE | FFTW_DESTROY_INPUT); + fft_plan_c2c_backward = myfftw_plan_dft_2d( + param_device.NumberPixels, param_device.NumberPixels, tmp_map, tmp_map2, + FFTW_BACKWARD, FFTW_MEASURE | FFTW_DESTROY_INPUT); + fft_plan_r2c_forward = myfftw_plan_dft_r2c_2d( + param_device.NumberPixels, param_device.NumberPixels, + (myfloat_t *) tmp_map, tmp_map2, FFTW_MEASURE | FFTW_DESTROY_INPUT); + fft_plan_c2r_backward = myfftw_plan_dft_c2r_2d( + param_device.NumberPixels, param_device.NumberPixels, tmp_map, + (myfloat_t *) tmp_map2, FFTW_MEASURE | FFTW_DESTROY_INPUT); + + if (fft_plan_c2c_forward == 0 || fft_plan_c2c_backward == 0 || + fft_plan_r2c_forward == 0 || fft_plan_c2r_backward == 0) + { + cout << "Error planing FFTs\n"; + exit(1); + } myfftw_free(tmp_map); myfftw_free(tmp_map2); const int count = omp_get_max_threads(); - fft_scratch_complex = new mycomplex_t*[count]; - fft_scratch_real = new myfloat_t*[count]; + fft_scratch_complex = new mycomplex_t *[count]; + fft_scratch_real = new myfloat_t *[count]; #pragma omp parallel { #pragma omp critical { const int i = omp_get_thread_num(); - fft_scratch_complex[i] = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param_device.NumberPixels * param_device.NumberFFTPixels1D); - fft_scratch_real[i] = (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) * param_device.NumberPixels * param_device.NumberPixels); + fft_scratch_complex[i] = (mycomplex_t *) myfftw_malloc( + sizeof(mycomplex_t) * param_device.NumberPixels * + param_device.NumberFFTPixels1D); + fft_scratch_real[i] = (myfloat_t *) myfftw_malloc( + sizeof(myfloat_t) * param_device.NumberPixels * + param_device.NumberPixels); } } fft_plans_created = 1; } - void bioem_param::releaseFFTPlans() { if (fft_plans_created) + { + const int count = omp_get_max_threads(); + for (int i = 0; i < count; i++) { - const int count = omp_get_max_threads(); - for (int i = 0;i < count;i++) - { - myfftw_free(fft_scratch_complex[i]); - myfftw_free(fft_scratch_real[i]); - } - delete[] fft_scratch_complex; - delete[] fft_scratch_real; - - myfftw_destroy_plan(fft_plan_c2c_forward); - myfftw_destroy_plan(fft_plan_c2c_backward); - myfftw_destroy_plan(fft_plan_r2c_forward); - myfftw_destroy_plan(fft_plan_c2r_backward); - myfftw_cleanup(); + myfftw_free(fft_scratch_complex[i]); + myfftw_free(fft_scratch_real[i]); } + delete[] fft_scratch_complex; + delete[] fft_scratch_real; + + myfftw_destroy_plan(fft_plan_c2c_forward); + myfftw_destroy_plan(fft_plan_c2c_backward); + myfftw_destroy_plan(fft_plan_r2c_forward); + myfftw_destroy_plan(fft_plan_c2r_backward); + myfftw_cleanup(); + } fft_plans_created = 0; } -int bioem_param::CalculateGridsParam(const char* fileangles) //TO DO FOR QUATERNIONS +int bioem_param::CalculateGridsParam( + const char *fileangles) // TO DO FOR QUATERNIONS { // ************************************************************************************** - // **************** Routine that pre-calculates Orientation Grids********************** + // **************** Routine that pre-calculates Orientation + // Grids********************** // ************************************************************************************ - - if(!doquater){ + if (!doquater) + { //*********** With Euler angles ******************* cout << "Analysis Using Default Euler Angles\n"; - if(!notuniformangles){ + if (!notuniformangles) + { - if(yespriorAngles){ - cout << "Error: This option is not valid with prior for orientations\nPlease provide separate file with orientations and priors"; - exit(1); + if (yespriorAngles) + { + cout << "Error: This option is not valid with prior for " + "orientations\nPlease provide separate file with orientations " + "and priors"; + exit(1); } - + cout << "Calculating Grids in Euler Angles\n"; - + myfloat_t grid_alpha, cos_grid_beta; int n = 0; - //alpha and gamma are uniform in -PI,PI + // alpha and gamma are uniform in -PI,PI grid_alpha = 2.f * M_PI / (myfloat_t) angleGridPointsAlpha; - //cosine beta is uniform in -1,1 + // cosine beta is uniform in -1,1 cos_grid_beta = 2.f / (myfloat_t) angleGridPointsBeta; // Euler Angle Array - angles = (myfloat3_t*) mallocchk( angleGridPointsAlpha * angleGridPointsBeta * angleGridPointsAlpha * sizeof(myfloat3_t)); - - - for (int ialpha = 0; ialpha < angleGridPointsAlpha; ialpha ++) - { - for (int ibeta = 0; ibeta < angleGridPointsBeta; ibeta ++) - { - for (int igamma = 0; igamma < angleGridPointsAlpha; igamma ++) - { - angles[n].pos[0] = (myfloat_t) ialpha * grid_alpha - M_PI + grid_alpha * 0.5f; //ALPHA centered in the middle - angles[n].pos[1] = acos((myfloat_t) ibeta * cos_grid_beta - 1 + cos_grid_beta * 0.5f); //BETA centered in the middle - angles[n].pos[2] = (myfloat_t) igamma * grid_alpha - M_PI + grid_alpha * 0.5f; //GAMMA centered in the middle - angles[n].quat4 =0.0; - n++; - } - } - } - nTotGridAngles = n; - voluang= grid_alpha * grid_alpha * cos_grid_beta / (2.f * M_PI) / (2.f * M_PI) / 2.f * priorMod; + angles = + (myfloat3_t *) mallocchk(angleGridPointsAlpha * angleGridPointsBeta * + angleGridPointsAlpha * sizeof(myfloat3_t)); - } else{ + for (int ialpha = 0; ialpha < angleGridPointsAlpha; ialpha++) + { + for (int ibeta = 0; ibeta < angleGridPointsBeta; ibeta++) + { + for (int igamma = 0; igamma < angleGridPointsAlpha; igamma++) + { + angles[n].pos[0] = + (myfloat_t) ialpha * grid_alpha - M_PI + + grid_alpha * 0.5f; // ALPHA centered in the middle + angles[n].pos[1] = + acos((myfloat_t) ibeta * cos_grid_beta - 1 + + cos_grid_beta * 0.5f); // BETA centered in the middle + angles[n].pos[2] = + (myfloat_t) igamma * grid_alpha - M_PI + + grid_alpha * 0.5f; // GAMMA centered in the middle + angles[n].quat4 = 0.0; + n++; + } + } + } + nTotGridAngles = n; + voluang = grid_alpha * grid_alpha * cos_grid_beta / (2.f * M_PI) / + (2.f * M_PI) / 2.f * priorMod; + } + else + { - //************ Reading Euler Angles From File ************************** + //************ Reading Euler Angles From File ************************** ifstream input(fileangles); if (!input.good()) - { - cout << "Euler Angle File Failed to open file " << fileangles << " " << endl ; - exit(1); - } + { + cout << "Euler Angle File Failed to open file " << fileangles << " " + << endl; + exit(1); + } char line[512] = {0}; // char saveline[512]; - int n=0; + int n = 0; // First line tels the number of rows input.getline(line, 511); - char tmpVals[36] = {0}; + char tmpVals[36] = {0}; - strncpy (tmpVals, line, 12); - sscanf (tmpVals, "%d", &NotUn_angles); + strncpy(tmpVals, line, 12); + sscanf(tmpVals, "%d", &NotUn_angles); cout << "Number of Euler angles " << NotUn_angles << "\n"; - - if(NotUn_angles<1) { - cout << "\nNot defined number of Euler angles in INPUT file:" << endl ; - // cout << "Use key word: NOT_UNIFORM_TOTAL_ANGS\n"; - exit(1); + if (NotUn_angles < 1) + { + cout << "\nNot defined number of Euler angles in INPUT file:" << endl; + // cout << "Use key word: NOT_UNIFORM_TOTAL_ANGS\n"; + exit(1); } // NotUn_angles=NotUn_angles+1; + angles = (myfloat3_t *) mallocchk(NotUn_angles * sizeof(myfloat3_t)); - angles = (myfloat3_t*) mallocchk( NotUn_angles * sizeof(myfloat3_t)); - - if(yespriorAngles){ - delete[] angprior; - angprior = new myfloat_t[NotUn_angles]; + if (yespriorAngles) + { + delete[] angprior; + angprior = new myfloat_t[NotUn_angles]; } while (!input.eof()) - { + { + + input.getline(line, 511); + + if (n < NotUn_angles) + { - input.getline(line, 511); + float a = 0., b = 0., g = 0., pp = 0.; - if(n< NotUn_angles){ + char tmpVals[60] = {0}; - float a=0.,b=0.,g=0.,pp=0.; - - char tmpVals[60] = {0}; + strncpy(tmpVals, line, 12); + sscanf(tmpVals, "%f", &a); - strncpy (tmpVals, line, 12); - sscanf (tmpVals, "%f", &a); + strncpy(tmpVals, line + 12, 12); + sscanf(tmpVals, "%f", &b); - strncpy (tmpVals, line + 12, 12); - sscanf (tmpVals, "%f", &b); + strncpy(tmpVals, line + 24, 12); + sscanf(tmpVals, "%f", &g); - strncpy (tmpVals, line + 24, 12); - sscanf (tmpVals, "%f", &g); + if (yespriorAngles) + { + strncpy(tmpVals, line + 36, 12); + sscanf(tmpVals, "%f", &pp); + if (pp < 0.0000001) + cout << "Sure you're input is correct? Very small prior.\n"; + angprior[n] = (myfloat_t) pp; + } - if(yespriorAngles){ - strncpy (tmpVals, line + 36, 12); - sscanf (tmpVals, "%f", &pp); - if(pp <0.0000001)cout << "Sure you're input is correct? Very small prior.\n"; - angprior[n] = (myfloat_t) pp; - } - - angles[n].pos[0] = (myfloat_t) a; - angles[n].pos[1] = (myfloat_t) b; - angles[n].pos[2] = (myfloat_t) g; - angles[n].quat4 =0.0;//just to be sure */ + angles[n].pos[0] = (myfloat_t) a; + angles[n].pos[1] = (myfloat_t) b; + angles[n].pos[2] = (myfloat_t) g; + angles[n].quat4 = 0.0; // just to be sure */ #ifdef DEBUG -// if(yespriorAngles) -cout << "check orient: " << n << " " << " " << angles[n].pos[0] << " " << angles[n].pos[1] << " " << angles[n].pos[2] << " prior:\n ";// << angprior[n]<< "\n"; + // if(yespriorAngles) + cout << "check orient: " << n << " " + << " " << angles[n].pos[0] << " " << angles[n].pos[1] << " " + << angles[n].pos[2] << " prior:\n "; // << angprior[n]<< "\n"; #endif - } - n++; - if(NotUn_angles+1 < n) { - cout << "Not properly defined total Euler angles " << n << " instead of " << NotUn_angles << "\n"; - exit(1); - } - } + } + n++; + if (NotUn_angles + 1 < n) + { + cout << "Not properly defined total Euler angles " << n + << " instead of " << NotUn_angles << "\n"; + exit(1); + } + } nTotGridAngles = NotUn_angles; - voluang= 1./ (myfloat_t) NotUn_angles * priorMod; + voluang = 1. / (myfloat_t) NotUn_angles * priorMod; input.close(); } - - } else { + } + else + { //************** Analysis with Quaternions - if(!notuniformangles){ + if (!notuniformangles) + { //************* Grid of Quaternions ******************* cout << "Calculating Grids in Quaterions\n "; - if(yespriorAngles){ - cout << "This option is not valid with prior for orientations\n It is necessary to provide a separate file with the angles and priors"; - exit(1); + if (yespriorAngles) + { + cout << "This option is not valid with prior for orientations\n It is " + "necessary to provide a separate file with the angles and " + "priors"; + exit(1); } - if (GridPointsQuatern < 0 ) { cout << "*** Missing Gridpoints Quaternions \n after QUATERNIONS (int)\n (int)=Number of gridpoins per dimension"; exit(1);} + if (GridPointsQuatern < 0) + { + cout << "*** Missing Gridpoints Quaternions \n after QUATERNIONS " + "(int)\n (int)=Number of gridpoins per dimension"; + exit(1); + } - myfloat_t dgridq,q1,q2,q3; - int n=0; + myfloat_t dgridq, q1, q2, q3; + int n = 0; - dgridq=2.f/(myfloat_t) (GridPointsQuatern +1); + dgridq = 2.f / (myfloat_t)(GridPointsQuatern + 1); // loop to calculate the number ofpoints in the quaternion shpere rad < 1 - for (int ialpha = 0; ialpha < GridPointsQuatern + 1 ; ialpha ++) - { - q1=(myfloat_t) ialpha * dgridq -1.f + 0.5 * dgridq; - for (int ibeta = 0; ibeta < GridPointsQuatern + 1 ; ibeta ++) - { - q2=(myfloat_t) ibeta * dgridq -1.f + 0.5 * dgridq; - for (int igamma = 0; igamma < GridPointsQuatern + 1; igamma ++) - { - q3= (myfloat_t) igamma * dgridq -1.f + 0.5 * dgridq; - if(q1*q1+q2*q2+q3*q3 <= 1.f)n=n+2; - - } - } - } - - //allocating angles + for (int ialpha = 0; ialpha < GridPointsQuatern + 1; ialpha++) + { + q1 = (myfloat_t) ialpha * dgridq - 1.f + 0.5 * dgridq; + for (int ibeta = 0; ibeta < GridPointsQuatern + 1; ibeta++) + { + q2 = (myfloat_t) ibeta * dgridq - 1.f + 0.5 * dgridq; + for (int igamma = 0; igamma < GridPointsQuatern + 1; igamma++) + { + q3 = (myfloat_t) igamma * dgridq - 1.f + 0.5 * dgridq; + if (q1 * q1 + q2 * q2 + q3 * q3 <= 1.f) + n = n + 2; + } + } + } + + // allocating angles nTotGridAngles = n; - angles = (myfloat3_t*) mallocchk( nTotGridAngles * sizeof(myfloat3_t)); - - voluang= dgridq * dgridq * dgridq * priorMod; + angles = (myfloat3_t *) mallocchk(nTotGridAngles * sizeof(myfloat3_t)); + + voluang = dgridq * dgridq * dgridq * priorMod; - n=0; + n = 0; // assigning values - for (int ialpha = 0; ialpha < GridPointsQuatern + 1; ialpha ++) - { - q1=(myfloat_t) ialpha * dgridq -1.f + 0.5 * dgridq; - for (int ibeta = 0; ibeta < GridPointsQuatern + 1; ibeta ++) - { - q2=(myfloat_t) ibeta * dgridq -1.f + 0.5 * dgridq; - for (int igamma = 0; igamma < GridPointsQuatern + 1 ; igamma ++) - { - q3= (myfloat_t) igamma * dgridq -1.f + 0.5 * dgridq; - if(q1*q1+q2*q2+q3*q3 <= 1.f){ - - angles[n].pos[0] = q1; - angles[n].pos[1] = q2; - angles[n].pos[2] = q3; - angles[n].quat4=sqrt(1.f-q1*q1-q2*q2-q3*q3); - n++; - //Adding the negative - angles[n].pos[0] = q1; - angles[n].pos[1] = q2; - angles[n].pos[2] = q3; - angles[n].quat4=-sqrt(1.f-q1*q1-q2*q2-q3*q3); - n++; - } - } - } - } - - } else{ + for (int ialpha = 0; ialpha < GridPointsQuatern + 1; ialpha++) + { + q1 = (myfloat_t) ialpha * dgridq - 1.f + 0.5 * dgridq; + for (int ibeta = 0; ibeta < GridPointsQuatern + 1; ibeta++) + { + q2 = (myfloat_t) ibeta * dgridq - 1.f + 0.5 * dgridq; + for (int igamma = 0; igamma < GridPointsQuatern + 1; igamma++) + { + q3 = (myfloat_t) igamma * dgridq - 1.f + 0.5 * dgridq; + if (q1 * q1 + q2 * q2 + q3 * q3 <= 1.f) + { + + angles[n].pos[0] = q1; + angles[n].pos[1] = q2; + angles[n].pos[2] = q3; + angles[n].quat4 = sqrt(1.f - q1 * q1 - q2 * q2 - q3 * q3); + n++; + // Adding the negative + angles[n].pos[0] = q1; + angles[n].pos[1] = q2; + angles[n].pos[2] = q3; + angles[n].quat4 = -sqrt(1.f - q1 * q1 - q2 * q2 - q3 * q3); + n++; + } + } + } + } + } + else + { //******** Reading Quaternions From a File *************************** ifstream input(fileangles); if (!input.good()) - { - cout << "Problem with Quaterion List file " << fileangles << " " << endl ; - exit(1); - } + { + cout << "Problem with Quaterion List file " << fileangles << " " + << endl; + exit(1); + } char line[512] = {0}; - int n=0; + int n = 0; // First line tels the number of rows input.getline(line, 511); int ntotquat; - char tmpVals[60] = {0}; + char tmpVals[60] = {0}; - strncpy (tmpVals, line, 12); - sscanf (tmpVals, "%d", &ntotquat); - if(ntotquat <1){ - cout << "Invalid Number of quaternions " << ntotquat << "\n"; exit(1); - }else{ - cout << "Number of quaternions " << ntotquat << "\n"; + strncpy(tmpVals, line, 12); + sscanf(tmpVals, "%d", &ntotquat); + if (ntotquat < 1) + { + cout << "Invalid Number of quaternions " << ntotquat << "\n"; + exit(1); + } + else + { + cout << "Number of quaternions " << ntotquat << "\n"; } - angles = (myfloat3_t*) mallocchk( ntotquat * sizeof(myfloat3_t)); + angles = (myfloat3_t *) mallocchk(ntotquat * sizeof(myfloat3_t)); // delete[] angles; // angles = new myfloat3_t[ ntotquat] ; - if(yespriorAngles){ - delete[] angprior; - angprior = new myfloat_t[ ntotquat ]; - } + if (yespriorAngles) + { + delete[] angprior; + angprior = new myfloat_t[ntotquat]; + } while (!input.eof()) - { - input.getline(line, 511); - if(n< ntotquat){ - myfloat_t q1,q2,q3,q4,pp; - - q1=-99999; q2=-99999;q3=-99999;q4=-99999; - char tmpVals[60] = {0}; - - strncpy (tmpVals, line, 12); - sscanf (tmpVals, "%f", &q1); - - strncpy (tmpVals, line + 12, 12); - sscanf (tmpVals, "%f", &q2); - - strncpy (tmpVals, line + 24, 12); - sscanf (tmpVals, "%f", &q3); - - strncpy (tmpVals, line + 36, 12); - sscanf (tmpVals, "%f", &q4); - - angles[n].pos[0] = q1; - angles[n].pos[1] = q2; - angles[n].pos[2] = q3; - angles[n].quat4 = q4; - - if(q1<-1 || q1 > 1){ cout << "Error reading quaterions from list. Value out of range " << q1 << " row " << n << "\n"; exit(1);}; - if(q2<-1 || q2 > 1){ cout << "Error reading quaterions from list. Value out of range " << q2 << " row " << n << "\n"; exit(1);}; - if(q3<-1 || q3 > 1){ cout << "Error reading quaterions from list. Value out of range " << q3 << " row " << n << "\n"; exit(1);}; - if(q4<-1 || q4 > 1){ cout << "Error reading quaterions from list. Value out of range " << q4 << " row " << n << "\n"; exit(1);}; - - - if(yespriorAngles){ - strncpy (tmpVals, line + 48, 12); - sscanf (tmpVals, "%f", &pp); - if(pp <0.0000001)cout << "Sure you're input is correct? Very small prior.\n"; - angprior[n] = pp;} + { + input.getline(line, 511); + if (n < ntotquat) + { + float q1, q2, q3, q4, pp; + + q1 = -99999.; + q2 = -99999.; + q3 = -99999.; + q4 = -99999.; + char tmpVals[60] = {0}; + + strncpy(tmpVals, line, 12); + sscanf(tmpVals, "%f", &q1); + + strncpy(tmpVals, line + 12, 12); + sscanf(tmpVals, "%f", &q2); + + strncpy(tmpVals, line + 24, 12); + sscanf(tmpVals, "%f", &q3); + + strncpy(tmpVals, line + 36, 12); + sscanf(tmpVals, "%f", &q4); + + angles[n].pos[0] = q1; + angles[n].pos[1] = q2; + angles[n].pos[2] = q3; + angles[n].quat4 = q4; + + if (q1 < -1 || q1 > 1) + { + cout << "Error reading quaterions from list. Value out of range " + << q1 << " row " << n << "\n"; + exit(1); + }; + if (q2 < -1 || q2 > 1) + { + cout << "Error reading quaterions from list. Value out of range " + << q2 << " row " << n << "\n"; + exit(1); + }; + if (q3 < -1 || q3 > 1) + { + cout << "Error reading quaterions from list. Value out of range " + << q3 << " row " << n << "\n"; + exit(1); + }; + if (q4 < -1 || q4 > 1) + { + cout << "Error reading quaterions from list. Value out of range " + << q4 << " row " << n << "\n"; + exit(1); + }; + + if (yespriorAngles) + { + strncpy(tmpVals, line + 48, 12); + sscanf(tmpVals, "%f", &pp); + if (pp < 0.0000001) + cout << "Sure you're input is correct? Very small prior.\n"; + angprior[n] = pp; + } #ifdef DEBUG - // if(yespriorAngles) - cout << "check orient: " << n << " " << angles[n].pos[0] << " " << angles[n].pos[1] << " " << angles[n].pos[2] << " prior: " << angles[n].quat4 << "\n"; + // if(yespriorAngles) + cout << "check orient: " << n << " " << angles[n].pos[0] << " " + << angles[n].pos[1] << " " << angles[n].pos[2] + << " prior: " << angles[n].quat4 << "\n"; #endif - - } - n++; - if(ntotquat+1 < n) { - cout << "More quaternions than expected in header " << n << " instead of " << NotUn_angles << "\n"; - exit(1); - } - } + } + n++; + if (ntotquat + 1 < n) + { + cout << "More quaternions than expected in header " << n + << " instead of " << NotUn_angles << "\n"; + exit(1); + } + } nTotGridAngles = ntotquat; - voluang= 1./ (myfloat_t) ntotquat * priorMod; + voluang = 1. / (myfloat_t) ntotquat * priorMod; - input.close(); + input.close(); } - - cout << "Analysis with Quaternions. Total number of quaternions " << nTotGridAngles << "\n"; + cout << "Analysis with Quaternions. Total number of quaternions " + << nTotGridAngles << "\n"; } - - return(0); - + return (0); } int bioem_param::CalculateRefCTF() { // ************************************************************************************** - // ********** Routine that pre-calculates Kernels for Convolution ********************** + // ********** Routine that pre-calculates Kernels for Convolution + // ********************** // ************************************************************************************ myfloat_t amp, env, phase, ctf, radsq; - myfloat_t* localCTF; - mycomplex_t* localout; + myfloat_t *localCTF; + mycomplex_t *localout; int nctfmax = param_device.NumberPixels / 2; int n = 0; - localCTF = (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) * param_device.NumberPixels * param_device.NumberPixels); - localout = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * param_device.NumberPixels * param_device.NumberFFTPixels1D); + localCTF = (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) * + param_device.NumberPixels * + param_device.NumberPixels); + localout = (mycomplex_t *) myfftw_malloc(sizeof(mycomplex_t) * + param_device.NumberPixels * + param_device.NumberFFTPixels1D); - nTotCTFs = numberGridPointsCTF_amp * numberGridPointsCTF_phase * numberGridPointsEnvelop; + nTotCTFs = numberGridPointsCTF_amp * numberGridPointsCTF_phase * + numberGridPointsEnvelop; delete[] refCTF; refCTF = new mycomplex_t[getRefCtfCount()]; delete[] CtfParam; @@ -1136,202 +1463,265 @@ int bioem_param::CalculateRefCTF() myfloat_t normctf; - - gridCTF_amp = (endGridCTF_amp - startGridCTF_amp) / (myfloat_t) numberGridPointsCTF_amp; - gridCTF_phase = (endGridCTF_phase - startGridCTF_phase) / (myfloat_t) numberGridPointsCTF_phase; - gridEnvelop = (endGridEnvelop - startGridEnvelop) / (myfloat_t) numberGridPointsEnvelop; - + gridCTF_amp = + (endGridCTF_amp - startGridCTF_amp) / (myfloat_t) numberGridPointsCTF_amp; + gridCTF_phase = (endGridCTF_phase - startGridCTF_phase) / + (myfloat_t) numberGridPointsCTF_phase; + gridEnvelop = + (endGridEnvelop - startGridEnvelop) / (myfloat_t) numberGridPointsEnvelop; - //if only one grid point for PSF kernel: - if( (myfloat_t) numberGridPointsCTF_amp == 1 ) { - gridCTF_amp = startGridCTF_amp;} - else if ( (endGridCTF_amp - startGridCTF_amp) < 0. ){ - cout << "Error: Interval of amplitude in CTF/PSF Negative"; exit(1); + // if only one grid point for PSF kernel: + if ((myfloat_t) numberGridPointsCTF_amp == 1) + { + gridCTF_amp = startGridCTF_amp; } - if( (myfloat_t) numberGridPointsCTF_phase == 1 ) { + else if ((endGridCTF_amp - startGridCTF_amp) < 0.) + { + cout << "Error: Interval of amplitude in CTF/PSF Negative"; + exit(1); + } + if ((myfloat_t) numberGridPointsCTF_phase == 1) + { gridCTF_phase = startGridCTF_phase; - }else if ( (endGridCTF_phase - startGridCTF_phase) < 0.){ - cout << "Error: Interval of PHASE in CTF/PSF is Negative"; exit(1); } - if( (myfloat_t) numberGridPointsEnvelop == 1 ) { + else if ((endGridCTF_phase - startGridCTF_phase) < 0.) + { + cout << "Error: Interval of PHASE in CTF/PSF is Negative"; + exit(1); + } + if ((myfloat_t) numberGridPointsEnvelop == 1) + { gridEnvelop = startGridEnvelop; - } else if ( (endGridEnvelop - startGridEnvelop) < 0.) { - cout << "Error: Interval of Envelope in CTF/PSF is Negative"; exit(1); + } + else if ((endGridEnvelop - startGridEnvelop) < 0.) + { + cout << "Error: Interval of Envelope in CTF/PSF is Negative"; + exit(1); } - - //More checks with input parameters + // More checks with input parameters // Envelope should not have a standard deviation greater than Npix/2 - if(sqrt(1./( (myfloat_t) numberGridPointsEnvelop * gridEnvelop + startGridEnvelop))> float(param_device.NumberPixels)/2.0 && usepsf) { - cout << "MAX Standard deviation of envelope is larger than Allowed KERNEL Length\n"; + if (sqrt(1. / ((myfloat_t) numberGridPointsEnvelop * gridEnvelop + + startGridEnvelop)) > float(param_device.NumberPixels) / 2.0 && + usepsf) + { + cout << "MAX Standard deviation of envelope is larger than Allowed KERNEL " + "Length\n"; exit(1); } // Envelop param should be positive - if(!printModel && (startGridCTF_amp < 0 || endGridCTF_amp > 1)){ + if (!printModel && (startGridCTF_amp < 0 || endGridCTF_amp > 1)) + { cout << "Error: PSF Amplitud should be between 0 and 1\n"; cout << "start: " << startGridCTF_amp << "End: " << endGridCTF_amp << "\n"; exit(1); } - if(!printModel && endGridCTF_amp < startGridCTF_amp){ - cout << "Error: values of amplitud starting is larger than ending points\n" ; + if (!printModel && endGridCTF_amp < startGridCTF_amp) + { + cout << "Error: values of amplitud starting is larger than ending points\n"; cout << "start: " << startGridCTF_amp << " End: " << endGridCTF_amp << "\n"; exit(1); } + for (int iamp = 0; iamp < numberGridPointsCTF_amp; + iamp++) // Loop over amplitud + { + amp = (myfloat_t) iamp * gridCTF_amp + startGridCTF_amp; - for (int iamp = 0; iamp < numberGridPointsCTF_amp ; iamp++) //Loop over amplitud - { - amp = (myfloat_t) iamp * gridCTF_amp + startGridCTF_amp; - - for (int iphase = 0; iphase < numberGridPointsCTF_phase ; iphase++)//Loop over phase - { - phase = (myfloat_t) iphase * gridCTF_phase + startGridCTF_phase; - - for (int ienv = 0; ienv < numberGridPointsEnvelop ; ienv++)//Loop over envelope - { - env = (myfloat_t) ienv * gridEnvelop + startGridEnvelop; - - memset(localCTF, 0, param_device.NumberPixels * param_device.NumberPixels * sizeof(myfloat_t)); - - normctf = 0.0; - - // cout <<"values " << amp << " " << phase << " " << env <<"\n"; - //Complex CTF - mycomplex_t* curRef = &refCTF[n * FFTMapSize]; - - // Initialzing everything to zero just to be sure - for(int i = 0; i < param_device.NumberPixels * param_device.NumberFFTPixels1D; i++ ){ - curRef[i][0] =0.f; - curRef[i][1] =0.f; - } - - for(int i = 0; i < param_device.NumberPixels; i++) - { - for(int j = 0; j < param_device.NumberPixels; j++) - { - localCTF[i * param_device.NumberPixels + j]=0.f; - } - } - - if(usepsf){ - normctf=0.0; - - for(int i = 0; i < param_device.NumberPixels; i++) - { - for(int j = 0; j < param_device.NumberPixels; j++) - { - int ri=0,rj=0; - - //Calculating the distance from the periodic center at 0,0 - - if(i + Copyright (C) 2017 Pilar Cossio, David Rohr, Fabio Baruffa, Markus Rampp, + Luka Stanisic, Volker Lindenstruth and Gerhard Hummer. + Max Planck Institute of Biophysics, Frankfurt, Germany. + Frankfurt Institute for Advanced Studies, Goethe University Frankfurt, + Germany. + Max Planck Computing and Data Facility, Garching, Germany. + + Released under the GNU Public License, v3. + See license statement for terms of distribution. + + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ + #include "timer.h" #ifdef _WIN32 -#include #include +#include #else #include #endif HighResTimer::HighResTimer() { - ElapsedTime = 0; - running = 0; + ElapsedTime = 0; + running = 0; } HighResTimer::~HighResTimer() {} @@ -17,76 +31,75 @@ HighResTimer::~HighResTimer() {} void HighResTimer::Start() { #ifdef _WIN32 - __int64 istart; - QueryPerformanceCounter((LARGE_INTEGER*)&istart); - StartTime = (double) istart; + __int64 istart; + QueryPerformanceCounter((LARGE_INTEGER *) &istart); + StartTime = (double) istart; #else - timespec tv; - clock_gettime(CLOCK_REALTIME, &tv); - StartTime = (double) tv.tv_sec * 1.0E9 + (double) tv.tv_nsec; + timespec tv; + clock_gettime(CLOCK_REALTIME, &tv); + StartTime = (double) tv.tv_sec * 1.0E9 + (double) tv.tv_nsec; #endif - running = 1; + running = 1; } void HighResTimer::ResetStart() { - ElapsedTime = 0; - Start(); + ElapsedTime = 0; + Start(); } void HighResTimer::Stop() { - if (running == 0) return; - running = 0; - double EndTime = 0; + if (running == 0) + return; + running = 0; + double EndTime = 0; #ifdef _WIN32 - __int64 iend; - QueryPerformanceCounter((LARGE_INTEGER*) &iend); - EndTime = (double) iend; + __int64 iend; + QueryPerformanceCounter((LARGE_INTEGER *) &iend); + EndTime = (double) iend; #else - timespec tv; - clock_gettime(CLOCK_REALTIME, &tv); - EndTime = (double) tv.tv_sec * 1.0E9 + (double) tv.tv_nsec; + timespec tv; + clock_gettime(CLOCK_REALTIME, &tv); + EndTime = (double) tv.tv_sec * 1.0E9 + (double) tv.tv_nsec; #endif - ElapsedTime += EndTime - StartTime; + ElapsedTime += EndTime - StartTime; } void HighResTimer::Reset() { - ElapsedTime = 0; - StartTime = 0; - running = 0; + ElapsedTime = 0; + StartTime = 0; + running = 0; } -double HighResTimer::GetElapsedTime() -{ - return ElapsedTime / Frequency; -} +double HighResTimer::GetElapsedTime() { return ElapsedTime / Frequency; } double HighResTimer::GetCurrentElapsedTime() { - if (running == 0) return(GetElapsedTime()); - double CurrentTime = 0; + if (running == 0) + return (GetElapsedTime()); + double CurrentTime = 0; #ifdef _WIN32 - __int64 iend; - QueryPerformanceCounter((LARGE_INTEGER*) &iend); - CurrentTime = (double) iend; + __int64 iend; + QueryPerformanceCounter((LARGE_INTEGER *) &iend); + CurrentTime = (double) iend; #else - timespec tv; - clock_gettime(CLOCK_REALTIME, &tv); - CurrentTime = (double) tv.tv_sec * 1.0E9 + (double) tv.tv_nsec; + timespec tv; + clock_gettime(CLOCK_REALTIME, &tv); + CurrentTime = (double) tv.tv_sec * 1.0E9 + (double) tv.tv_nsec; #endif - return((CurrentTime - StartTime + ElapsedTime) / Frequency); + return ((CurrentTime - StartTime + ElapsedTime) / Frequency); } double HighResTimer::GetFrequency() { #ifdef _WIN32 - __int64 ifreq; - QueryPerformanceFrequency((LARGE_INTEGER*)&ifreq); - return((double) ifreq); + __int64 ifreq; + QueryPerformanceFrequency((LARGE_INTEGER *) &ifreq); + return ((double) ifreq); #else - return(1.0E9); + return (1.0E9); #endif } @@ -114,9 +127,10 @@ void TimeStat::InitTimeStat(int nlogs) void TimeStat::EmptyTimeStat() { - if (tl == NULL) return; + if (tl == NULL) + return; - delete [ ] tl; + delete[] tl; tl = NULL; time = 0.; } @@ -127,22 +141,25 @@ void TimeStat::ComputeTimeStat() vector diff; for (int i = 0; i < total_logs; i++) - { - tl[i].sum = std::accumulate(tl[i].vec.begin(), tl[i].vec.end(), 0.0); - mean = tl[i].sum / tl[i].vec.size(); - - diff.resize(tl[i].vec.size()); - std::transform(tl[i].vec.begin(), tl[i].vec.end(), diff.begin(), std::bind2nd(std::minus(), mean)); - sq_sum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0); - tl[i].stdev = std::sqrt(sq_sum / tl[i].vec.size()); - } + { + tl[i].sum = std::accumulate(tl[i].vec.begin(), tl[i].vec.end(), 0.0); + mean = tl[i].sum / tl[i].vec.size(); + + diff.resize(tl[i].vec.size()); + std::transform(tl[i].vec.begin(), tl[i].vec.end(), diff.begin(), + std::bind2nd(std::minus(), mean)); + sq_sum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0); + tl[i].stdev = std::sqrt(sq_sum / tl[i].vec.size()); + } } void TimeStat::PrintTimeStat(int mpi_rank) { ComputeTimeStat(); for (int i = 0; i < total_logs; i++) - { - printf("SUMMARY -> %s: Total %f sec; Mean %f sec; Std.Dev. %f (rank %d)\n", tl[i].name.c_str(), tl[i].sum, tl[i].sum / tl[i].vec.size(), tl[i].stdev, mpi_rank); - } + { + printf("SUMMARY -> %s: Total %f sec; Mean %f sec; Std.Dev. %f (rank %d)\n", + tl[i].name.c_str(), tl[i].sum, tl[i].sum / tl[i].vec.size(), + tl[i].stdev, mpi_rank); + } }