nn4_ctfws Direct Fourier Weighted Inversion Reconstructor for sorting More...

#include <reconstructor.h>

Inheritance diagram for EMAN::nn4_ctfwsReconstructor:

Collaboration diagram for EMAN::nn4_ctfwsReconstructor:

[legend]

Public Member Functions
	nn4_ctfwsReconstructor ()

	nn4_ctfwsReconstructor (const string &symmetry, int size, int npad, float snr, int sign, int do_ctf)

virtual	~nn4_ctfwsReconstructor ()

virtual void	setup ()
	Initialize the reconstructor. More...

virtual int	insert_slice (const EMData *const slice, const Transform &euler, const float weight)
	Insert a slice into a 3D volume, in a given orientation. More...

virtual EMData *	finish (bool compensate=true)
	Finish reconstruction and return the complete model. More...

virtual string	get_name () const
	Get the unique name of this class (especially for factory based instantiation access) More...

virtual string	get_desc () const
	Get a clear, concise description of this class. More...

TypeDict	get_param_types () const

void	setup (const string &symmetry, int size, int npad, float snr, int sign, int do_ctf)

int	insert_padfft_slice_weighted (EMData padfft, EMData ctf2d2, vector< float > bckgnoise, const Transform &trans, const float weight)

Public Member Functions inherited from EMAN::Reconstructor
	Reconstructor ()

virtual	~Reconstructor ()

virtual void	setup_seed (EMData *seed, float seed_weight)
	Initialize the reconstructor with a seed volume. More...

virtual void	setup_seedandweights (EMData seed, EMData weight)
	Initialize the reconstructor with a seed volume, as above. More...

virtual EMData *	preprocess_slice (const EMData *const slice, const Transform &t=Transform())
	While you can just insert unprocessed slices, if you call preprocess_slice yourself, and insert the returned slice instead, repeatedly, it can save a fair bit of computation. More...

int	insert_slice (const EMData *const slice, const Transform &euler)

virtual int	determine_slice_agreement (EMData *slice, const Transform &euler, const float weight=1.0, bool sub=true)
	Compares a slice to the current reconstruction volume and computes a normalization factor and quality. More...

virtual EMData *	projection (const Transform &euler, int ret_fourier=1)
	This will create a projection from the current reconstruction. More...

virtual void	clear ()
	set the volume and tmp_volume data to zero, for use in Monte Carlo reconstructors More...

void	print_params () const
	Print the current parameters to std::out. More...

EMObject &	operator[] (const string &key)

Public Member Functions inherited from EMAN::FactoryBase
	FactoryBase ()

virtual	~FactoryBase ()

Dict	get_params () const
	get a copy of the parameters of this class More...

void	set_params (const Dict &new_params)
	Set new parameters. More...

void	set_param (const string key, const EMObject val)

void	insert_params (const Dict &new_params)
	Insert parameters. More...

Dict	copy_relevant_params (const FactoryBase *const that) const

Static Public Member Functions
static Reconstructor *	NEW ()

Static Public Attributes
static const string	NAME = "nn4_ctfws"

Private Member Functions
void	buildFFTVolume ()

void	buildNormVolume ()

Private Attributes
EMData *	m_volume

EMData *	m_wptr

EMData *	m_refvol

int	m_vnx

int	m_vny

int	m_vnz

int	m_vnzp

int	m_vnyp

int	m_vnxp

int	m_vnxc

int	m_vnyc

int	m_vnzc

int	m_npad

int	m_sign

int	m_varsnr

int	m_weighting

float	m_wghta

float	m_wghtb

float	m_snr

string	m_symmetry

int	m_nsym

int	m_do_ctf

Additional Inherited Members
Protected Attributes inherited from EMAN::FactoryBase
Dict	params
	This is the dictionary the stores the parameters of the object. More...

Detailed Description

nn4_ctfws Direct Fourier Weighted Inversion Reconstructor for sorting

Definition at line 1459 of file reconstructor.h.

Constructor & Destructor Documentation

◆ nn4_ctfwsReconstructor() [1/2]

nn4_ctfwsReconstructor::nn4_ctfwsReconstructor ( )

Definition at line 5073 of file reconstructor.cpp.

{
        m_volume  = NULL;
        m_wptr    = NULL;
}

References m_volume, and m_wptr.

Referenced by NEW().

