ProgCTFBasicParams Class Reference

#include <ctf_estimate_from_psd_base.h>

Inheritance diagram for ProgCTFBasicParams:

Collaboration diagram for ProgCTFBasicParams:

Public Member Functions
	ProgCTFBasicParams ()
void	readParams ()
	Read parameters. More...
void	readBasicParams (XmippProgram *program)
	Read parameters. More...
void	show ()
	Show parameters. More...
void	defineParams ()
	Define Parameters. More...
void	produceSideInfo ()
	Produce side information. More...
void	generate_model_halfplane (int Ydim, int Xdim, MultidimArray< double > &model)
void	generate_model_quadrant (int Ydim, int Xdim, MultidimArray< double > &model)
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	run ()
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 ()

Static Public Member Functions
static void	defineBasicParams (XmippProgram *program)
	Define basic parameters. More...

Public Attributes
FileName	fn_psd
	CTF filename. More...
double	downsampleFactor
	Downsample performed. More...
Image< double >	ctftomodel
	CTF amplitude to model. More...
Image< double >	enhanced_ctftomodel
	CTF amplitude to model. More...
Image< double >	enhanced_ctftomodel_fullsize
	CTF amplitude to model. More...
bool	show_optimization
	Show convergence values. More...
bool	selfEstimation
int	ctfmodelSize
	X dimension of particle projections (-1=the same as the psd) More...
bool	bootstrap
	Bootstrap estimation. More...
bool	refineAmplitudeContrast
	Refine amplitude contrast. More...
bool	fastDefocusEstimate
	Fast defocus estimate. More...
bool	noDefocusEstimate
	No defocus estimate. More...
double	lambdaPhase
	Regularization factor for the phase direction and unwrapping estimates (used in Zernike estimate) More...
int	sizeWindowPhase
	Size of the average window used during phase direction and unwrapping estimates (used in Zernike estimate) More...
double	min_freq
	Minimum frequency to adjust. More...
double	max_freq
	Maximum frequency to adjust. More...
double	Tm
	Sampling rate. More...
double	defocus_range
	Defocus range. More...
double	f1
	Enhancement filter low freq. More...
double	f2
	Enhancement filter high freq. More...
double	enhanced_weight
	Weight of the enhanced image. More...
Matrix1D< double >	adjust
	Set of parameters for the complete adjustment of the CTF. More...
int	modelSimplification
	Model simplification. More...
MultidimArray< double >	x_contfreq
	Frequencies in axes. More...
MultidimArray< double >	y_contfreq
MultidimArray< double >	w_contfreq
MultidimArray< double >	x_digfreq
MultidimArray< double >	y_digfreq
MultidimArray< double >	w_digfreq
MultidimArray< double >	psd_exp_radial
	PSD data. More...
MultidimArray< double >	psd_exp_enhanced_radial
MultidimArray< double >	psd_exp_enhanced_radial_2
MultidimArray< double >	psd_exp_enhanced_radial_derivative
MultidimArray< double >	psd_theo_radial_derivative
MultidimArray< double >	psd_exp_radial_derivative
MultidimArray< double >	psd_theo_radial
MultidimArray< double >	w_digfreq_r_iN
MultidimArray< double >	w_digfreq_r
MultidimArray< std::complex< double > >	psd_fft
std::vector< double >	amplitud
MultidimArray< double >	mask
	Masks. More...
MultidimArray< double >	mask_between_zeroes
MultidimArray< double >	w_count
double	value_th
double	min_freq_psd
double	max_freq_psd
double	max_gauss_freq
int	show_inf
int	action
double	corr13
bool	penalize
int	evaluation_reduction
double	heavy_penalization
double	current_penalty
MultidimArray< double > *	f
Matrix1D< double > *	adjust_params
Public Attributes inherited from XmippProgram
bool	doRun
bool	runWithoutArgs
int	verbose
	Verbosity level. More...
int	debug

Static Public Attributes
static constexpr double	penalty = 32.0

Additional Inherited Members
Protected Member Functions inherited from XmippProgram
void	defineCommons ()
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

Detailed Description

Definition at line 17 of file ctf_estimate_from_psd_base.h.

Constructor & Destructor Documentation

ProgCTFBasicParams()

