ProgRecFourierGPU Class Reference

#include <reconstruct_fourier_gpu.h>

Inheritance diagram for ProgRecFourierGPU:

Collaboration diagram for ProgRecFourierGPU:

Public Member Functions
void	run ()
void	finishComputations (const FileName &out_name)
virtual void	setIO (const FileName &fn_in, const FileName &fn_out)
Public Member Functions inherited from ProgReconsBase
virtual	~ProgReconsBase ()
Public Member Functions inherited from XmippProgram
const char *	getParam (const char *param, int arg=0)
const char *	getParam (const char *param, const char *subparam, int arg=0)
int	getIntParam (const char *param, int arg=0)
int	getIntParam (const char *param, const char *subparam, int arg=0)
double	getDoubleParam (const char *param, int arg=0)
double	getDoubleParam (const char *param, const char *subparam, int arg=0)
float	getFloatParam (const char *param, int arg=0)
float	getFloatParam (const char *param, const char *subparam, int arg=0)
void	getListParam (const char *param, StringVector &list)
int	getCountParam (const char *param)
bool	checkParam (const char *param)
bool	existsParam (const char *param)
void	addParamsLine (const String &line)
void	addParamsLine (const char *line)
ParamDef *	getParamDef (const char *param) const
virtual void	quit (int exit_code=0) const
virtual int	tryRun ()
void	initProgress (size_t total, size_t stepBin=60)
void	setProgress (size_t value=0)
void	endProgress ()
void	processDefaultComment (const char *param, const char *left)
void	setDefaultComment (const char *param, const char *comment)
virtual void	initComments ()
void	setProgramName (const char *name)
void	addUsageLine (const char *line, bool verbatim=false)
void	clearUsage ()
void	addExampleLine (const char *example, bool verbatim=true)
void	addSeeAlsoLine (const char *seeAlso)
void	addKeywords (const char *keywords)
const char *	name () const
virtual void	usage (int verb=0) const
virtual void	usage (const String &param, int verb=2)
int	version () const
virtual void	show () const
virtual void	read (int argc, const char **argv, bool reportErrors=true)
virtual void	read (int argc, char **argv, bool reportErrors=true)
void	read (const String &argumentsLine)
	XmippProgram ()
	XmippProgram (int argc, const char **argv)
virtual	~XmippProgram ()

Protected Member Functions
void	checkDefines ()
void	mirrorAndCropTempSpaces ()
void	getGPUData ()
void	forceHermitianSymmetry ()
void	processWeights ()
void	createWorkThread (int gpuStream, int startIndex, int endIndex, RecFourierWorkThread &thread)
void	readParams ()
void	defineParams ()
void	show ()
void	produceSideinfo ()
void	processImages (int firstImageIndex, int lastImageIndex)
void	releaseTempSpaces ()
Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Protected Attributes
RecFourierWorkThread *	workThreads
MetaDataDb	SF
FileName	fn_out
FileName	fn_in
int	maxVolumeIndexYZ
int	maxVolumeIndexX
std::complex< float > ***	tempVolume = NULL
float ***	tempWeights = NULL
float *	tempVolumeGPU = NULL
float *	tempWeightsGPU = NULL
int	noOfThreads
int	device
Protected Attributes inherited from XmippProgram
int	errorCode
ProgramDef *	progDef
	Program definition and arguments parser. More...
std::map< String, CommentList >	defaultComments
int	argc
	Original command line arguments. More...
const char **	argv

Additional Inherited Members
Public Attributes inherited from XmippProgram
bool	doRun
bool	runWithoutArgs
int	verbose
	Verbosity level. More...
int	debug

Detailed Description

Definition at line 60 of file reconstruct_fourier_gpu.h.

Member Function Documentation

checkDefines()

void ProgRecFourierGPU::checkDefines ( )

protected

Method checks that there is no logical problem in the defines used by program. If found, error is thrown.