◆ nn4_ctfwsReconstructor() [2/2]

nn4_ctfwsReconstructor::nn4_ctfwsReconstructor	(	const string &	symmetry,
		int	size,
		int	npad,
		float	snr,
		int	sign,
		int	do_ctf
	)

Definition at line 5079 of file reconstructor.cpp.

{
        setup( symmetry, size, npad, snr, sign, do_ctf );
}

References setup().

◆ ~nn4_ctfwsReconstructor()

nn4_ctfwsReconstructor::~nn4_ctfwsReconstructor ( )

virtual

Definition at line 5084 of file reconstructor.cpp.

{
 
        //if( m_delete_weight ) checked_delete( m_wptr );
 
        //checked_delete( m_result );
}

Member Function Documentation

◆ buildFFTVolume()

void nn4_ctfwsReconstructor::buildFFTVolume ( )

private

Definition at line 5147 of file reconstructor.cpp.

                                            {
        int offset = 2 - m_vnxp%2;
 
        m_volume = params["fftvol"];
        m_volume->get_data();
        /*
        if (m_npad ==0) m_npad = m_volume->get_attr("npad");
        else { 
            int tmp_npad = m_volume->get_attr("npad");
            if (m_npad != tmp_npad)  m_npad = m_volume->get_attr("npad");
                }
        */
        if ( m_vnxp % 2 == 0 )  m_volume->set_fftodd(0);
        else                    m_volume->set_fftodd(1);
        m_volume->set_complex(true);
        m_volume->set_ri(true);
        m_volume->set_fftpad(true);
        m_volume->set_array_offsets(0,1,1);
 
/*
        if( m_volume->get_xsize() != m_vnxp+offset && m_volume->get_ysize() != m_vnyp && m_volume->get_zsize() != m_vnzp ) {
                m_volume->set_size(m_vnxp+offset,m_vnyp,m_vnzp);
                m_volume->to_zero();
        }
 
        if ( m_vnxp % 2 == 0 )  m_volume->set_fftodd(0);
        else                    m_volume->set_fftodd(1);
        m_volume->set_nxc(m_vnxp/2);
        m_volume->set_complex(true);
        m_volume->set_ri(true);
        m_volume->set_fftpad(true);
        m_volume->set_attr("npad", m_npad);
        m_volume->set_array_offsets(0,1,1);
        
        */
}

References m_vnxp, m_volume, and EMAN::FactoryBase::params.

Referenced by setup().

◆ buildNormVolume()

void nn4_ctfwsReconstructor::buildNormVolume ( )

private

Definition at line 5184 of file reconstructor.cpp.

{
        m_wptr = params["weight"];
        m_wptr->get_data();
        m_wptr->set_array_offsets(0,1,1);
/*
        if( m_wptr->get_xsize() != m_vnxc+1 && m_wptr->get_ysize() != m_vnyp && m_wptr->get_zsize() != m_vnzp ) {
               m_wptr->set_size(m_vnxc+1,m_vnyp,m_vnzp);
               m_wptr->to_zero();
        }
 
        m_wptr->set_array_offsets(0,1,1);
*/
}

References m_wptr, and EMAN::FactoryBase::params.

Referenced by setup().

◆ finish()

EMData * nn4_ctfwsReconstructor::finish ( bool doift = true )

virtual

Finish reconstruction and return the complete model.

Parameters

doift A flag indicating whether the returned object should be guaranteed to be in real-space (true) or should be left in whatever space the reconstructor generated

Returns: The result 3D model.

Reimplemented from EMAN::Reconstructor.

Definition at line 5286 of file reconstructor.cpp.