ProgCTFBasicParams::ProgCTFBasicParams ( )

inline

Definition at line 128 of file ctf_estimate_from_psd_base.h.

    {
    }

Member Function Documentation

defineBasicParams()

void ProgCTFBasicParams::defineBasicParams ( XmippProgram *  program )

static

Define basic parameters.

Definition at line 99 of file ctf_estimate_from_psd_base.cpp.

{
    program->addSeeAlsoLine("ctf_enhance_psd");
    program->addParamsLine("== Downsampling");
    program->addParamsLine(
        "  [--downSamplingPerformed <F=1>] : Downsampling performed to produce this PSD");
    program->addParamsLine(
        "                                  : Note that the output CTF model is referred to the original sampling rate");
    program->addParamsLine(
        "                                  : not the one of the downsampled image.");
    program->addParamsLine("== CTF fit: Optimization constraints");
    program->addParamsLine(
        "   [--min_freq <fmin=0.03>]     : Minimum digital frequency (<0.5) to use in adjust. Its value");
    program->addParamsLine(
        "                                : should be a little lower than the dig. freq. of the first ");
    program->addParamsLine("                                : CTF zero.");
    program->addParamsLine(
        "   [--max_freq <fmax=0.35>]     : Maximum digital frequency (<0.5) to use in adjust.");
    program->addParamsLine(
        "                                : It should be higher than the last zero of the CTF.");
    program->addParamsLine(
        "   [--fastDefocus <lambda=2> <size=10>] : Estimate first defocus with Zernike polynomials");
    program->addParamsLine(
        "                                :+Lambda is a regularization factor used during the estimation of the CTF phase");
    program->addParamsLine(
        "                                :+During the estimation, the phase values are averaged within a window of this size");
    program->addParamsLine(
        "   [--noDefocus]                : No defocus estimation");
    program->addParamsLine(
        "   [--defocus_range <D=8000>]   : Defocus range in Angstroms");
    program->addParamsLine(
        "   [--refine_amplitude_contrast]  : Refine amplitude contrast with respect to the input one");
    program->addParamsLine(
        "   [--show_optimization+]       : Show optimization process");
    program->addParamsLine(
        "   [--radial_noise++]           : By default, noise is astigmatic");
    program->addParamsLine(
        "   [--enhance_weight++ <w=1>]   : Weight of the enhanced term");
    program->addParamsLine(
        "   [--model_simplification++ <s=0>]: 0 (no simplification)");
    program->addParamsLine(
        "                                : 1 (simplified envelope)");
    program->addParamsLine(
        "                                : 2 (last Gaussian removal)");
    program->addParamsLine(
        "                                : 3 (symmetric intermediate Gaussian)");
    program->addParamsLine(
        "   [--bootstrapFit++ <N=-1>]    : Perform bootstrap fit (Fourier pixels are randomly chosen)");
    program->addParamsLine(
        "                                : This is used to test the variability of the fit");
    program->addParamsLine(
        "                                : N defines the number of times the fit is repeated");
    program->addParamsLine("==+ CTF fit: Output CTF models");
    program->addParamsLine(
        "   [--ctfmodelSize <size=256>]  : Size for the ctfmodel thumbnails");
    program->addParamsLine("==+ PSD enhancement");
    program->addParamsLine(
        "   [--enhance_min_freq <f1>]    : Bandpass cutoff. Normalized to 0.5");
    program->addParamsLine(
        "                                : If fmax>0.35, f1 default=0.01");
    program->addParamsLine(
        "                                : If fmax<0.35, f1 default=0.02");
    program->addParamsLine(
        "   [--enhance_max_freq <f2>]    : Bandpass cutoff. Normalized to 0.5.");
    program->addParamsLine(
        "   [--selfEstimation]           : Estimate defocus without previous estimation");
    program->addParamsLine(
        "                                : If fmax>0.35, f2 default=0.08");
    program->addParamsLine(
        "                                : If fmax<0.35, f2 default=0.15");
}

defineParams()

void ProgCTFBasicParams::defineParams ( )

virtual

Define Parameters.

Reimplemented from XmippProgram.

Reimplemented in ProgCTFEstimateFromPSDFast.

Definition at line 171 of file ctf_estimate_from_psd_base.cpp.