Definition at line 147 of file reconstruct_fourier_gpu.cpp.

                                     {
    if (!((TILE == 1) || (BLOCK_DIM % TILE == 0))) { //
        REPORT_ERROR(ERR_PARAM_INCORRECT,"TILE has to be set to 1(one) or BLOCK_DIM has to be a multiple of TILE");
    }
    if ((SHARED_IMG == 1) && (TILE != 1)) {
        REPORT_ERROR(ERR_PARAM_INCORRECT,"TILE cannot be used while SHARED_IMG is active");
    }
    if (TILE >= BLOCK_DIM) {
        REPORT_ERROR(ERR_PARAM_INCORRECT,"TILE must be smaller than BLOCK_DIM");
    }
    if ((SHARED_BLOB_TABLE == 1) && (PRECOMPUTE_BLOB_VAL == 0)) {
        REPORT_ERROR(ERR_PARAM_INCORRECT,"PRECOMPUTE_BLOB_VAL must be set to 1(one) when SHARED_BLOB_TABLE is active");
    }
}

createWorkThread()

void ProgRecFourierGPU::createWorkThread ( int  gpuStream, int  startIndex, int  endIndex, RecFourierWorkThread &  thread  )

protected

Method will create thread used for loading and processing images Thread starts the work immediately gpuStream - stream to use startIndex - index of the first projection to process endIndex - index of the last projection to process thread - used for referencing the thread

Definition at line 198 of file reconstruct_fourier_gpu.cpp.

                                                                                                                  {
    thread.parent = this;
    thread.startImageIndex = startIndex;
    thread.endImageIndex = endIndex;
    thread.gpuStream = gpuStream;
    pthread_create( &thread.id , NULL, threadRoutine, (void *)(&thread) );
}

defineParams()

void ProgRecFourierGPU::defineParams ( )

protectedvirtual

Specify supported command line arguments

Reimplemented from XmippProgram.

Definition at line 42 of file reconstruct_fourier_gpu.cpp.

{
    //usage
    addUsageLine("Generate 3D reconstructions from projections using direct Fourier interpolation with arbitrary geometry.");
    addUsageLine("Kaisser-windows are used for interpolation in Fourier space.");
    //params
    addParamsLine("   -i <md_file>                : Metadata file with input projections");
    addParamsLine("  [-o <volume_file=\"rec_fourier.vol\">]  : Filename for output volume");
    addParamsLine("  [--sym <symfile=c1>]              : Enforce symmetry in projections");
    addParamsLine("  [--padding <proj=2.0> <vol=2.0>]  : Padding used for projections and volume");
    addParamsLine("  [--max_resolution <p=0.5>]     : Max resolution (Nyquist=0.5)");
    addParamsLine("  [--weight]                     : Use weights stored in the image metadata");
    addParamsLine("  [--blob <radius=1.9> <order=0> <alpha=15>] : Blob parameters");
    addParamsLine("                                 : radius in pixels, order of Bessel function in blob and parameter alpha");
    addParamsLine("  [--thr <threads=all>]                  : Number of concurrent threads (and GPU streams). All threads are used by default");
    addParamsLine("  [--device <dev=0>]                 : GPU device to use. 0th by default");
    addParamsLine("  [--fast]                       : Do the blobing at the end of the computation.");
    addParamsLine("                                 : Gives slightly different results, but is faster.");
    addParamsLine("  [--fftOnGPU]                   : Perform the FFT conversion of the input images on GPU.");
    addParamsLine("                                 : Requires more memory on GPU (see also --bufferSize).");
    addParamsLine("  [--useCTF]                     : Use CTF information if present");
    addParamsLine("  [--sampling <Ts=1>]            : sampling rate of the input images in Angstroms/pixel");
    addParamsLine("                                 : It is only used when correcting for the CTF");
    addParamsLine("  [--phaseFlipped]               : Give this flag if images have been already phase flipped");
    addParamsLine("  [--minCTF <ctf=0.01>]          : Minimum value of the CTF that will be inverted");
    addParamsLine("                                 : CTF values (in absolute value) below this one will not be corrected");
    addParamsLine("  [--bufferSize <size=25>]        : Number of projection loaded in memory (will be actually 2x as much.");
    addParamsLine("                                 : This will require up to 4*size*projSize*projSize*16B, e.g.");
    addParamsLine("                                 : 100MB for projection of 256x256 or 400MB for projection of 512x512");
    addExampleLine("For reconstruct enforcing i3 symmetry and using stored weights:", false);
    addExampleLine("   xmipp_reconstruct_fourier  -i reconstruction.sel --sym i3 --weight");
}