{
        m_volume->set_array_offsets(0, 1, 1);
        m_wptr->set_array_offsets(0, 1, 1);
        m_refvol->set_array_offsets(0, 1, 1);
        if(m_volume->is_fftodd())       m_volume->symplane0_odd(m_wptr);
        else                                            m_volume->symplane0_ctf(m_wptr);
        bool do_invert = false;
        bool refvol_present = (*m_refvol)(0) > 0.0f ;
        /*
        int box = 7;
        int vol = box*box*box;
        int kc = (box-1)/2;
        vector< float > pow_a( 3*kc+1, 1.0 );
        for( unsigned int i=1; i < pow_a.size(); ++i ) pow_a[i] = pow_a[i-1] * exp(m_wghta);
        pow_a[3*kc]=0.0;
 
 
        float max = max3d( kc, pow_a );
        float alpha = ( 1.0f - 1.0f/(float)vol ) / max;
        float osnr = 1.0f/m_snr;
        */
 
 
        int ix,iy,iz;
        //  refvol carries fsc
        int  limitres = m_vnyc-1;
        if( refvol_present )  { // If fsc is set to zero, it will be straightforward reconstruction with snr = 1
                for (ix = 0; ix < m_vnyc; ix++) {
                                //cout<<"  fsc  "<< m_vnyc-ix-1 <<"   "<<m_vnyc<<"   "<<(*m_refvol)(m_vnyc-ix-1)<<endl;
                          if( (*m_refvol)(m_vnyc-ix-1) == 0.0f )  limitres = m_vnyc-ix-2;
                }
        } else {
//cout<<"   limitres   "<<limitres<<endl;
 
                vector<float> count(m_vnyc+1, 0.0f);
                vector<float> sigma2(m_vnyc+1, 0.0f);
 
                //  compute sigma2
                for (iz = 1; iz <= m_vnzp; iz++) {
                        int   izp = (iz<=m_vnzc) ? iz - 1 : iz-m_vnzp-1;
                        float argz = float(izp*izp);
                        for (iy = 1; iy <= m_vnyp; iy++) {
                                int   iyp = (iy<=m_vnyc) ? iy - 1 : iy-m_vnyp-1;
                                float argy = argz + float(iyp*iyp);
                                for (ix = 0; ix <= m_vnxc; ix++) {
                                        if(ix>0 || (izp>=0 && (iyp>=0 || izp!=0))) {  //Skip Friedel related values
                                                float r = std::sqrt(argy + float(ix*ix));
                                                int  ir = int(r);
                                                if (ir <= limitres) {
                                                        float frac = r - float(ir);
                                                        float qres = 1.0f - frac;
                                                        float temp = (*m_wptr)(ix,iy,iz);
                                                        //cout<<" WEIGHTS "<<jx<<"  "<<jy<<"  "<<ir<<"  "<<temp<<"  "<<frac<<endl;
                                                        //cout<<" WEIGHTS "<<ix<<"  "<<iy-1<<"  "<<iz-1<<"  "<<temp<<"  "<<endl;
                                                        sigma2[ir]   += temp*qres;
                                                        sigma2[ir+1] += temp*frac;
                                                        count[ir]    += qres;
                                                        count[ir+1]  += frac;
                                                }
                                        }
                                }
                        }
                }
                for (ix = 0; ix <= m_vnyc; ix++) {
                        if( count[ix] > 0.0f )  (*m_refvol)(ix) = sigma2[ix]/count[ix];
                        //cout<<"  sigma2  "<< ix <<"   "<<sigma2[ix]<<endl;
                }
                /*
                #  This part will have to be done on python level.
                float fudge = m_refvol->get_attr("fudge");
                // now counter will serve to keep fsc-derived stuff
                for (ix = 0; ix <= limitres; ix++)  count[ix] = fudge * sigma2[ix] * (1.0f - (*m_refvol)(ix))/(*m_refvol)(ix);  //fudge?
                count[limitres+1] = count[limitres];
                //for (ix = 0; ix <= limitres+1; ix++)  cout<<"  tau2  "<< ix <<"   "<<count[ix]<<endl;
                */
        
        }
 
 
        // normalize
        float osnr = 0.0f;
        for (iz = 1; iz <= m_vnzp; iz++) {
                int   izp = (iz<=m_vnzc) ? iz - 1 : iz-m_vnzp-1;
                float argz = float(izp*izp);
                for (iy = 1; iy <= m_vnyp; iy++) {
                        int   iyp = (iy<=m_vnyc) ? iy - 1 : iy-m_vnyp-1;
                        float argy = argz + float(iyp*iyp);
                        for (ix = 0; ix <= m_vnxc; ix++) {
                                float r = std::sqrt(argy + float(ix*ix));
                                int  ir = int(r);
                                if (ir <= limitres) {
                                        if ( (*m_wptr)(ix,iy,iz) > 0.0f) {
                                                if( refvol_present) {
                                                        float frac = r - float(ir);
                                                        float qres = 1.0f - frac;
                                                        osnr = qres*(*m_refvol)(ir) + frac*(*m_refvol)(ir+1);
                                                        //if(osnr == 0.0f)  osnr = 1.0f/(0.001*(*m_wptr)(ix,iy,iz));
                                                        //cout<<"  "<<iz<<"   "<<iy<<"   "<<"   "<<ix<<"   "<<ir<<"   "<<(*m_wptr)(ix,iy,iz)<<"   "<<osnr<<"      "<<(*m_volume)(2*ix,iy,iz)<<"      "<<(*m_volume)(2*ix+1,iy,iz)<<endl;
                                                }  else osnr = 0.0f;
 
                                                float tmp = ((*m_wptr)(ix,iy,iz)+osnr);
 
                                                if(do_invert){
                                                        if(tmp>0.0f) {
                                                        //cout<<" mvol "<<ix<<"  "<<iy<<"  "<<iz<<"  "<<(*m_volume)(2*ix,iy,iz)<<"  "<<(*m_volume)(2*ix+1,iy,iz)<<"  "<<tmp<<"  "<<osnr<<endl;
                                                                (*m_volume)(2*ix,iy,iz)   /= tmp;
                                                                (*m_volume)(2*ix+1,iy,iz) /= tmp;
                                                        } else {
                                                                (*m_volume)(2*ix,iy,iz)   = 0.0f;
                                                                (*m_volume)(2*ix+1,iy,iz) = 0.0f;
                                                        }
                                                }  else (*m_wptr)(ix,iy,iz) = tmp;
                                        }
                                } else {
                                        (*m_volume)(2*ix,iy,iz)   = 0.0f;
                                        (*m_volume)(2*ix+1,iy,iz) = 0.0f;
                                }
                        }
                }
        }
 
        if(do_invert)  {
                m_volume->center_origin_fft();
                // back fft
                m_volume->do_ift_inplace();
                int npad = m_volume->get_attr("npad");
                m_volume->depad();
                if( compensate )  circumftrl( m_volume, npad );
                m_volume->set_array_offsets( 0, 0, 0 );
        }
 
        return 0;
}