{
    addUsageLine("Adjust a parametric model to a PSD file.");
    addUsageLine(
        "The PSD is enhanced ([[http://www.ncbi.nlm.nih.gov/pubmed/16987671][See article]]). ");
    addUsageLine(
        "And finally, the CTF is fitted to the PSD, being guided by the enhanced PSD ");
    addUsageLine(
        "([[http://www.ncbi.nlm.nih.gov/pubmed/17911028][See article]]).");
    addParamsLine("   --psd <PSDfile> : PSD file");
    addSeeAlsoLine("ctf_estimate_from_micrograph");
    defineBasicParams(this);
}

generate_model_halfplane()

void ProgCTFBasicParams::generate_model_halfplane	(	int	Ydim,
		int	Xdim,
		MultidimArray< double > &	model
	)

Generate half-plane model at a given size. It is assumed that ROUT_Adjust_CTF has been already run

generate_model_quadrant()

void ProgCTFBasicParams::generate_model_quadrant	(	int	Ydim,
		int	Xdim,
		MultidimArray< double > &	model
	)

Generate quadrant model at a given size. It is assumed that ROUT_Adjust_CTF has been already run

produceSideInfo()

void ProgCTFBasicParams::produceSideInfo

(

)

Produce side information.

Definition at line 186 of file ctf_estimate_from_psd_base.cpp.