finishComputations()

void ProgRecFourierGPU::finishComputations

(

const FileName &

out_name

)

Method will take data stored in tempVolume and tempWeights (which should be cropped in X axis), calculate IFFT and store result to final destination.

Definition at line 879 of file reconstruct_fourier_gpu.cpp.

{
    if (useFast) {
        tempVolume = applyBlob(tempVolume, blob.radius, blobTableSqrt, iDeltaSqrt);
        tempWeights = applyBlob(tempWeights, blob.radius, blobTableSqrt, iDeltaSqrt);
    }

    forceHermitianSymmetry();
    processWeights();
    release(tempWeights, maxVolumeIndexYZ+1, maxVolumeIndexYZ+1);
    MultidimArray< std::complex<double> > VoutFourier;
    allocateVoutFourier(VoutFourier);
    convertToExpectedSpace(tempVolume, maxVolumeIndexYZ, VoutFourier);
    release(tempVolume, maxVolumeIndexYZ+1, maxVolumeIndexYZ+1);

    // Output volume
    Image<double> Vout;
    Vout().initZeros(paddedImgSize,paddedImgSize,paddedImgSize);
    FourierTransformer transformerVol;
    transformerVol.setThreadsNumber(noOfThreads);
    transformerVol.fReal = &(Vout.data);
    transformerVol.setFourierAlias(VoutFourier);
    transformerVol.recomputePlanR2C();

    transformerVol.inverseFourierTransform();
    transformerVol.clear();
    CenterFFT(Vout(),false);

    // Correct by the Fourier transform of the blob
    Vout().setXmippOrigin();
    Vout().selfWindow(FIRST_XMIPP_INDEX(imgSize),FIRST_XMIPP_INDEX(imgSize),
                      FIRST_XMIPP_INDEX(imgSize),LAST_XMIPP_INDEX(imgSize),
                      LAST_XMIPP_INDEX(imgSize),LAST_XMIPP_INDEX(imgSize));
    double pad_relation= ((double)padding_factor_proj/padding_factor_vol);
    pad_relation = (pad_relation * pad_relation * pad_relation);

    MultidimArray<double> &mVout=Vout();
    double ipad_relation=1.0/pad_relation;
    double meanFactor2=0;
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mVout)
    {
        double radius=sqrt((double)(k*k+i*i+j*j));
        double aux=radius*iDeltaFourier;
        double factor = Fourier_blob_table(ROUND(aux));
        double factor2=(pow(Sinc(radius/(2*imgSize)),2));
        A3D_ELEM(mVout,k,i,j) /= (ipad_relation*factor2*factor);
        meanFactor2+=factor2;
    }
    meanFactor2/=MULTIDIM_SIZE(mVout);
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mVout)
    A3D_ELEM(mVout,k,i,j) *= meanFactor2;
    Vout.write(out_name);
    Vout.clear();
}

forceHermitianSymmetry()

void ProgRecFourierGPU::forceHermitianSymmetry ( )

protected

Method will enforce Hermitian symmetry, i.e will make sure that the values in temporal space at X=0 are complex conjugate of in respect to center of the space

Definition at line 732 of file reconstruct_fourier_gpu.cpp.

                                               {
    int x = 0;
    for (int z = 0; z <= maxVolumeIndexYZ; z++) {
        for (int y = 0; y <= maxVolumeIndexYZ/2; y++) {
            int newPos[3];
            // mirror against center of the volume, e.g. [0,0,0]->[size,size,size]. It will fit as the input space is one voxel biger
            newPos[0] = x;
            newPos[1] = maxVolumeIndexYZ - y;
            newPos[2] = maxVolumeIndexYZ - z;
            std::complex<float> tmp1 = 0.5f * (tempVolume[newPos[2]][newPos[1]][newPos[0]] + conj(tempVolume[z][y][x]));
            float tmp2 = 0.5f * (tempWeights[newPos[2]][newPos[1]][newPos[0]] + tempWeights[z][y][x]);

            tempVolume[newPos[2]][newPos[1]][newPos[0]] = tmp1;
            tempVolume[z][y][x] = conj(tmp1);
            tempWeights[newPos[2]][newPos[1]][newPos[0]] = tempWeights[z][y][x] = tmp2;
        }
    }
}