References circumftrl(), m_refvol, m_vnxc, m_vnyc, m_vnyp, m_vnzc, m_vnzp, m_volume, m_wptr, and sqrt().

◆ get_desc()

virtual string EMAN::nn4_ctfwsReconstructor::get_desc ( ) const

inlinevirtual

Get a clear, concise description of this class.

Returns: a clear, concise description of this class

Implements EMAN::FactoryBase.

Definition at line 1488 of file reconstructor.h.

                {
                        return "Direct Fourier inversion reconstruction routine";
                }

◆ get_name()

virtual string EMAN::nn4_ctfwsReconstructor::get_name ( ) const

inlinevirtual

Get the unique name of this class (especially for factory based instantiation access)

Returns: the unique name of this class

Implements EMAN::FactoryBase.

Definition at line 1483 of file reconstructor.h.

                {
                        return NAME;
                }

References NAME.

◆ get_param_types()

TypeDict EMAN::nn4_ctfwsReconstructor::get_param_types ( ) const

inlinevirtual

Returns: a TypeDict defining and describing the feasible parameters of this class

Implements EMAN::FactoryBase.

Definition at line 1499 of file reconstructor.h.

                {
                        TypeDict d;
                        d.put("size",           EMObject::INT);
                        d.put("npad",           EMObject::INT);
                        d.put("sign",           EMObject::INT);
                        d.put("symmetry",       EMObject::STRING);
                        d.put("snr",            EMObject::FLOAT);
                        d.put("fftvol",         EMObject::EMDATA);
                        d.put("weight",         EMObject::EMDATA);
                        d.put("refvol",         EMObject::EMDATA);
                        d.put("weighting",  EMObject::INT);
                        d.put("varsnr",     EMObject::INT);
                        d.put("do_ctf",     EMObject::INT);
                        return d;
                }

References EMAN::EMObject::EMDATA, EMAN::EMObject::FLOAT, EMAN::EMObject::INT, EMAN::TypeDict::put(), and EMAN::EMObject::STRING.

◆ insert_padfft_slice_weighted()

int nn4_ctfwsReconstructor::insert_padfft_slice_weighted	(	EMData *	padfft,
		EMData *	ctf2d2,
		vector< float >	bckgnoise,
		const Transform &	trans,
		const float	weight
	)