{
    // Resize the frequency
    x_digfreq.initZeros(YSIZE(*f), XSIZE(*f) / 2);
    y_digfreq.initZeros(YSIZE(*f), XSIZE(*f) / 2);
    w_digfreq.initZeros(YSIZE(*f), XSIZE(*f) / 2);
    w_digfreq_r.initZeros(YSIZE(*f), XSIZE(*f) / 2);
    x_contfreq.initZeros(YSIZE(*f), XSIZE(*f) / 2);
    y_contfreq.initZeros(YSIZE(*f), XSIZE(*f) / 2);
    w_contfreq.initZeros(YSIZE(*f), XSIZE(*f) / 2);

    Matrix1D<int> idx(2); // Indexes for Fourier plane
    Matrix1D<double> freq(2); // Frequencies for Fourier plane

    FOR_ALL_ELEMENTS_IN_ARRAY2D(x_digfreq)
    {
        XX(idx) = j;
        YY(idx) = i;

        // Digital frequency
        FFT_idx2digfreq(*f, idx, freq);
        x_digfreq(i, j) = XX(freq);
        y_digfreq(i, j) = YY(freq);
        w_digfreq(i, j) = freq.module();
        w_digfreq_r(i, j) = (int)(w_digfreq(i,j) * (double)YSIZE(w_digfreq));

        // Continuous frequency
        digfreq2contfreq(freq, freq, Tm);
        x_contfreq(i, j) = XX(freq);
        y_contfreq(i, j) = YY(freq);
        w_contfreq(i, j) = freq.module();
    }

    // Build frequency mask
    mask.initZeros(w_digfreq);
    w_count.initZeros(XSIZE(w_digfreq));
    FOR_ALL_ELEMENTS_IN_ARRAY2D(w_digfreq)
    {
        if (w_digfreq(i, j) >= max_freq
            || w_digfreq(i, j) <= min_freq)
            continue;
        mask(i, j) = 1;
        w_count(w_digfreq_r(i, j))++;
    }

    // Enhance PSD for ctfmodels
    ProgCTFEnhancePSD prm;
    prm.filter_w1 = 0.02;
    prm.filter_w2 = 0.2;
    prm.decay_width = 0.02;
    prm.mask_w1 = 0.01;
    prm.mask_w2 = 0.5;
    enhanced_ctftomodel() = ctftomodel();
    prm.applyFilter(enhanced_ctftomodel());
    if (fn_psd.find('@')==std::string::npos)
        enhanced_ctftomodel.write(fn_psd.withoutExtension() + "_enhanced_psd.xmp");
    else
        enhanced_ctftomodel.write(fn_psd.withoutExtension() + "_enhanced_psd.stk");
    CenterFFT(enhanced_ctftomodel(), false);
    enhanced_ctftomodel_fullsize() = enhanced_ctftomodel();

    // Enhance PSD for optimization
    prm.filter_w1 = f1;
    prm.filter_w2 = f2;
    enhanced_ctftomodel() = ctftomodel();
    prm.applyFilter(enhanced_ctftomodel());
    CenterFFT(enhanced_ctftomodel(), false);
    enhanced_ctftomodel().resize(w_digfreq);

    // Divide by the number of count at each frequency
    // and mask between min_freq and max_freq
    double min_val = enhanced_ctftomodel().computeMin();
    FOR_ALL_ELEMENTS_IN_ARRAY2D(mask)
    if (mask(i, j) <= 0)
        enhanced_ctftomodel(i, j) = min_val;

    MultidimArray<double> aux;
    medianFilter3x3(enhanced_ctftomodel(), aux);

    enhanced_ctftomodel() = aux;
    enhanced_ctftomodel().rangeAdjust(0, 1);

    FourierFilter Filter;
    Filter.FilterShape = RAISED_COSINE;
    Filter.FilterBand = HIGHPASS;
    Filter.w1 = 0.01;
    Filter.raised_w = 0.005;
    enhanced_ctftomodel().setXmippOrigin();
    Filter.generateMask(enhanced_ctftomodel());
    Filter.applyMaskSpace(enhanced_ctftomodel());
    STARTINGX(enhanced_ctftomodel()) = STARTINGY(enhanced_ctftomodel()) = 0;

    // Compute now radial average of the enhanced_ctftomodel
    psd_exp_enhanced_radial_derivative.initZeros(XSIZE(enhanced_ctftomodel()));
    psd_theo_radial_derivative.initZeros(psd_exp_enhanced_radial_derivative);
    psd_exp_enhanced_radial.initZeros(psd_exp_enhanced_radial_derivative);
    psd_exp_radial.initZeros(psd_exp_enhanced_radial_derivative);
    psd_theo_radial.initZeros(psd_exp_enhanced_radial_derivative);
    w_digfreq_r_iN.initZeros(psd_exp_enhanced_radial_derivative);
    FOR_ALL_ELEMENTS_IN_ARRAY2D(enhanced_ctftomodel())
    {
        if (w_digfreq(i,j)>min_freq && w_digfreq(i,j)<max_freq)
        {
            int r = w_digfreq_r(i, j);
            w_digfreq_r_iN(r)+=1;
            psd_exp_enhanced_radial(r) += enhanced_ctftomodel(i, j);
            psd_exp_radial(r) += ctftomodel(i, j);
        }
    }
    FOR_ALL_ELEMENTS_IN_ARRAY1D(w_digfreq_r_iN)
    if (w_digfreq_r_iN(i)>0)
    {
        w_digfreq_r_iN(i)=1.0/w_digfreq_r_iN(i);
        psd_exp_enhanced_radial(i)*=w_digfreq_r_iN(i);
        psd_exp_radial(i)*=w_digfreq_r_iN(i);
    }

    // Compute its derivative
    int state=0;
    double maxDiff=0;
    FOR_ALL_ELEMENTS_IN_ARRAY1D(psd_exp_enhanced_radial)
    {
        switch (state)
        {
        case 0:
            if (w_digfreq(i,0)>min_freq)
                state=1;
            break;
        case 1:
            state=2; // Skip first sample
            break;
        case 2:
            if (w_digfreq(i,0)>max_freq)
                state=3;
            else
            {
                double diff=psd_exp_enhanced_radial(i)-psd_exp_enhanced_radial(i-1);
                psd_exp_enhanced_radial_derivative(i)=diff;
                maxDiff=std::max(maxDiff,fabs(diff));
            }
            break;
        }
    }
    psd_exp_enhanced_radial_derivative/=maxDiff;
    if (show_optimization)
    {
        psd_exp_enhanced_radial.write("PPPexpEnhanced_fast.txt");
        psd_exp_radial.write("PPPexp_fast.txt");
    }

}

readBasicParams()

void ProgCTFBasicParams::readBasicParams

(

XmippProgram *

program

)

Read parameters.

Definition at line 33 of file ctf_estimate_from_psd_base.cpp.