getGPUData()

void ProgRecFourierGPU::getGPUData ( )

protected

Method will fill temporal spaces with data stored at the GPU.

Definition at line 683 of file reconstruct_fourier_gpu.cpp.

                                   {
    if (NULL == tempVolume) {
        allocate(tempVolume, maxVolumeIndexYZ + 1, maxVolumeIndexYZ + 1,
                maxVolumeIndexYZ + 1);
    }
    if (NULL == tempWeights) {
        allocate(tempWeights, maxVolumeIndexYZ + 1, maxVolumeIndexYZ + 1,
                maxVolumeIndexYZ + 1);
    }
    copyTempVolumes(tempVolume, tempWeights, tempVolumeGPU, tempWeightsGPU, maxVolumeIndexYZ + 1);
    releaseTempVolumeGPU(tempVolumeGPU);
    releaseTempVolumeGPU(tempWeightsGPU);
}

mirrorAndCropTempSpaces()

void ProgRecFourierGPU::mirrorAndCropTempSpaces ( )

protected

Method will take temp spaces (containing complex conjugate values in the 'right X side'), transfer them to 'left X side' and remove the 'right X side'. As a result, the X dimension of the temp spaces will be half of the original.

Definition at line 697 of file reconstruct_fourier_gpu.cpp.

                                                {
    maxVolumeIndexX = maxVolumeIndexYZ/2; // just half of the space is necessary, the rest is complex conjugate
    mirrorAndCrop(tempWeights, &identity<float>);
    mirrorAndCrop(tempVolume, &conjugate);
}

processImages()

void ProgRecFourierGPU::processImages ( int  firstImageIndex, int  lastImageIndex  )

protected

Method will initialize temporal storage (if necessary), processes images in given interval (including boundary indexes) and store results in temporal storage (

See also

tempVolume and tempWeights)

Definition at line 832 of file reconstruct_fourier_gpu.cpp.

{

    GPU::setDevice(device);

// initialize GPU
    if (NULL == tempVolumeGPU) {
        allocateTempVolumeGPU(tempVolumeGPU, maxVolumeIndexYZ+1, sizeof(std::complex<float>));
    }
    if (NULL == tempWeightsGPU) {
        allocateTempVolumeGPU(tempWeightsGPU, maxVolumeIndexYZ+1, sizeof(float));
    }
    createStreams(noOfThreads);
    copyConstants(maxVolumeIndexX, maxVolumeIndexYZ,
            blob.radius, blob.alpha, iDeltaSqrt, iw0, 1.f/getBessiOrderAlpha(blob));
    if ( ! useFast) {
        copyBlobTable(blobTableSqrt, BLOB_TABLE_SIZE_SQRT);
    }

    // create threads
    int imgPerThread = ceil((lastImageIndex-firstImageIndex+1) / (float)noOfThreads);
    workThreads = new RecFourierWorkThread[noOfThreads];
    barrier_init( &barrier, noOfThreads + 1 ); // + main thread
    for (int i = 0; i < noOfThreads; i++) {
        int sIndex = firstImageIndex + i*imgPerThread;
        int eIndex = std::min(lastImageIndex, sIndex + imgPerThread-1);
        createWorkThread(i, sIndex, eIndex, workThreads[i]);
    }

    // Waiting for threads to finish
    barrier_wait( &barrier );

    // clean threads and GPU
    for (int i = 0; i < noOfThreads; i++) {
        pthread_join(workThreads[i].id, NULL);
    }
    barrier_destroy( &barrier );
    delete[] workThreads;
    releaseBlobTable(); // this also ensures that all work on GPU is done (synchronous call)
    deleteStreams(noOfThreads);
}