Definition at line 5263 of file reconstructor.cpp.

{
        Assert( padfft != NULL );
 
        vector<float> abc_list;
        int abc_list_len = 0;   
        if (m_volume->has_attr("smear")) {
                abc_list = m_volume->get_attr("smear");
                abc_list_len = abc_list.size();
        }
 
        vector<Transform> tsym = t.get_sym_proj(m_symmetry);
        for (unsigned int isym=0; isym < tsym.size(); isym++) {
                if (abc_list_len == 0)
                        m_volume->nn_ctfw(m_wptr, padfft, ctf2d2, m_npad, bckgnoise, tsym[isym], weight);
                else
                        for (int i = 0; i < abc_list_len; i += 4) 
                                m_volume->nn_ctfw(m_wptr, padfft, ctf2d2, m_npad, bckgnoise, tsym[isym] * Transform(Dict("type", "SPIDER", "phi",  abc_list[i], "theta", abc_list[i+1], "psi", abc_list[i+2])), weight * abc_list[i+3]);
        }
        return 0;
}

References Assert, EMAN::Transform::get_sym_proj(), m_npad, m_symmetry, m_volume, and m_wptr.

Referenced by insert_slice().

◆ insert_slice()

int nn4_ctfwsReconstructor::insert_slice	(	const EMData *const	slice,
		const Transform &	euler,
		const float	weight
	)

virtual

Insert a slice into a 3D volume, in a given orientation.

Returns: 0 if successful, 1 otherwise

Parameters

slice	the image slice to be inserted into the 3D volume
euler	Euler angle of this image slice.
weight	A weighting factor for this slice, generally the number of particles in a class-average. May be ignored by some reconstructors

Returns: 0 if OK. 1 if error.

Exceptions

NullPointerException	if the input EMData pointer is null
ImageFormatException	if the image is complex as opposed to real

Reimplemented from EMAN::Reconstructor.

Definition at line 5199 of file reconstructor.cpp.

{
        // sanity checks
        if (!slice) {
                LOGERR("try to insert NULL slice");
                return 1;
        }
        if(weight !=0.0f) {
                /*
                int buffed = slice->get_attr_default( "buffed", 0 );
                        if( buffed > 0 ) {
                                insert_buffed_slice( slice, weight );
                                return 0;
                        }
                */
 
                EMData* padfft = padfft_slice( slice, t, m_npad );
 
                EMData* ctf2d = NULL;
                if( m_do_ctf == 1 ) {
                        float tmp = padfft->get_attr_default("ctf_applied", 0);
                        int   ctf_applied = (int) tmp;
 
                        // Generate 2D CTF (EMData object)
                        //ctf_store_real::init( padfft->get_ysize(), padfft->get_attr( "ctf" ) );
                   int winsize = padfft->get_ysize();
                   Ctf* ctf = padfft->get_attr( "ctf" );
                   Dict params = ctf->to_dict();        
                   ctf2d = Util::ctf_img_real(winsize , winsize, 1, params["defocus"], params["apix"],params["voltage"], params["cs"], \
                           params["ampcont"], params["bfactor"], params["dfdiff"], params["dfang"], 1);
                        params.clear();
                        if(ctf) {delete ctf; ctf=0;}
                        //ctf2d = ctf_store_real::get_ctf_real(); //This is in 2D projection plane
                        int nx=ctf2d->get_xsize(),ny=ctf2d->get_ysize(),nz=ctf2d->get_zsize();
                        float *ctf2d_ptr  = ctf2d->get_data();
 
                        size_t size = (size_t)nx*ny*nz;
                        if (!ctf_applied) {
                                for (int i = 0; i < size; ++i) padfft->cmplx(i) *= ctf2d_ptr[i]; // Multiply padfft by CTF
                        }
 
                        for (int i = 0; i < size; ++i) ctf2d_ptr[i] *= ctf2d_ptr[i];     // Squared 2D CTF
                } else {
                        int nx=padfft->get_xsize(),ny=padfft->get_ysize(),nz=padfft->get_zsize();
                        ctf2d = new EMData();
                        ctf2d->set_size(nx/2,ny,nz);
                        float *ctf2d_ptr  = ctf2d->get_data();
                        size_t size = (size_t)nx*ny*nz/2;
                        for (int i = 0; i < size; ++i) ctf2d_ptr[i] = 1.0;
                }
 
                vector<float> bckgnoise;
                bckgnoise = slice->get_attr("bckgnoise");
 
                insert_padfft_slice_weighted(padfft, ctf2d, bckgnoise, t, weight);
 
                checked_delete( ctf2d );
                checked_delete( padfft );
                bckgnoise.clear();
 
        }
        return 0;
}