{
    downsampleFactor = program->getDoubleParam("--downSamplingPerformed");
    show_optimization = program->checkParam("--show_optimization");
    min_freq = program->getDoubleParam("--min_freq");
    max_freq = program->getDoubleParam("--max_freq");
    defocus_range = program->getDoubleParam("--defocus_range");
    modelSimplification = program->getIntParam("--model_simplification");
    bootstrap = program->checkParam("--bootstrapFit");
    refineAmplitudeContrast = program->checkParam("--refine_amplitude_contrast");
    fastDefocusEstimate = program->checkParam("--fastDefocus");
    noDefocusEstimate = program->checkParam("--noDefocus");
    selfEstimation = program->checkParam("--selfEstimation");
    if (fastDefocusEstimate)
    {
        lambdaPhase=program->getDoubleParam("--fastDefocus",0);
        sizeWindowPhase=program->getIntParam("--fastDefocus",1);
    }
    ctfmodelSize = program->getIntParam("--ctfmodelSize");
    enhanced_weight = program->getDoubleParam("--enhance_weight");
    if (!program->checkParam("--enhance_min_freq"))
        f1 = (max_freq > 0.35) ? 0.01 : 0.02;
    else
        f1 = program->getDoubleParam("--enhance_min_freq");
    if (!program->checkParam("--enhance_max_freq"))
        f2 = (max_freq > 0.35) ? 0.08 : 0.15;
    else
        f2 = program->getDoubleParam("--enhance_max_freq");
}

readParams()

void ProgCTFBasicParams::readParams ( )

virtual

Read parameters.

Reimplemented from XmippProgram.

Reimplemented in ProgCTFEstimateFromPSDFast.

Definition at line 63 of file ctf_estimate_from_psd_base.cpp.

{
    fn_psd = getParam("--psd");
    readBasicParams(this);
}

show()

void ProgCTFBasicParams::show

(

)

Show parameters.

Definition at line 70 of file ctf_estimate_from_psd_base.cpp.

{
    if (verbose==0)
        return;
    std::cout
    << "PSD file:                  " << fn_psd << std::endl
    << "Downsampling:              " << downsampleFactor << std::endl
    << "Min Freq.:                 " << min_freq << std::endl
    << "Max Freq.:                 " << max_freq << std::endl
    << "Sampling:                  " << Tm << std::endl
    << "Defocus range:             " << defocus_range << std::endl
    << "ctfmodelSize:              " << ctfmodelSize << std::endl
    << "Enhance min freq:          " << f1 << std::endl
    << "Enhance max freq:          " << f2 << std::endl
    << "Enhance weight:            " << enhanced_weight << std::endl
    << "Model simplification:      " << modelSimplification << std::endl
    << "Bootstrap:                 " << bootstrap << std::endl
    << "Fast defocus:              " << fastDefocusEstimate << std::endl
    << "No defocus:                " << noDefocusEstimate << std::endl
    << "Refine amplitude contrast: " << refineAmplitudeContrast << std::endl
    ;
    if (fastDefocusEstimate)
        std::cout
        << "Regularization factor:      " << lambdaPhase << std::endl
        << "Window size:                " << sizeWindowPhase << std::endl;

}

Member Data Documentation

action

int ProgCTFBasicParams::action

Definition at line 102 of file ctf_estimate_from_psd_base.h.

adjust

Matrix1D<double> ProgCTFBasicParams::adjust

Set of parameters for the complete adjustment of the CTF.

Definition at line 62 of file ctf_estimate_from_psd_base.h.

adjust_params

Matrix1D<double>* ProgCTFBasicParams::adjust_params

Definition at line 126 of file ctf_estimate_from_psd_base.h.

amplitud

std::vector<double> ProgCTFBasicParams::amplitud

Definition at line 83 of file ctf_estimate_from_psd_base.h.

bootstrap

bool ProgCTFBasicParams::bootstrap

Bootstrap estimation.

Definition at line 36 of file ctf_estimate_from_psd_base.h.

corr13

double ProgCTFBasicParams::corr13

Definition at line 112 of file ctf_estimate_from_psd_base.h.

ctfmodelSize

int ProgCTFBasicParams::ctfmodelSize

X dimension of particle projections (-1=the same as the psd)

Definition at line 34 of file ctf_estimate_from_psd_base.h.

ctftomodel

Image<double> ProgCTFBasicParams::ctftomodel