processWeights()

void ProgRecFourierGPU::processWeights ( )

protected

Method will in effect do the point-wise division of tempVolume and tempWeights (i.e. correct Fourier coefficients by proper weight)

Definition at line 751 of file reconstruct_fourier_gpu.cpp.

                                       {
    // Get a first approximation of the reconstruction
    float corr2D_3D=pow(padding_factor_proj,2.)/
                     (imgSize* pow(padding_factor_vol,3.));
    for (int z = 0; z <= maxVolumeIndexYZ; z++) {
        for (int y = 0; y <= maxVolumeIndexYZ; y++) {
            for (int x = 0; x <= maxVolumeIndexX; x++) {
                float weight = tempWeights[z][y][x];

                if (weight > ACCURACY)
                    tempVolume[z][y][x] *= corr2D_3D / weight;
                else
                    tempVolume[z][y][x] = 0;
            }
        }
    }
}

produceSideinfo()

void ProgRecFourierGPU::produceSideinfo ( )

protected

Method will fill other help structures and variables

Definition at line 207 of file reconstruct_fourier_gpu.cpp.

{
    // Translate the maximum resolution to digital frequency
    // maxResolution=sampling_rate/maxResolution;
    maxResolutionSqr=maxResolution*maxResolution;

    // Read the input images
    SF.read(fn_in);
    SF.removeDisabled();
    SF.getDatabase()->activateThreadMuting();

    // Ask for memory for the output volume and its Fourier transform
    size_t objId = SF.firstRowId();
    FileName fnImg;
    SF.getValue(MDL_IMAGE,fnImg,objId);
    Image<double> I;
    I.read(fnImg, HEADER);
    int Ydim=YSIZE(I());
    int Xdim=XSIZE(I());
    if (Ydim!=Xdim)
        REPORT_ERROR(ERR_MULTIDIM_SIZE,"This algorithm only works for squared images");
    imgSize=Xdim;
    paddedImgSize = Xdim*padding_factor_vol;
    auto conserveRows = (size_t) ceil((double) paddedImgSize * maxResolution * 2.0);
    conserveRows = (size_t) ceil((double) conserveRows / 2.0);
    maxVolumeIndexX = maxVolumeIndexYZ = 2 * conserveRows;

    // Build a table of blob values
    Fourier_blob_table.resize(BLOB_TABLE_SIZE_SQRT);

    struct blobtype blobFourier,blobnormalized;
    blobFourier=blob;
    blobFourier.radius/=(padding_factor_vol*Xdim);
    blobnormalized=blob;
    blobnormalized.radius/=((double)padding_factor_proj/padding_factor_vol);
    double deltaSqrt     = (blob.radius*blob.radius) /(BLOB_TABLE_SIZE_SQRT-1);
    double deltaFourier  = (sqrt(3.)*Xdim/2.)/(BLOB_TABLE_SIZE_SQRT-1);

    // The interpolation kernel must integrate to 1
    iw0 = 1.0 / blob_Fourier_val(0.0, blobnormalized);
    double padXdim3 = padding_factor_vol * Xdim;
    padXdim3 = padXdim3 * padXdim3 * padXdim3;
    double blobTableSize = blob.radius*sqrt(1./ (BLOB_TABLE_SIZE_SQRT-1));
    for (int i = 0; i < BLOB_TABLE_SIZE_SQRT; i++)
    {
        //use a r*r sample instead of r
        //DIRECT_VEC_ELEM(blob_table,i)         = blob_val(delta*i, blob)  *iw0;
        blobTableSqrt[i] = blob_val(blobTableSize*sqrt((double)i), blob)  *iw0;
        //***
        //DIRECT_VEC_ELEM(fourierBlobTableSqrt,i) =
        //     blob_Fourier_val(fourierBlobTableSize*sqrt(i), blobFourier)*padXdim3  *iw0;
        VEC_ELEM(Fourier_blob_table,i) =
            blob_Fourier_val(deltaFourier*i, blobFourier)*padXdim3  *iw0;
        //#define DEBUG
#ifdef DEBUG

        std::cout << VEC_ELEM(Fourier_blob_table,i)
        << " " << VEC_ELEM(fourierBlobTableSqrt,i)
        << std::endl;
#endif
  #undef DEBUG

    }
    //iDelta        = 1/delta;
    iDeltaSqrt    = 1/deltaSqrt;
    iDeltaFourier = 1/deltaFourier;

    // Get symmetries
    Matrix2D<double>  Identity(3,3);
    Identity.initIdentity();
    R_repository.push_back(Identity);
    if (fn_sym != "")
    {
        SymList SL;
        SL.readSymmetryFile(fn_sym);
        for (int isym = 0; isym < SL.symsNo(); isym++)
        {
            Matrix2D<double>  L(4, 4), R(4, 4);
            SL.getMatrices(isym, L, R);
            R.resize(3, 3);
            R_repository.push_back(R);
        }
    }
}