References checked_delete(), EMAN::Dict::clear(), insert_padfft_slice_weighted(), LOGERR, m_do_ctf, m_npad, EMAN::padfft_slice(), EMAN::FactoryBase::params, and EMAN::Ctf::to_dict().

◆ NEW()

static Reconstructor * EMAN::nn4_ctfwsReconstructor::NEW ( )

inlinestatic

Definition at line 1493 of file reconstructor.h.

                {
                        return new nn4_ctfwsReconstructor();
                }

References nn4_ctfwsReconstructor().

◆ setup() [1/2]

void nn4_ctfwsReconstructor::setup ( )

virtual

Initialize the reconstructor.

Implements EMAN::Reconstructor.

Definition at line 5093 of file reconstructor.cpp.

{
        //if(!params.has_key("size")) throw std::logic_error("Error: image size is not given");
        int size = params.has_key("size")? int(params["size"]): 0;
        int npad = params.has_key("npad")? int(params["npad"]): 2;
        // int sign = params.has_key("sign") ? int(params["sign"]) : 1;
        int sign = 1;
        string symmetry = params.has_key("symmetry")? params["symmetry"].to_str() : "c1";
        float  snr = params["snr"];
        int do_ctf = params["do_ctf"];
        setup( symmetry, size, npad, snr, sign, do_ctf );
}

References EMAN::Dict::has_key(), EMAN::FactoryBase::params, and setup().

Referenced by nn4_ctfwsReconstructor(), and setup().

◆ setup() [2/2]

void nn4_ctfwsReconstructor::setup	(	const string &	symmetry,
		int	size,
		int	npad,
		float	snr,
		int	sign,
		int	do_ctf
	)

Definition at line 5106 of file reconstructor.cpp.

{
        m_weighting = ESTIMATE;
        
                 /*     if( params.has_key("weighting") ) {
                                if( int( params["weighting"])==0) m_weighting = NONE;
                        } */
 
        m_wghta = 0.2f;
        m_wghtb = 0.004f;
 
        m_symmetry = symmetry;
        if (npad!=0) m_npad = npad;
        else m_npad = 0;
        m_sign = sign;
        m_nsym = Transform::get_nsym(m_symmetry);
        m_do_ctf = do_ctf;
 
        m_snr = snr;
 
        m_vnx = size;
        m_vny = size;
        m_vnz = size;
 
        //m_vnxp = size*npad;
        //m_vnyp = size*npad;
        //m_vnzp = size*npad;
        m_vnxp = size;
        m_vnyp = size;
        m_vnzp = size;
 
        m_vnxc = m_vnxp/2;
        m_vnyc = m_vnyp/2;
        m_vnzc = m_vnzp/2;
 
        buildFFTVolume();
        buildNormVolume();
        m_refvol = params["refvol"];
        m_refvol->get_data();
}

References buildFFTVolume(), buildNormVolume(), ESTIMATE, EMAN::Transform::get_nsym(), m_do_ctf, m_npad, m_nsym, m_refvol, m_sign, m_snr, m_symmetry, m_vnx, m_vnxc, m_vnxp, m_vny, m_vnyc, m_vnyp, m_vnz, m_vnzc, m_vnzp, m_weighting, m_wghta, m_wghtb, and EMAN::FactoryBase::params.

Member Data Documentation

◆ m_do_ctf

int EMAN::nn4_ctfwsReconstructor::m_do_ctf

private

Definition at line 1540 of file reconstructor.h.

Referenced by insert_slice(), and setup().

◆ m_npad

int EMAN::nn4_ctfwsReconstructor::m_npad

private

Definition at line 1532 of file reconstructor.h.

Referenced by insert_padfft_slice_weighted(), insert_slice(), and setup().

◆ m_nsym

int EMAN::nn4_ctfwsReconstructor::m_nsym

private

Definition at line 1539 of file reconstructor.h.

Referenced by setup().

◆ m_refvol

EMData* EMAN::nn4_ctfwsReconstructor::m_refvol

private

Definition at line 1528 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_sign

