#include <cuda_volume_halves_restorator.h>

Classes
struct	Builder

Public Member Functions
	VolumeHalvesRestorator (int verbosity, unsigned denoisingIters, unsigned deconvolutionIters, T sigma, T lambda, unsigned differenceIters, T Kdiff, T bankStep, T bankOverlap, unsigned weightFun, T weightPower)

void	apply (const MultidimArray< T > &volume1, const MultidimArray< T > &volume2, const int *mask)

const MultidimArray< T > &	getReconstructedVolume1 () const

const MultidimArray< T > &	getReconstructedVolume2 () const

const MultidimArray< T > &	getFilterBankVolume () const

const MultidimArray< T > &	getDeconvolvedS () const

const MultidimArray< T > &	getConvolvedS () const

const MultidimArray< T > &	getAverageDifference () const

Public Attributes
struct {
T * d_R2

Complex * d_fVol

Complex * d_fV1

Complex * d_fV2

size_t fourier_size

}	restorationPointers

Friends
std::ostream &	operator<< (std::ostream &out, const VolumeHalvesRestorator &r)

Detailed Description

template<typename T>
class VolumeHalvesRestorator< T >

Definition at line 41 of file cuda_volume_halves_restorator.h.

Constructor & Destructor Documentation

◆ VolumeHalvesRestorator()

template<typename T>

VolumeHalvesRestorator< T >::VolumeHalvesRestorator	(	int	verbosity,
		unsigned	denoisingIters,
		unsigned	deconvolutionIters,
		T	sigma,
		T	lambda,
		unsigned	differenceIters,
		T	Kdiff,
		T	bankStep,
		T	bankOverlap,
		unsigned	weightFun,
		T	weightPower
	)

inline

Definition at line 135 of file cuda_volume_halves_restorator.h.

     : verbosity(verbosity)
     , denoisingIters(denoisingIters)
     , deconvolutionIters(deconvolutionIters)
     , sigma(sigma)
     , lambda(lambda)
     , differenceIters(differenceIters)
     , Kdiff(Kdiff)
     , bankStep(bankStep)
     , bankOverlap(bankOverlap)
     , weightFun(weightFun)
     , weightPower(weightPower) {}

Member Function Documentation

◆ apply()

template<typename T >

void VolumeHalvesRestorator< T >::apply	(	const MultidimArray< T > &	volume1,
		const MultidimArray< T > &	volume2,
		const int *	mask
	)

Definition at line 345 of file cuda_volume_halves_restorator.cpp.

                                                                                                                        {
     setSizes(volume1);
     createFFTPlans();
     initializeFilter();
 
     T* d_volume1;
     T* d_volume2;
     int* d_mask = nullptr;
 
     gpuErrchk( cudaMalloc(&d_volume1, memsize) );
     gpuErrchk( cudaMalloc(&d_volume2, memsize) );
     if (mask) {
         gpuErrchk( cudaMalloc(&d_mask, volume_size * sizeof(int)) );
     }
 
     gpuErrchk( cudaMemcpy(d_volume1, volume1.data, memsize, cudaMemcpyHostToDevice) );
     gpuErrchk( cudaMemcpy(d_volume2, volume2.data, memsize, cudaMemcpyHostToDevice) );
     if (mask) {
         gpuErrchk( cudaMemcpy(d_mask, mask, volume_size * sizeof(int), cudaMemcpyHostToDevice) );
     }
 
     gpuErrchk( cudaMalloc(&d_buf1, memsize) );
     gpuErrchk( cudaMalloc(&d_buf2, memsize) );
     gpuErrchk( cudaMalloc(&d_cbuf1, fourier_memsize) );
     gpuErrchk( cudaMalloc(&d_cbuf2, fourier_memsize) );
 
     denoise(d_volume1, d_volume2, d_mask);
     deconvolution(d_volume1, d_volume2);
     filterBank(d_volume1, d_volume2);
     difference(d_volume1, d_volume2, d_mask);
 
     reconstructedVolume1.resize(zdim, ydim, xdim);
     gpuErrchk( cudaMemcpy(reconstructedVolume1.data, d_volume1, memsize, cudaMemcpyDeviceToHost) );
     reconstructedVolume2.resize(zdim, ydim, xdim);
     gpuErrchk( cudaMemcpy(reconstructedVolume2.data, d_volume2, memsize, cudaMemcpyDeviceToHost) );
 
     gpuErrchk( cudaFree(d_R2) );
     gpuErrchk( cudaFree(d_mask) );
     gpuErrchk( cudaFree(d_buf1) );
     gpuErrchk( cudaFree(d_buf2) );
     gpuErrchk( cudaFree(d_cbuf1) );
     gpuErrchk( cudaFree(d_cbuf2) );
     CudaFFT<T>::release(planForward);
     CudaFFT<T>::release(planBackward);
 }

◆ getAverageDifference()

template<typename T>

const MultidimArray<T>& VolumeHalvesRestorator< T >::getAverageDifference ( ) const

inline

Definition at line 163 of file cuda_volume_halves_restorator.h.

163 { return averageDifference; }

◆ getConvolvedS()

template<typename T>

const MultidimArray<T>& VolumeHalvesRestorator< T >::getConvolvedS ( ) const

inline

Definition at line 162 of file cuda_volume_halves_restorator.h.

162 { return convolvedS; }

◆ getDeconvolvedS()

template<typename T>

const MultidimArray<T>& VolumeHalvesRestorator< T >::getDeconvolvedS ( ) const

inline

Definition at line 161 of file cuda_volume_halves_restorator.h.

161 { return deconvolvedS; }

◆ getFilterBankVolume()

template<typename T>

const MultidimArray<T>& VolumeHalvesRestorator< T >::getFilterBankVolume ( ) const

inline

Definition at line 160 of file cuda_volume_halves_restorator.h.

160 { return filterBankVolume; }

◆ getReconstructedVolume1()

template<typename T>

const MultidimArray<T>& VolumeHalvesRestorator< T >::getReconstructedVolume1 ( ) const

inline

Definition at line 158 of file cuda_volume_halves_restorator.h.

158 { return reconstructedVolume1; }

◆ getReconstructedVolume2()

template<typename T>

const MultidimArray<T>& VolumeHalvesRestorator< T >::getReconstructedVolume2 ( ) const

inline

Definition at line 159 of file cuda_volume_halves_restorator.h.

159 { return reconstructedVolume2; }

Friends And Related Function Documentation

◆ operator<<

template<typename T>

std::ostream& operator<<	(	std::ostream &	out,
		const VolumeHalvesRestorator< T > &	r
	)

friend

Definition at line 119 of file cuda_volume_halves_restorator.h.

                                                                                      {
         out << "VolumeHalvesRestoration parameters:" << std::endl
         << "    Denoising Iterations:" << r.denoisingIters << std::endl
         << "    Deconvolution Iterations: " << r.deconvolutionIters << std::endl
         << "    Sigma0:   " << r.sigma << std::endl
         << "    Lambda:   " << r.lambda << std::endl
         << "    Bank step:" << r.bankStep << std::endl
         << "    Bank overlap:" << r.bankOverlap << std::endl
         << "    Weight fun:" << r.weightFun << std::endl
         << "    Weight power:" << r.weightPower << std::endl
         << "    Difference Iterations: " << r.differenceIters << std::endl
         << "    Kdiff: " << r.Kdiff << std::endl
         ;
         return out;
     }