readParams()

void ProgRecFourierGPU::readParams ( )

protectedvirtual

Read arguments from command line

Reimplemented from XmippProgram.

Definition at line 76 of file reconstruct_fourier_gpu.cpp.

{
    fn_in = getParam("-i");
    fn_out = getParam("-o");
    fn_sym = getParam("--sym");
    do_weights = checkParam("--weight");
    padding_factor_proj = getDoubleParam("--padding", 0);
    padding_factor_vol = getDoubleParam("--padding", 1);
    blob.radius   = getDoubleParam("--blob", 0);
    blob.order    = getIntParam("--blob", 1);
    blob.alpha    = getDoubleParam("--blob", 2);
    useFast       = checkParam("--fast");
    parseNoOfThreads();
    device = getIntParam("--device");
    fftOnGPU      = checkParam("--fftOnGPU");
    maxResolution = getDoubleParam("--max_resolution");
    useCTF = checkParam("--useCTF");
    isPhaseFlipped = checkParam("--phaseFlipped");
    minCTF = getDoubleParam("--minCTF");
    if (useCTF)
        iTs = 1 / getDoubleParam("--sampling");
    bufferSize = getIntParam("--bufferSize");
}

releaseTempSpaces()

void ProgRecFourierGPU::releaseTempSpaces ( )

protected

Method will release temporal spaces for weights and Fourier coefs.

Definition at line 874 of file reconstruct_fourier_gpu.cpp.

                                          {
    release(tempWeights, maxVolumeIndexYZ+1, maxVolumeIndexYZ+1);
    release(tempVolume, maxVolumeIndexYZ+1, maxVolumeIndexYZ+1);
}

run()

void ProgRecFourierGPU::run ( )

virtual

Run the image processing. Method will load data, process them and store result to final destination.

Reimplemented from XmippProgram.

Definition at line 179 of file reconstruct_fourier_gpu.cpp.

{
    show();
    checkDefines(); // check that there is not a logical error in defines
    produceSideinfo();
    checkMemory();
    if (verbose) {
        init_progress_bar(SF.size());
    }
    //Computing interpolated volume
    processImages(0, SF.size() - 1);
    // Get data from GPU
    getGPUData();
    // remove complex conjugate of the intermediate result
    mirrorAndCropTempSpaces();
    //Saving the volume
    finishComputations(fn_out);
}

setIO()

void ProgRecFourierGPU::setIO ( const FileName &  fn_in, const FileName &  fn_out  )

virtual

Functions of common reconstruction interface

Implements ProgReconsBase.

Definition at line 934 of file reconstruct_fourier_gpu.cpp.

{
    this->fn_in = fn_in;
    this->fn_out = fn_out;
}

show()

void ProgRecFourierGPU::show ( )

protected

Show basic info to standard output

Definition at line 101 of file reconstruct_fourier_gpu.cpp.

{
    if (verbose > 0)
    {
        std::cout << " =====================================================================" << std::endl;
        std::cout << " Direct 3D reconstruction method using Kaiser windows as interpolators" << std::endl;
        std::cout << " =====================================================================" << std::endl;
        std::cout << " Input selfile             : "  << fn_in << std::endl;
        std::cout << " padding_factor_proj       : "  << padding_factor_proj << std::endl;
        std::cout << " padding_factor_vol        : "  << padding_factor_vol << std::endl;
        std::cout << " Output volume             : "  << fn_out << std::endl;
        if (fn_sym != "")
            std::cout << " Symmetry file for projections : "  << fn_sym << std::endl;
        if (do_weights)
            std::cout << " Use weights stored in the image headers or doc file" << std::endl;
        else
            std::cout << " Do NOT use weights" << std::endl;
        if (useCTF)
            std::cout << "Using CTF information" << std::endl
            << "Sampling rate: " << 1 / iTs << std::endl
            << "Phase flipped: " << isPhaseFlipped << std::endl
            << "Minimum CTF: " << minCTF << std::endl;
        std::cout << "\n Interpolation Function"
        << "\n   blrad                 : "  << blob.radius
        << "\n   blord                 : "  << blob.order
        << "\n   blalpha               : "  << blob.alpha
        << "\n max_resolution          : "  << maxResolution
        << "\n -----------------------------------------------------------------" << std::endl;
    }
}

Member Data Documentation

device

int ProgRecFourierGPU::device

protected

CUDA device to use

Definition at line 134 of file reconstruct_fourier_gpu.h.

fn_in

FileName ProgRecFourierGPU::fn_in

protected

Input file name

Definition at line 92 of file reconstruct_fourier_gpu.h.

fn_out

FileName ProgRecFourierGPU::fn_out

protected

Output file name

Definition at line 89 of file reconstruct_fourier_gpu.h.

maxVolumeIndexX

int ProgRecFourierGPU::maxVolumeIndexX

protected

maximal index in the temporal volumes, X axis

Definition at line 98 of file reconstruct_fourier_gpu.h.

maxVolumeIndexYZ

int ProgRecFourierGPU::maxVolumeIndexYZ

protected

maximal index in the temporal volumes, Y and Z axis

Definition at line 95 of file reconstruct_fourier_gpu.h.

noOfThreads

int ProgRecFourierGPU::noOfThreads

protected

Holds number of cores available at the host system

Definition at line 131 of file reconstruct_fourier_gpu.h.

SF

MetaDataDb ProgRecFourierGPU::SF

protected

SelFile containing all projections

Definition at line 86 of file reconstruct_fourier_gpu.h.

tempVolume

std::complex<float>*** ProgRecFourierGPU::tempVolume = NULL

protected

3D volume holding the cropped (without high frequencies) Fourier space. Lowest frequencies are in the center, i.e. Fourier space creates a sphere within a cube.

Definition at line 105 of file reconstruct_fourier_gpu.h.

tempVolumeGPU

float* ProgRecFourierGPU::tempVolumeGPU = NULL

protected

3D volume holding the cropped (without high frequencies) Fourier space. Lowest frequencies are in the center, i.e. Fourier space creates a sphere within a cube. Valid for GPU, i.e. it is equivalent to tempVolume, which has been flattened Each two successive values represent one complex number

Definition at line 120 of file reconstruct_fourier_gpu.h.

tempWeights

float*** ProgRecFourierGPU::tempWeights = NULL

protected

3D volume holding the weights of the Fourier coefficients stored in tempVolume.

Definition at line 111 of file reconstruct_fourier_gpu.h.

tempWeightsGPU

float* ProgRecFourierGPU::tempWeightsGPU = NULL

protected

3D volume holding the weights of the Fourier coefficients stored in tempVolume. Valid for GPU, i.e. it is equivalent to tempWeights, which has been flattened

Definition at line 127 of file reconstruct_fourier_gpu.h.

workThreads

RecFourierWorkThread* ProgRecFourierGPU::workThreads

protected

Thread used for loading input data

Definition at line 83 of file reconstruct_fourier_gpu.h.

---

The documentation for this class was generated from the following files:

• xmipp/libraries/reconstruction_adapt_cuda/reconstruct_fourier_gpu.h
• xmipp/libraries/reconstruction_adapt_cuda/reconstruct_fourier_gpu.cpp