int EMAN::nn4_ctfwsReconstructor::m_sign

private

Definition at line 1533 of file reconstructor.h.

Referenced by setup().

◆ m_snr

float EMAN::nn4_ctfwsReconstructor::m_snr

private

Definition at line 1537 of file reconstructor.h.

Referenced by setup().

◆ m_symmetry

string EMAN::nn4_ctfwsReconstructor::m_symmetry

private

Definition at line 1538 of file reconstructor.h.

Referenced by insert_padfft_slice_weighted(), and setup().

◆ m_varsnr

int EMAN::nn4_ctfwsReconstructor::m_varsnr

private

Definition at line 1534 of file reconstructor.h.

◆ m_vnx

int EMAN::nn4_ctfwsReconstructor::m_vnx

private

Definition at line 1529 of file reconstructor.h.

Referenced by setup().

◆ m_vnxc

int EMAN::nn4_ctfwsReconstructor::m_vnxc

private

Definition at line 1531 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_vnxp

int EMAN::nn4_ctfwsReconstructor::m_vnxp

private

Definition at line 1530 of file reconstructor.h.

Referenced by buildFFTVolume(), and setup().

◆ m_vny

int EMAN::nn4_ctfwsReconstructor::m_vny

private

Definition at line 1529 of file reconstructor.h.

Referenced by setup().

◆ m_vnyc

int EMAN::nn4_ctfwsReconstructor::m_vnyc

private

Definition at line 1531 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_vnyp

int EMAN::nn4_ctfwsReconstructor::m_vnyp

private

Definition at line 1530 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_vnz

int EMAN::nn4_ctfwsReconstructor::m_vnz

private

Definition at line 1529 of file reconstructor.h.

Referenced by setup().

◆ m_vnzc

int EMAN::nn4_ctfwsReconstructor::m_vnzc

private

Definition at line 1531 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_vnzp

int EMAN::nn4_ctfwsReconstructor::m_vnzp

private

Definition at line 1530 of file reconstructor.h.

Referenced by finish(), and setup().

◆ m_volume

EMData* EMAN::nn4_ctfwsReconstructor::m_volume

private

Definition at line 1526 of file reconstructor.h.

Referenced by buildFFTVolume(), finish(), insert_padfft_slice_weighted(), and nn4_ctfwsReconstructor().

◆ m_weighting

int EMAN::nn4_ctfwsReconstructor::m_weighting

private

Definition at line 1535 of file reconstructor.h.

Referenced by setup().

◆ m_wghta

float EMAN::nn4_ctfwsReconstructor::m_wghta

private

Definition at line 1536 of file reconstructor.h.

Referenced by setup().

◆ m_wghtb

float EMAN::nn4_ctfwsReconstructor::m_wghtb

private

Definition at line 1536 of file reconstructor.h.

Referenced by setup().

◆ m_wptr

EMData* EMAN::nn4_ctfwsReconstructor::m_wptr

private

Definition at line 1527 of file reconstructor.h.

Referenced by buildNormVolume(), finish(), insert_padfft_slice_weighted(), and nn4_ctfwsReconstructor().

◆ NAME

const string nn4_ctfwsReconstructor::NAME = "nn4_ctfws"

static

Definition at line 1523 of file reconstructor.h.

Referenced by get_name().

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ nn4_ctfwsReconstructor() [1/2]

◆ nn4_ctfwsReconstructor() [2/2]

◆ ~nn4_ctfwsReconstructor()

Member Function Documentation

◆ buildFFTVolume()

◆ buildNormVolume()

◆ finish()

◆ get_desc()

◆ get_name()

◆ get_param_types()

◆ insert_padfft_slice_weighted()

◆ insert_slice()

◆ NEW()

◆ setup() [1/2]

◆ setup() [2/2]

Member Data Documentation

◆ m_do_ctf

◆ m_npad

◆ m_nsym

◆ m_refvol

◆ m_sign

◆ m_snr

◆ m_symmetry

◆ m_varsnr

◆ m_vnx

◆ m_vnxc

◆ m_vnxp

◆ m_vny

◆ m_vnyc

◆ m_vnyp

◆ m_vnz

◆ m_vnzc

◆ m_vnzp

◆ m_volume

◆ m_weighting

◆ m_wghta

◆ m_wghtb

◆ m_wptr

◆ NAME