CTF amplitude to model.

Definition at line 25 of file ctf_estimate_from_psd_base.h.

current_penalty

double ProgCTFBasicParams::current_penalty

Definition at line 122 of file ctf_estimate_from_psd_base.h.

defocus_range

double ProgCTFBasicParams::defocus_range

Defocus range.

Definition at line 54 of file ctf_estimate_from_psd_base.h.

downsampleFactor

double ProgCTFBasicParams::downsampleFactor

Downsample performed.

Definition at line 23 of file ctf_estimate_from_psd_base.h.

enhanced_ctftomodel

Image<double> ProgCTFBasicParams::enhanced_ctftomodel

CTF amplitude to model.

Definition at line 27 of file ctf_estimate_from_psd_base.h.

enhanced_ctftomodel_fullsize

Image<double> ProgCTFBasicParams::enhanced_ctftomodel_fullsize

CTF amplitude to model.

Definition at line 29 of file ctf_estimate_from_psd_base.h.

enhanced_weight

double ProgCTFBasicParams::enhanced_weight

Weight of the enhanced image.

Definition at line 60 of file ctf_estimate_from_psd_base.h.

evaluation_reduction

int ProgCTFBasicParams::evaluation_reduction

Definition at line 118 of file ctf_estimate_from_psd_base.h.

f

MultidimArray<double>* ProgCTFBasicParams::f

Definition at line 125 of file ctf_estimate_from_psd_base.h.

f1

double ProgCTFBasicParams::f1

Enhancement filter low freq.

Definition at line 56 of file ctf_estimate_from_psd_base.h.

f2

double ProgCTFBasicParams::f2

Enhancement filter high freq.

Definition at line 58 of file ctf_estimate_from_psd_base.h.

fastDefocusEstimate

bool ProgCTFBasicParams::fastDefocusEstimate

Fast defocus estimate.

Definition at line 40 of file ctf_estimate_from_psd_base.h.

fn_psd

FileName ProgCTFBasicParams::fn_psd

CTF filename.

Definition at line 21 of file ctf_estimate_from_psd_base.h.

heavy_penalization

double ProgCTFBasicParams::heavy_penalization

Definition at line 121 of file ctf_estimate_from_psd_base.h.

lambdaPhase

double ProgCTFBasicParams::lambdaPhase

Regularization factor for the phase direction and unwrapping estimates (used in Zernike estimate)

Definition at line 44 of file ctf_estimate_from_psd_base.h.

mask

MultidimArray<double> ProgCTFBasicParams::mask

Masks.

Definition at line 85 of file ctf_estimate_from_psd_base.h.

mask_between_zeroes

MultidimArray<double> ProgCTFBasicParams::mask_between_zeroes

Definition at line 86 of file ctf_estimate_from_psd_base.h.

max_freq

double ProgCTFBasicParams::max_freq

Maximum frequency to adjust.

Definition at line 50 of file ctf_estimate_from_psd_base.h.

max_freq_psd

double ProgCTFBasicParams::max_freq_psd

Definition at line 92 of file ctf_estimate_from_psd_base.h.

max_gauss_freq

double ProgCTFBasicParams::max_gauss_freq

Definition at line 95 of file ctf_estimate_from_psd_base.h.

min_freq

double ProgCTFBasicParams::min_freq

Minimum frequency to adjust.

Definition at line 48 of file ctf_estimate_from_psd_base.h.

min_freq_psd

double ProgCTFBasicParams::min_freq_psd

Definition at line 91 of file ctf_estimate_from_psd_base.h.

modelSimplification

int ProgCTFBasicParams::modelSimplification

Model simplification.

Definition at line 64 of file ctf_estimate_from_psd_base.h.

noDefocusEstimate

bool ProgCTFBasicParams::noDefocusEstimate

No defocus estimate.

Definition at line 42 of file ctf_estimate_from_psd_base.h.

penalize

bool ProgCTFBasicParams::penalize

Definition at line 115 of file ctf_estimate_from_psd_base.h.

penalty

constexpr double ProgCTFBasicParams::penalty = 32.0

static

Definition at line 123 of file ctf_estimate_from_psd_base.h.

psd_exp_enhanced_radial

MultidimArray<double> ProgCTFBasicParams::psd_exp_enhanced_radial

Definition at line 74 of file ctf_estimate_from_psd_base.h.

psd_exp_enhanced_radial_2

MultidimArray<double> ProgCTFBasicParams::psd_exp_enhanced_radial_2

Definition at line 75 of file ctf_estimate_from_psd_base.h.

psd_exp_enhanced_radial_derivative

MultidimArray<double> ProgCTFBasicParams::psd_exp_enhanced_radial_derivative

Definition at line 76 of file ctf_estimate_from_psd_base.h.

psd_exp_radial

MultidimArray<double> ProgCTFBasicParams::psd_exp_radial

PSD data.

Definition at line 73 of file ctf_estimate_from_psd_base.h.

psd_exp_radial_derivative

MultidimArray<double> ProgCTFBasicParams::psd_exp_radial_derivative

Definition at line 78 of file ctf_estimate_from_psd_base.h.

psd_fft

MultidimArray<std::complex<double> > ProgCTFBasicParams::psd_fft

Definition at line 82 of file ctf_estimate_from_psd_base.h.

psd_theo_radial

MultidimArray<double> ProgCTFBasicParams::psd_theo_radial

Definition at line 79 of file ctf_estimate_from_psd_base.h.

psd_theo_radial_derivative

MultidimArray<double> ProgCTFBasicParams::psd_theo_radial_derivative

Definition at line 77 of file ctf_estimate_from_psd_base.h.

refineAmplitudeContrast

bool ProgCTFBasicParams::refineAmplitudeContrast

Refine amplitude contrast.

Definition at line 38 of file ctf_estimate_from_psd_base.h.

selfEstimation

bool ProgCTFBasicParams::selfEstimation

Definition at line 32 of file ctf_estimate_from_psd_base.h.

show_inf

int ProgCTFBasicParams::show_inf

Definition at line 97 of file ctf_estimate_from_psd_base.h.

show_optimization

bool ProgCTFBasicParams::show_optimization

Show convergence values.

Definition at line 31 of file ctf_estimate_from_psd_base.h.

sizeWindowPhase

int ProgCTFBasicParams::sizeWindowPhase

Size of the average window used during phase direction and unwrapping estimates (used in Zernike estimate)

Definition at line 46 of file ctf_estimate_from_psd_base.h.

Tm

double ProgCTFBasicParams::Tm

Sampling rate.

Definition at line 52 of file ctf_estimate_from_psd_base.h.

value_th

double ProgCTFBasicParams::value_th

Definition at line 90 of file ctf_estimate_from_psd_base.h.

w_contfreq

MultidimArray<double> ProgCTFBasicParams::w_contfreq

Definition at line 68 of file ctf_estimate_from_psd_base.h.

w_count

MultidimArray<double> ProgCTFBasicParams::w_count

Definition at line 87 of file ctf_estimate_from_psd_base.h.

w_digfreq

MultidimArray<double> ProgCTFBasicParams::w_digfreq

Definition at line 71 of file ctf_estimate_from_psd_base.h.

w_digfreq_r

MultidimArray<double> ProgCTFBasicParams::w_digfreq_r

Definition at line 81 of file ctf_estimate_from_psd_base.h.

w_digfreq_r_iN

MultidimArray<double> ProgCTFBasicParams::w_digfreq_r_iN

Definition at line 80 of file ctf_estimate_from_psd_base.h.

x_contfreq

MultidimArray<double> ProgCTFBasicParams::x_contfreq

Frequencies in axes.

Definition at line 66 of file ctf_estimate_from_psd_base.h.

x_digfreq

MultidimArray<double> ProgCTFBasicParams::x_digfreq

Definition at line 69 of file ctf_estimate_from_psd_base.h.

y_contfreq

MultidimArray<double> ProgCTFBasicParams::y_contfreq

Definition at line 67 of file ctf_estimate_from_psd_base.h.

y_digfreq

MultidimArray<double> ProgCTFBasicParams::y_digfreq

Definition at line 70 of file ctf_estimate_from_psd_base.h.

---

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

• xmipp/libraries/reconstruction/ctf_estimate_from_psd_base.h
• xmipp/libraries/reconstruction/ctf_estimate_from_psd_base.cpp