Commit d41e474a authored by David Rohr's avatar David Rohr
Browse files

fix comment style

parent 65ca8537
......@@ -47,24 +47,24 @@ bioem::~bioem()
int bioem::configure(int ac, char* av[])
{
/**************************************************************************************/
/**** Configuration Routine using boost for extracting parameters, models and maps ****/
/**************************************************************************************/
/****** And Precalculating necessary grids, map crosscorrelations and kernels ********/
/*************************************************************************************/
// **************************************************************************************
// **** Configuration Routine using boost for extracting parameters, models and maps ****
// **************************************************************************************
// ****** And Precalculating necessary grids, map crosscorrelations and kernels ********
// *************************************************************************************
/*** Inizialzing default variables ***/
// *** Inizialzing default variables ***
std::string infile, modelfile, mapfile;
Model.readPDB = false;
param.writeAngles = false;
param.dumpMap = false;
param.loadMap = false;
/*************************************************************************************/
// *************************************************************************************
cout << " ++++++++++++ FROM COMMAND LINE +++++++++++\n\n";
/*************************************************************************************/
// *************************************************************************************
/********************* Command line reading input with BOOST ************************/
// ********************* Command line reading input with BOOST ************************
try {
po::options_description desc("Command line inputs");
......@@ -145,23 +145,23 @@ int bioem::configure(int ac, char* av[])
return 1;
}
/********************* Reading Parameter Input ***************************/
// ********************* Reading Parameter Input ***************************
// copying inputfile to param class
param.fileinput = infile.c_str();
param.readParameters();
/********************* Reading Model Input ******************************/
// ********************* Reading Model Input ******************************
// copying modelfile to model class
Model.filemodel = modelfile.c_str();
Model.readModel();
/********************* Reading Particle Maps Input **********************/
/********* HERE: PROBLEM if maps dont fit on the memory!! ***************/
// ********************* Reading Particle Maps Input **********************
// ********* HERE: PROBLEM if maps dont fit on the memory!! ***************
// copying mapfile to ref map class
param.filemap = mapfile.c_str();
RefMap.readRefMaps(param);
/****************** Precalculating Necessary Stuff *********************/
// ****************** Precalculating Necessary Stuff *********************
precalculate();
if (getenv("BIOEM_DEBUG_BREAK"))
......@@ -177,9 +177,9 @@ int bioem::configure(int ac, char* av[])
int bioem::precalculate()
{
/**************************************************************************************/
// **************************************************************************************
/* Precalculating Routine of Orientation grids, Map crosscorrelations and CTF Kernels */
/**************************************************************************************/
// **************************************************************************************
// Generating Grids of orientations
param.CalculateGridsParam();
......@@ -207,12 +207,12 @@ int bioem::precalculate()
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 *************************
pProb = new bioem_Probability[RefMap.ntotRefMap];
printf("\tInitializing\n");
......@@ -228,12 +228,12 @@ int bioem::run()
pProb[iRefMap].ConstAngle[iOrient] = -99999999;
}
}
/**************************************************************************************/
// **************************************************************************************
deviceStartRun();
/******************************** MAIN CYCLE ******************************************/
// ******************************** MAIN CYCLE ******************************************
/*** Declaring Private variables for each thread *****/
// *** Declaring Private variables for each thread *****
mycomplex_t* proj_mapFFT;
myfloat_t* conv_map = new myfloat_t[param.param_device.NumberPixels * param.param_device.NumberPixels];
mycomplex_t* conv_mapFFT;
......@@ -249,25 +249,25 @@ int bioem::run()
printf("\tInner Loop Count (%d %d %d) %lld\n", param.param_device.maxDisplaceCenter, param.param_device.GridSpaceCenter, param.param_device.NumberPixels, (long long int) (param.param_device.NumberPixels * param.param_device.NumberPixels * (2 * param.param_device.maxDisplaceCenter / param.param_device.GridSpaceCenter + 1) * (2 * param.param_device.maxDisplaceCenter / param.param_device.GridSpaceCenter + 1)));
for (int iProjectionOut = 0; iProjectionOut < param.nTotGridAngles; iProjectionOut++)
{
/***************************************************************************************/
/***** Creating Projection for given orientation and transforming to Fourier space *****/
// ***************************************************************************************
// ***** Creating Projection for given orientation and transforming to Fourier space *****
timer.ResetStart();
createProjection(iProjectionOut, proj_mapFFT);
printf("Time Projection %d: %f\n", iProjectionOut, timer.GetCurrentElapsedTime());
/***************************************************************************************/
/***** **** Internal Loop over convolutions **** *****/
// ***************************************************************************************
// ***** **** Internal Loop over convolutions **** *****
for (int iConv = 0; iConv < param.nTotCTFs; iConv++)
{
printf("\t\tConvolution %d %d\n", iProjectionOut, iConv);
/*** Calculating convolutions of projection map and crosscorrelations ***/
// *** Calculating convolutions of projection map and crosscorrelations ***
timer.ResetStart();
createConvolutedProjectionMap(iProjectionOut, iConv, proj_mapFFT, conv_map, conv_mapFFT, sumCONV, sumsquareCONV);
printf("Time Convolution %d %d: %f\n", iProjectionOut, iConv, timer.GetCurrentElapsedTime());
/***************************************************************************************/
/*** Comparing each calculated convoluted map with all experimental maps ***/
// ***************************************************************************************
// *** Comparing each calculated convoluted map with all experimental maps ***
timer.ResetStart();
compareRefMaps(iProjectionOut, iConv, conv_map, conv_mapFFT, sumCONV, sumsquareCONV);
......@@ -289,9 +289,9 @@ int bioem::run()
deviceFinishRun();
/************* Writing Out Probabilities ***************/
// ************* Writing Out Probabilities ***************
/*** Angular Probability ***/
// *** Angular Probability ***
// if(param.writeAngles){
ofstream angProbfile;
......@@ -303,12 +303,12 @@ int bioem::run()
for (int iRefMap = 0; iRefMap < RefMap.ntotRefMap; iRefMap ++)
{
/**** Total Probability ***/
// **** Total Probability ***
outputProbFile << "RefMap " << iRefMap << " Probability " << log(pProb[iRefMap].Total) + pProb[iRefMap].Constoadd + 0.5 * log(M_PI) + (1 - param.param_device.Ntotpi * 0.5)*(log(2 * M_PI) + 1) + log(param.param_device.volu) << " Constant " << pProb[iRefMap].Constoadd << "\n";
outputProbFile << "RefMap " << iRefMap << " Maximizing Param: ";
/*** Param that maximize probability****/
// *** Param that maximize probability****
outputProbFile << (pProb[iRefMap].max_prob + 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[pProb[iRefMap].max_prob_orient].pos[0] << " ";
outputProbFile << param.angles[pProb[iRefMap].max_prob_orient].pos[1] << " ";
......@@ -320,7 +320,7 @@ int bioem::run()
outputProbFile << pProb[iRefMap].max_prob_cent_y;
outputProbFile << "\n";
/*** For individual files***/ //angProbfile.open ("ANG_PROB_"iRefMap);
// *** For individual files*** //angProbfile.open ("ANG_PROB_"iRefMap);
if(param.writeAngles)
{
......@@ -405,10 +405,10 @@ inline void bioem::calculateCCFFT(int iRefMap, int iOrient, int iConv, myfloat_t
int bioem::createProjection(int iMap, mycomplex_t* mapFFT)
{
/**************************************************************************************/
/**** BioEM Create Projection routine in Euler angle predefined grid****************
********************* and turns projection into Fourier space **********************/
/**************************************************************************************/
// **************************************************************************************
// **** BioEM Create Projection routine in Euler angle predefined grid****************
********************* and turns projection into Fourier space **********************
// **************************************************************************************
myfloat3_t RotatedPointsModel[Model.nPointsModel];
myfloat_t rotmat[3][3];
......@@ -422,9 +422,9 @@ 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: cout << "Id " << omp_get_thread_num() << " Angs: " << alpha << " " << beta << " " << gam << "\n"; ***/
// **** To see how things are going: cout << "Id " << omp_get_thread_num() << " Angs: " << alpha << " " << beta << " " << gam << "\n"; ***
/********** Creat Rotation with pre-defiend grid of orientations**********/
// ********** Creat Rotation with pre-defiend grid of orientations**********
rotmat[0][0] = cos(gam) * cos(alpha) - cos(beta) * sin(alpha) * sin(gam);
rotmat[0][1] = cos(gam) * sin(alpha) + cos(beta) * cos(alpha) * sin(gam);
......@@ -455,7 +455,7 @@ int bioem::createProjection(int iMap, mycomplex_t* mapFFT)
int i, j;
/************ Projection over the Z axis********************/
// ************ Projection over the Z axis********************
for(int n = 0; n < Model.nPointsModel; n++)
{
//Getting pixel that represents coordinates & shifting the start at to Numpix/2,Numpix/2 )
......@@ -465,7 +465,7 @@ int bioem::createProjection(int iMap, mycomplex_t* mapFFT)
localproj[i * param.param_device.NumberPixels + j] += Model.densityPointsModel[n] / Model.NormDen;
}
/**** Output Just to check****/
// **** Output Just to check****
if(iMap == 10)
{
ofstream myexamplemap;
......@@ -483,8 +483,8 @@ int bioem::createProjection(int iMap, mycomplex_t* mapFFT)
myexampleRot.close();
}
/***** Converting projection to Fourier Space for Convolution later with kernel****/
/********** Omp Critical is necessary with FFTW*******/
// ***** 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);
return(0);
......@@ -492,18 +492,18 @@ int bioem::createProjection(int iMap, mycomplex_t* mapFFT)
int bioem::createConvolutedProjectionMap(int iMap, int iConv, mycomplex_t* lproj, myfloat_t* Mapconv, mycomplex_t* localmultFFT, myfloat_t& sumC, myfloat_t& sumsquareC)
{
/**************************************************************************************/
/**** BioEM Create Convoluted Projection Map routine, multiplies in Fourier **********
// **************************************************************************************
// **** BioEM Create Convoluted Projection Map routine, multiplies in Fourier **********
**************** calculated Projection with convoluted precalculated Kernel**********
*************** and Backtransforming it to real Space ******************************/
/**************************************************************************************/
*************** and Backtransforming it to real Space ******************************
// **************************************************************************************
myfloat_t* localconvFFT;
localconvFFT = (myfloat_t *) myfftw_malloc(sizeof(myfloat_t) * param.param_device.NumberPixels * param.param_device.NumberPixels);
mycomplex_t* tmp;
tmp = (mycomplex_t*) myfftw_malloc(sizeof(mycomplex_t) * param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D);
/**** Multiplying FFTmap with corresponding kernel ****/
// **** Multiplying FFTmap with corresponding kernel ****
const mycomplex_t* refCTF = &param.refCTF[iConv * param.FFTMapSize];
for(int i = 0; i < param.param_device.NumberPixels * param.param_device.NumberFFTPixels1D; i++)
......@@ -516,10 +516,10 @@ int bioem::createConvolutedProjectionMap(int iMap, int iConv, mycomplex_t* lproj
//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 ****/
// **** Bringing convoluted Map to real Space ****
myfftw_execute_dft_c2r(param.fft_plan_c2r_backward, tmp, localconvFFT);
/****Asigning convolution fftw_complex to bioem_map ****/
// ****Asigning convolution fftw_complex to bioem_map ****
for(int i = 0; i < param.param_device.NumberPixels ; i++ )
{
for(int j = 0; j < param.param_device.NumberPixels ; j++ )
......@@ -528,7 +528,7 @@ int bioem::createConvolutedProjectionMap(int iMap, int iConv, mycomplex_t* lproj
}
}
/*** Calculating Cross-correlations of cal-convoluted map with its self *****/
// *** Calculating Cross-correlations of cal-convoluted map with its self *****
sumC = 0;
sumsquareC = 0;
for(int i = 0; i < param.param_device.NumberPixels * param.param_device.NumberPixels; i++)
......@@ -536,14 +536,14 @@ int bioem::createConvolutedProjectionMap(int iMap, int iConv, mycomplex_t* lproj
sumC += localconvFFT[i];
sumsquareC += localconvFFT[i] * localconvFFT[i];
}
/*** The DTF gives an unnormalized value so have to divded by the total number of pixels in Fourier ***/
// *** The DTF gives an unnormalized value so have to divded by the total number of pixels in Fourier ***
// Normalizing
myfloat_t norm2 = (myfloat_t) (param.param_device.NumberPixels * param.param_device.NumberPixels);
myfloat_t norm4 = norm2 * norm2;
sumC = sumC / norm2;
sumsquareC = sumsquareC / norm4;
/**** Freeing fftw_complex created (dont know if omp critical is necessary) ****/
// **** Freeing fftw_complex created (dont know if omp critical is necessary) ****
myfftw_free(localconvFFT);
myfftw_free(tmp);
......@@ -552,7 +552,7 @@ int bioem::createConvolutedProjectionMap(int iMap, int iConv, mycomplex_t* lproj
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;
......
......@@ -14,8 +14,8 @@
template <int GPUAlgo>
__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, myfloat_t* buf3 = NULL, int* bufint = NULL)
{
/******* Summing total Probabilities *************/
/******* Need a constant because of numerical divergence*****/
// ******* Summing total Probabilities *************
// ******* Need a constant because of numerical divergence*****
if(pProb[iRefMap].Constoadd < logpro)
{
pProb[iRefMap].Total = pProb[iRefMap].Total * exp(-logpro + pProb[iRefMap].Constoadd);
......@@ -35,7 +35,7 @@ __device__ static inline void update_prob(const myfloat_t logpro, const int iRef
pProb[iRefMap].forAngles[iOrient] += exp(logpro - pProb[iRefMap].ConstAngle[iOrient]);
}
/********** Getting parameters that maximize the probability ***********/
// ********** Getting parameters that maximize the probability ***********
if(pProb[iRefMap].max_prob < logpro)
{
pProb[iRefMap].max_prob = logpro;
......@@ -64,7 +64,7 @@ __device__ static inline myfloat_t calc_logpro(const bioem_param_device& param,
const myfloat_t firstele = param.Ntotpi * (sumsquareref * sumsquare - crossproMapConv * crossproMapConv) +
2 * sumref * sum * crossproMapConv - sumsquareref * sum * sum - sumref * sumref * sumsquare;
//******* Calculating log of Prob*********/
/// ******* 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);
const myfloat_t logpro = (3 - param.Ntotpi) * 0.5 * log(firstele) + (param.Ntotpi * 0.5 - 2) * log((param.Ntotpi - 2) * ForLogProb);
return(logpro);
......@@ -72,9 +72,9 @@ __device__ static inline myfloat_t calc_logpro(const bioem_param_device& param,
__device__ static inline void calProb(int iRefMap, int iOrient, int iConv, myfloat_t sumC, myfloat_t sumsquareC, float value, int disx, int disy, bioem_Probability* pProb, const bioem_param_device& param, const bioem_RefMap& RefMap)
{
/********************************************************/
/*********** Calculates the BioEM probability ***********/
/********************************************************/
// ********************************************************
// *********** Calculates the BioEM probability ***********
// ********************************************************
const myfloat_t logpro = calc_logpro(param, sumC, sumsquareC, value, RefMap.sum_RefMap[iRefMap], RefMap.sumsquare_RefMap[iRefMap]);
......
......@@ -21,9 +21,9 @@
int main(int argc, char* argv[])
{
/**************************************************************************************/
/********************************* Main BioEM code **********************************/
/************************************************************************************/
// **************************************************************************************
// ********************************* Main BioEM code **********************************
// ************************************************************************************
#pragma omp parallel
{
......@@ -43,17 +43,17 @@ int main(int argc, char* argv[])
bio = new bioem;
}
/************ Configuration and Pre-calculating necessary objects *****************/
// ************ Configuration and Pre-calculating necessary objects *****************
printf("Configuring\n");
if (bio->configure(argc, argv)) return(1);
/******************************* Run BioEM routine ******************************/
// ******************************* Run BioEM routine ******************************
printf("Running\n");
timer.Start();
bio->run();
timer.Stop();
/************************************ End **********************************/
// ************************************ End **********************************
printf ("The code ran for %f seconds.\n", timer.GetElapsedTime());
delete bio;
......
......@@ -15,9 +15,9 @@ int bioem_RefMap::readRefMaps(bioem_param& param)
{
numPixels = 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)
{
......@@ -143,9 +143,9 @@ int bioem_RefMap::readRefMaps(bioem_param& param)
int bioem_RefMap::PreCalculateMapsFFT(bioem_param& param)
{
/**************************************************************************************/
/********** Routine that pre-calculates Kernels for Convolution **********************/
/************************************************************************************/
// **************************************************************************************
// ********** Routine that pre-calculates Kernels for Convolution **********************
// ************************************************************************************
myfloat_t* localMap;
......
......@@ -11,9 +11,9 @@ using namespace std;
int bioem_model::readModel()
{
/**************************************************************************************/
/***************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");
......@@ -173,7 +173,7 @@ int bioem_model::readModel()
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;
......@@ -208,7 +208,7 @@ myfloat_t bioem_model::getAminoAcidRad(char *name)
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;
......
......@@ -25,7 +25,7 @@ bioem_param::bioem_param()
numberGridPointsCTF_amp = 0;
numberGridPointsCTF_phase = 0;
/****center displacement paramters Equal in both directions***/
// ****center displacement paramters Equal in both directions***
param_device.maxDisplaceCenter = 0;
numberGridPointsDisplaceCenter = 0;
......@@ -37,9 +37,9 @@ bioem_param::bioem_param()
int bioem_param::readParameters()
{
/**************************************************************************************/
/***************************** Reading Input Parameters ******************************/
/**************************************************************************************/
// **************************************************************************************
// ***************************** Reading Input Parameters ******************************
// **************************************************************************************
ifstream input(fileinput);
if (!input.good())
......@@ -220,9 +220,9 @@ void bioem_param::releaseFFTPlans()
int bioem_param::CalculateGridsParam() //TO DO FOR QUATERNIONS
{
/**************************************************************************************/
/**************** Routine that pre-calculates Euler angle grids **********************/
/************************************************************************************/
// **************************************************************************************
// **************** Routine that pre-calculates Euler angle grids **********************
// ************************************************************************************
myfloat_t grid_alpha, cos_grid_beta;
int n = 0;
......@@ -248,13 +248,13 @@ int bioem_param::CalculateGridsParam() //TO DO FOR QUATERNIONS
}
nTotGridAngles = n;
/********** Calculating normalized volumen element *********/
// ********** Calculating normalized volumen element *********
param_device.volu = grid_alpha * grid_alpha * cos_grid_beta * (myfloat_t) param_device.GridSpaceCenter * pixelSize * (myfloat_t) param_device.GridSpaceCenter * pixelSize
* gridCTF_phase * gridCTF_amp * gridEnvelop / (2.f * M_PI) / (2.f * M_PI) / 2.f / (2.f * (myfloat_t) param_device.maxDisplaceCenter) / (2.f * (myfloat_t) param_device.maxDisplaceCenter) / ((myfloat_t) numberGridPointsCTF_amp * gridCTF_amp + startGridCTF_amp)
/ ((myfloat_t) numberGridPointsCTF_phase * gridCTF_phase + startGridCTF_phase) / ((myfloat_t) numberGridPointsEnvelop * gridEnvelop + startGridEnvelop);
/*** Number of total pixels***/
// *** Number of total pixels***
param_device.Ntotpi = (myfloat_t) (param_device.NumberPixels * param_device.NumberPixels);
param_device.NtotDist = (2 * (int) (param_device.maxDisplaceCenter / param_device.GridSpaceCenter) + 1 ) * (2 * (int) (param_device.maxDisplaceCenter / param_device.GridSpaceCenter) + 1);
......@@ -265,9 +265,9 @@ int bioem_param::CalculateGridsParam() //TO DO FOR QUATERNIONS
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;
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment