CTF support classes

Collaboration diagram for CTF support classes:

Classes
class	PrecomputedForCTF
class	CTFDescription1D
class	CTFDescription

Functions
	CTFDescription1D::CTFDescription1D ()
void	CTFDescription1D::read (const FileName &fn, bool disable_if_not_K=true)
void	CTFDescription1D::readFromMetadataRow (const MetaData &MD, size_t id, bool disable_if_not_K=true)
void	CTFDescription1D::readFromMdRow (const MDRow &row, bool disable_if_not_K=true)
void	CTFDescription1D::setRow (MDRow &row) const
void	CTFDescription1D::write (const FileName &fn)
static void	CTFDescription1D::defineParams (XmippProgram *program)
	Define parameters in the command line. More...
void	CTFDescription1D::readParams (XmippProgram *program)
	Read parameters from the command line. More...
void	CTFDescription1D::clear ()
	Clear. More...
void	CTFDescription1D::clearNoise ()
	Clear noise. More...
void	CTFDescription1D::clearPureCtf ()
	Clear pure CTF. More...
void	CTFDescription1D::changeSamplingRate (double newTm)
void	CTFDescription1D::produceSideInfo ()
	Produce Side information. More...
void	CTFDescription1D::precomputeValues (double X)
	Precompute values for a given frequency. More...
void	CTFDescription1D::precomputeValues (const MultidimArray< double > &cont_x_freq)
	Precompute values for an image. More...
void	CTFDescription1D::precomputeValues (int i)
	Precompute values for a given frequency. More...
double	CTFDescription1D::getValueAt (bool show=false) const
	Compute CTF at (U,V). Continuous frequencies. More...
double	CTFDescription1D::getValueDampingAt (bool show=false) const
	Compute CTF damping at (U,V). Continuous frequencies. More...
double	CTFDescription1D::getValuePureAt (bool show=false) const
	Compute CTF pure at (U,V). Continuous frequencies. More...
double	CTFDescription1D::getValuePureNoKAt () const
	Compute CTF pure at (U,V). Continuous frequencies. More...
double	CTFDescription1D::getValueNoiseAt (bool show=false) const
	Compute noise at (X,Y). Continuous frequencies, notice it is squared. More...
double	CTFDescription1D::getValuePureWithoutDampingAt (bool show=false) const
	Compute pure CTF without damping at (U,V). Continuous frequencies. More...
void	CTFDescription1D::getSineAndCosineParts (double &sine_part, double &cosine_part, double E, double u2, double deltaf, bool show) const
double	CTFDescription1D::getValuePureNoPrecomputedAt (double X, bool show=false) const
	Compute CTF pure at (U,V). Continuous frequencies. More...
void	CTFDescription1D::lookFor (int n, const Matrix1D< double > &u, Matrix1D< double > &freq, int iwhat=0)
void	CTFDescription1D::applyCTF (MultidimArray< std::complex< double > > &FFTI, const MultidimArray< double > &I, double Ts, bool absPhase=false)
	Apply CTF to an image. More...
void	CTFDescription1D::applyCTF (MultidimArray< double > &I, double Ts, bool absPhase=false)
	Apply CTF to an image. More...
void	CTFDescription1D::correctPhase (MultidimArray< std::complex< double > > &FFTI, const MultidimArray< double > &I, double Ts)
	Correct phase flip of an image. More...
void	CTFDescription1D::correctPhase (MultidimArray< double > &I, double Ts)
	Correct phase flip of an image. More...
template<class T1 , class T2 >
void	CTFDescription1D::generateCTF (const MultidimArray< T1 > &sample_image, MultidimArray< T2 > &CTF, double Ts=-1)
void	CTFDescription1D::getProfile (double fmax, int nsamples, MultidimArray< double > &profiles)
void	CTFDescription1D::getAverageProfile (double fmax, int nsamples, MultidimArray< double > &profiles)
template<class T >
double	CTFDescription1D::initCTF (int Ydim, int Xdim, MultidimArray< T > &CTF, double Ts=-1) const
	Function to initialize CTF to avoid duplicated code. More...
template<class T >
void	CTFDescription1D::generateCTF (int Ydim, int Xdim, MultidimArray< T > &CTF, double Ts=-1)
	Generate CTF image. More...
template<class T >
void	CTFDescription1D::generateCTFWithoutDamping (int Ydim, int Xdim, MultidimArray< T > &CTF, double Ts=-1)
bool	CTFDescription1D::hasPhysicalMeaning ()
void	CTFDescription1D::forcePhysicalMeaning ()
void	generateCTFImageWith2CTFs (const MetaData &MD1, const MetaData &MD2, int Xdim, MultidimArray< double > &imgOut)
double	errorBetween2CTFs (MetaData &MD1, MetaData &MD2, size_t dim, double minFreq=0.05, double maxFreq=0.25)
double	errorMaxFreqCTFs (MetaData &MD1, double phaseRad=HALFPI)
double	errorMaxFreqCTFs2D (MetaData &MD1, MetaData &MD2, size_t xDim=256, double phaseRad=HALFPI)
void	generatePSDCTFImage (MultidimArray< double > &img, const MetaData &MD)
	CTFDescription::CTFDescription ()
	CTFDescription::CTFDescription (CTFDescription1D copy)
void	CTFDescription::read (const FileName &fn, bool disable_if_not_K=true)
void	CTFDescription::readFromMetadataRow (const MetaData &MD, size_t id, bool disable_if_not_K=true)
void	CTFDescription::readFromMdRow (const MDRow &row, bool disable_if_not_K=true)
void	CTFDescription::setRow (MDRow &row) const
void	CTFDescription::write (const FileName &fn)
static void	CTFDescription::defineParams (XmippProgram *program)
	Define parameters in the command line. More...
void	CTFDescription::readParams (XmippProgram *program)
	Read parameters from the command line. More...
void	CTFDescription::clear ()
	Clear. More...
void	CTFDescription::clearNoise ()
	Clear noise. More...
void	CTFDescription::clearPureCtf ()
	Clear pure CTF. More...
void	CTFDescription::changeSamplingRate (double newTm)
void	CTFDescription::produceSideInfo ()
	Produce Side information. More...
void	CTFDescription::precomputeValues (double X, double Y)
	Precompute values for a given frequency. More...
void	CTFDescription::precomputeValues (const MultidimArray< double > &cont_x_freq, const MultidimArray< double > &cont_y_freq)
	Precompute values for an image. More...
void	CTFDescription::precomputeValues (int i, int j)
	Precompute values for a given frequency. More...
double	CTFDescription::getValueAt (bool show=false) const
	Compute CTF at (U,V). Continuous frequencies. More...
double	CTFDescription::getValueArgument (bool show=false) const
	Compute pure CTF without damping at (U,V). Continuous frequencies. More...
double	CTFDescription::getPhaseAt () const
	Get Phase of the CTF. More...
double	CTFDescription::getValuePureNoPrecomputedAtxy (double X, double Y, bool show=false) const
	Compute CTF pure at (U,V). Continuous frequencies. More...
double	CTFDescription::getValuePureNoDampingNoPrecomputedAt (double X, double Y) const
	Compute CTF pure at (U,V). Continuous frequencies. More...
double	CTFDescription::getDeltafNoPrecomputed (double X, double Y) const
	Deltaf at a given direction. More...
double	CTFDescription::getValueNoiseAt (bool show=false) const
	Compute noise at (X,Y). Continuous frequencies, notice it is squared. More...
void	CTFDescription::lookFor (int n, const Matrix1D< double > &u, Matrix1D< double > &freq, int iwhat=0)
void	CTFDescription::applyCTF (MultidimArray< std::complex< double > > &FFTI, const MultidimArray< double > &I, double Ts, bool absPhase=false)
	Apply CTF to an image. More...
void	CTFDescription::applyCTF (MultidimArray< double > &I, double Ts, bool absPhase=false)
	Apply CTF to an image. More...
void	CTFDescription::correctPhase (MultidimArray< std::complex< double > > &FFTI, const MultidimArray< double > &I, double Ts)
	Correct phase flip of an image. More...
void	CTFDescription::correctPhase (MultidimArray< double > &I, double Ts)
	Correct phase flip of an image. More...
template<class T1 , class T2 >
void	CTFDescription::generateCTF (const MultidimArray< T1 > &sample_image, MultidimArray< T2 > &CTF, double Ts=-1)
void	CTFDescription::getProfile (double angle, double fmax, int nsamples, MultidimArray< double > &profiles)
void	CTFDescription::getAverageProfile (double fmax, int nsamples, MultidimArray< double > &profiles)
template<class T >
void	CTFDescription::generateCTF (int Ydim, int Xdim, MultidimArray< T > &CTF, double Ts=-1)
	Generate CTF image. More...
template<class T >
void	CTFDescription::generateCTFWithoutDamping (int Ydim, int Xdim, MultidimArray< T > &CTF, double Ts=-1)
template<class T >
void	CTFDescription::generateEnvelope (int Ydim, int Xdim, MultidimArray< T > &CTF, double Ts=-1)
bool	CTFDescription::hasPhysicalMeaning ()
void	CTFDescription::forcePhysicalMeaning ()

Variables
double	PrecomputedForCTF::u_sqrt
double	PrecomputedForCTF::u
double	PrecomputedForCTF::u2
double	PrecomputedForCTF::u3
double	PrecomputedForCTF::u4
double	PrecomputedForCTF::ang
double	PrecomputedForCTF::deltaf
double	CTFDescription1D::lambda
double	CTFDescription1D::K1
double	CTFDescription1D::K2
double	CTFDescription1D::K3
double	CTFDescription1D::K4
double	CTFDescription1D::K5
double	CTFDescription1D::K6
double	CTFDescription1D::K7
double	CTFDescription1D::Ksin
double	CTFDescription1D::Kcos
double	CTFDescription1D::D
PrecomputedForCTF	CTFDescription1D::precomputed
std::vector< PrecomputedForCTF >	CTFDescription1D::precomputedImage
int	CTFDescription1D::precomputedImageXdim
double	CTFDescription1D::K
	Global gain. By default, 1. More...
double	CTFDescription1D::Tm
	Sampling rate (A/pixel) More...
double	CTFDescription1D::kV
	Accelerating Voltage (in KiloVolts) More...
double	CTFDescription1D::Defocus
	Defocus (in Angstroms). Negative values are underfocused. More...
double	CTFDescription1D::Cs
	Spherical aberration (in milimeters). Typical value 5.6. More...
double	CTFDescription1D::Ca
	Chromatic aberration (in milimeters). Typical value 2. More...
double	CTFDescription1D::espr
double	CTFDescription1D::ispr
	Objective lens stability (deltaI/I) (ppm). Typical value 1. More...
double	CTFDescription1D::alpha
	Convergence cone semiangle (in mrad). Typical value 0.5. More...
double	CTFDescription1D::DeltaF
	Longitudinal mechanical displacement (ansgtrom). Typical value 100. More...
double	CTFDescription1D::DeltaR
	Transversal mechanical displacement (ansgtrom). Typical value 3. More...
double	CTFDescription1D::Q0
	Factor for the importance of the Amplitude contrast. More...
double	CTFDescription1D::x0
	In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined. More...
double	CTFDescription1D::xF
	In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined. More...
double	CTFDescription1D::y0
	In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined. More...
double	CTFDescription1D::yF
	In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined. More...
bool	CTFDescription1D::isLocalCTF
	Local CTF determination. More...
bool	CTFDescription1D::enable_CTFnoise
	Enable CTFnoise part. More...
bool	CTFDescription1D::enable_CTF
	Enable CTF part. More...
double	CTFDescription1D::base_line
	Global base_line. More...
double	CTFDescription1D::gaussian_K
	Gain for the gaussian term. More...
double	CTFDescription1D::sigma1
	Gaussian width. More...
double	CTFDescription1D::Gc1
	Gaussian center. More...
double	CTFDescription1D::sqrt_K
	Gain for the square root term. More...
double	CTFDescription1D::sq
	Sqrt width. More...
double	CTFDescription1D::gaussian_K2
	Gain for the second Gaussian term. More...
double	CTFDescription1D::sigma2
	Second Gaussian width. More...
double	CTFDescription1D::Gc2
	Second Gaussian center. More...
double	CTFDescription1D::bgR1
double	CTFDescription1D::bgR2
double	CTFDescription1D::bgR3
double	CTFDescription1D::envR0
double	CTFDescription1D::envR1
double	CTFDescription1D::envR2
double	CTFDescription1D::freq_max
double	CTFDescription1D::phase_shift
double	CTFDescription1D::VPP_radius
double	CTFDescription::rad_azimuth
double	CTFDescription::defocus_average
double	CTFDescription::defocus_deviation
double	CTFDescription::rad_gaussian
double	CTFDescription::rad_gaussian2
double	CTFDescription::rad_sqrt
double	CTFDescription::DeltafU
	Global gain. By default, 1. More...
double	CTFDescription::DeltafV
	Defocus in V (in Angstroms). Negative values are underfocused. More...
double	CTFDescription::azimuthal_angle
	Azimuthal angle (between X and U) in degrees. More...
double	CTFDescription::sigmaU
	Spherical aberration (in milimeters). Typical value 5.6. More...
double	CTFDescription::sigmaV
	Gaussian width V. More...
double	CTFDescription::cU
	Gaussian center for U. More...
double	CTFDescription::cV
	Gaussian center for V. More...
double	CTFDescription::gaussian_angle
	Gaussian angle. More...
double	CTFDescription::sqU
	Gain for the square root term. More...
double	CTFDescription::sqV
	Sqrt width V. More...
double	CTFDescription::sqrt_angle
	Sqrt angle. More...
double	CTFDescription::sigmaU2
	Second Gaussian width U. More...
double	CTFDescription::sigmaV2
	Second Gaussian width V. More...
double	CTFDescription::cU2
	Second Gaussian center for U. More...
double	CTFDescription::cV2
	Second Gaussian center for V. More...
double	CTFDescription::gaussian_angle2
	Second Gaussian angle. More...

Friends
std::ostream &	CTFDescription1D::operator<< (std::ostream &out, const CTFDescription1D &ctf)
	Show. More...
std::ostream &	CTFDescription::operator<< (std::ostream &out, const CTFDescription &ctf)
	Show. More...

Detailed Description

Function Documentation

applyCTF() [1/4]

void CTFDescription1D::applyCTF	(	MultidimArray< std::complex< double > > &	FFTI,
		const MultidimArray< double > &	I,
		double	Ts,
		bool	absPhase = false
	)

Apply CTF to an image.

Definition at line 800 of file ctf.cpp.

{
    Matrix1D<int>    idx(2);
    Matrix1D<double> freq(2);
    if ( ZSIZE(FFTI) > 1 )
        REPORT_ERROR(ERR_MULTIDIM_DIM,"ERROR: Apply_CTF only works on 2D images, not 3D.");

    double iTs=1.0/Ts;
    FOR_ALL_ELEMENTS_IN_ARRAY2D(FFTI)
    {
        XX(idx) = j;
        YY(idx) = i;
        FFT_idx2digfreq(I, idx, freq);
        precomputeValues(XX(freq)*iTs);
        double ctf = getValueAt();
        if (absPhase)
            ctf=fabs(ctf);
        A2D_ELEM(FFTI, i, j) *= ctf;
    }
}

applyCTF() [2/4]

void CTFDescription1D::applyCTF	(	MultidimArray< double > &	I,
		double	Ts,
		bool	absPhase = false
	)

Apply CTF to an image.

Definition at line 821 of file ctf.cpp.

{
    FourierTransformer transformer;
    MultidimArray<double> FFTI;
    transformer.setReal(I);
    transformer.FourierTransform();
    applyCTF(transformer.fFourier, I, Ts, absPhase);
    transformer.inverseFourierTransform();
}

applyCTF() [3/4]

void CTFDescription::applyCTF	(	MultidimArray< std::complex< double > > &	FFTI,
		const MultidimArray< double > &	I,
		double	Ts,
		bool	absPhase = false
	)

Apply CTF to an image.

Definition at line 1521 of file ctf.cpp.

{
    Matrix1D<int>    idx(2);
    Matrix1D<double> freq(2);
    if ( ZSIZE(FFTI) > 1 )
        REPORT_ERROR(ERR_MULTIDIM_DIM,"ERROR: Apply_CTF only works on 2D images, not 3D.");

    double iTs=1.0/Ts;
    FOR_ALL_ELEMENTS_IN_ARRAY2D(FFTI)
    {
        XX(idx) = j;
        YY(idx) = i;
        FFT_idx2digfreq(I, idx, freq);
        precomputeValues(XX(freq)*iTs, YY(freq)*iTs);
        double ctf = getValueAt();
        if (absPhase)
            ctf=fabs(ctf);
        A2D_ELEM(FFTI, i, j) *= ctf;
    }
}

applyCTF() [4/4]

void CTFDescription::applyCTF	(	MultidimArray< double > &	I,
		double	Ts,
		bool	absPhase = false
	)

Apply CTF to an image.

Definition at line 1542 of file ctf.cpp.

{
    FourierTransformer transformer;
    MultidimArray<double> FFTI;
    transformer.setReal(I);
    transformer.FourierTransform();
    applyCTF(transformer.fFourier, I, Ts, absPhase);
    transformer.inverseFourierTransform();
}

changeSamplingRate() [1/2]

void CTFDescription1D::changeSamplingRate ( double  newTm )

inline

Change sampling rate. It is advisable to change the sampling rate just after reading the CTF parameters. However, unless you use precomputed values, there should not be any problem of changing it at a later stage.

Definition at line 367 of file ctf.h.

      {
          Tm=newTm;
      }

changeSamplingRate() [2/2]

void CTFDescription::changeSamplingRate ( double  newTm )

inline

Change sampling rate. It is advisable to change the sampling rate just after reading the CTF parameters. However, unless you use precomputed values, there should not be any problem of changing it at a later stage.

Definition at line 994 of file ctf.h.

    {
        Tm=newTm;
    }

clear() [1/2]

void CTFDescription1D::clear

(

)

Clear.

Definition at line 610 of file ctf.cpp.

{
    enable_CTF = true;
    enable_CTFnoise = false;
    isLocalCTF = false;
    clearNoise();
    clearPureCtf();
    y0=x0=xF=yF=0;
}

clear() [2/2]

void CTFDescription::clear

(

)

Clear.

Definition at line 1366 of file ctf.cpp.

{
    CTFDescription1D::clear();
    clearNoise();
    clearPureCtf();
}

clearNoise() [1/2]

void CTFDescription1D::clearNoise

(

)

Clear noise.

Definition at line 620 of file ctf.cpp.

{
    base_line = 0;
    Gc1 = sigma1 = gaussian_K = 0;
    sq  = sqrt_K  = 0;
    Gc2  = sigma2 = gaussian_K2 = 0;
    bgR1 = bgR2 = bgR3 = 0.0;
    isLocalCTF = false;
}

clearNoise() [2/2]

void CTFDescription::clearNoise

(

)

Clear noise.

Definition at line 1373 of file ctf.cpp.

{
    base_line = 0;
    cU = cV = sigmaU = sigmaV = gaussian_angle = gaussian_K = 0;
    sqU = sqV = sqrt_K = sqrt_angle = 0;
    cU2 = cV2 = sigmaU2 = sigmaV2 = gaussian_angle2 = gaussian_K2 = 0;
    bgR1 = bgR2 = bgR3 = 0.0;
    VPP_radius = phase_shift = 0.0;
    isLocalCTF = false;
}

clearPureCtf() [1/2]

void CTFDescription1D::clearPureCtf

(

)

Clear pure CTF.

Definition at line 630 of file ctf.cpp.

{
    enable_CTF = true;
    enable_CTFnoise = false;
    Tm = 2;
    kV = 100;
    Defocus = 0;
    Cs = Ca = espr = ispr = alpha = DeltaF = DeltaR = 0;
    K = 1;
    Q0 = 0;
    envR0 = envR1 = envR2 = 0.0;
    isLocalCTF = false;
}

clearPureCtf() [2/2]

void CTFDescription::clearPureCtf

(

)

Clear pure CTF.

Definition at line 1384 of file ctf.cpp.

{
    CTFDescription1D::clearPureCtf();
    DeltafU = DeltafV = azimuthal_angle = 0;
}

correctPhase() [1/4]

void CTFDescription1D::correctPhase	(	MultidimArray< std::complex< double > > &	FFTI,
		const MultidimArray< double > &	I,
		double	Ts
	)

Correct phase flip of an image.

Definition at line 832 of file ctf.cpp.

{
    Matrix1D<int>    idx(2);
    Matrix1D<double> freq(2);
    if ( ZSIZE(FFTI) > 1 )
        REPORT_ERROR(ERR_MULTIDIM_DIM,"ERROR: Correct phase only works on 2D images, not 3D.");

    double iTs=1.0/Ts;
    FOR_ALL_ELEMENTS_IN_ARRAY2D(FFTI)
    {
        XX(idx) = j;
        YY(idx) = i;
        FFT_idx2digfreq(I, idx, freq);
        precomputeValues(XX(freq)*iTs);
        double ctf = getValuePureAt();
        if (ctf<0)
            A2D_ELEM(FFTI, i, j) *= -1;
    }
}

correctPhase() [2/4]

void CTFDescription1D::correctPhase	(	MultidimArray< double > &	I,
		double	Ts
	)

Correct phase flip of an image.

Definition at line 852 of file ctf.cpp.

{
    FourierTransformer transformer;
    MultidimArray<double> FFTI;
    transformer.setReal(I);
    transformer.FourierTransform();
    correctPhase(transformer.fFourier, I, Ts);
    transformer.inverseFourierTransform();
}

correctPhase() [3/4]

void CTFDescription::correctPhase	(	MultidimArray< std::complex< double > > &	FFTI,
		const MultidimArray< double > &	I,
		double	Ts
	)

Correct phase flip of an image.

Definition at line 1553 of file ctf.cpp.

{
    Matrix1D<int>    idx(2);
    Matrix1D<double> freq(2);
    if ( ZSIZE(FFTI) > 1 )
        REPORT_ERROR(ERR_MULTIDIM_DIM,"ERROR: Apply_CTF only works on 2D images, not 3D.");

    double iTs=1.0/Ts;
    FOR_ALL_ELEMENTS_IN_ARRAY2D(FFTI)
    {
        XX(idx) = j;
        YY(idx) = i;
        FFT_idx2digfreq(I, idx, freq);
        precomputeValues(XX(freq)*iTs, YY(freq)*iTs);
        double ctf = getValuePureAt();
        if (ctf<0)
            A2D_ELEM(FFTI, i, j) *= -1;
    }
}

correctPhase() [4/4]

void CTFDescription::correctPhase	(	MultidimArray< double > &	I,
		double	Ts
	)

Correct phase flip of an image.

Definition at line 1573 of file ctf.cpp.

{
    FourierTransformer transformer;
    MultidimArray<double> FFTI;
    transformer.setReal(I);
    transformer.FourierTransform();
    correctPhase(transformer.fFourier, I, Ts);
    transformer.inverseFourierTransform();
}

CTFDescription() [1/2]

CTFDescription::CTFDescription ( )

inline

Definition at line 899 of file ctf.h.

    {
        clear();
    }

CTFDescription() [2/2]

CTFDescription::CTFDescription ( CTFDescription1D  copy )

inline

Definition at line 904 of file ctf.h.

    {
        DeltafU = DeltafV = copy.Defocus;
        Ca = copy.Ca;
        Cs = copy.Cs;
        DeltaF = copy.DeltaF;
        DeltaR = copy.DeltaR;
        Q0 = copy.Q0;
        cU = cV = copy.Gc1;
        cU2 = cV2 = copy.Gc2;
        base_line = copy.base_line;
        gaussian_K = copy.gaussian_K;
        gaussian_K2 = copy.gaussian_K2;
        sigmaU = sigmaV = copy.sigma1;
        sigmaU2 = sigmaV2 = copy.sigma2;
        sqU = sqV = copy.sq;
        kV = copy.kV;
        bgR1 = copy.bgR1;
        bgR2 = copy.bgR2;
        bgR3 = copy.bgR3;
        envR0 = copy.envR0;
        envR1 = copy.envR1;
        envR2 = copy.envR2;
        espr = copy.espr;
        ispr = copy.ispr;
        alpha = copy.alpha;
        sqrt_K = copy.sqrt_K;
        K = copy.K;
        Tm = copy.Tm;
        azimuthal_angle = 0;
        gaussian_angle = 0;
        gaussian_angle2 = 0;
        sqrt_angle = 0;
        enable_CTFnoise = copy.enable_CTFnoise;
        phase_shift = copy.phase_shift;
        VPP_radius = copy.VPP_radius;
    }

CTFDescription1D()

CTFDescription1D::CTFDescription1D ( )

inline

Empty constructor.

Definition at line 309 of file ctf.h.

    {
      clear();
    }

defineParams() [1/2]

void CTFDescription1D::defineParams ( XmippProgram *  program )

static

Define parameters in the command line.

Definition at line 496 of file ctf.cpp.

{
    program->addParamsLine("== CTF1D description");
    program->addParamsLine("  [--ctf_similar_to++ <ctfFile>]        : ctfparam file");
    program->addParamsLine("                                        : Parameters from this file are ");
    program->addParamsLine("                                        : overriden by the parameters in the command line");
    program->addParamsLine("  [--sampling_rate <Tm>]                : Angstroms/pixel. Ex: 1.4");
    program->addParamsLine("                                        : This parameter is compulsory if a CTF is needed.");
    program->addParamsLine("  [--voltage <kV>]                      : Accelerating voltage (kV). Ex: 200");
    program->addParamsLine("                                        : This parameter is compulsory if a CTF is needed.");
    program->addParamsLine("     alias --kV;");
    program->addParamsLine("  [--spherical_aberration <Cs>]         : Milimiters. Ex: 5.6");
    program->addParamsLine("                                        : This parameter is compulsory if a CTF is needed.");
    program->addParamsLine("     alias --Cs;");
    program->addParamsLine("  [--defocusU <Defocus>]                : Defocus in Angstroms (Ex: 2000)");
    program->addParamsLine("  [--chromatic_aberration++ <Ca=0>]     : Milimiters. Ex: 2");
    program->addParamsLine("  [--energy_loss++ <espr=0>]            : eV. Ex: 1");
    program->addParamsLine("  [--lens_stability++ <ispr=0>]         : ppm. Ex: 1");
    program->addParamsLine("  [--convergence_cone++ <alpha=0>]      : mrad. Ex: 0.5");
    program->addParamsLine("  [--longitudinal_displace++ <DeltaF=0>]: Angstrom. Ex: 100");
    program->addParamsLine("  [--transversal_displace++ <DeltaR=0>] : Angstrom. Ex: 3");
    program->addParamsLine("  [--Q0++ <Q0=0>]                       : Percentage of cosine (Q0>0)");
    program->addParamsLine("  [--K++ <K=0>]                         : Global gain");
    program->addParamsLine("  [--phase_shift++ <phase_shift>]     : VPP phase shift");
    program->addParamsLine("  [--VPP_radius++ <VPP_radius>]       : phase plate radius");
}

defineParams() [2/2]

void CTFDescription::defineParams ( XmippProgram *  program )

static

Define parameters in the command line.

Definition at line 1287 of file ctf.cpp.

{
    CTFDescription1D::defineParams(program);
    program->addParamsLine("== CTF 2D description");
    program->addParamsLine("  [--defocusV++ <DeltafV>]              : If astigmatic");
    program->addParamsLine("  [--azimuthal_angle++ <ang=0>]         : Angle between X and U (degrees)");

}

errorBetween2CTFs()

double errorBetween2CTFs	(	MetaData &	MD1,
		MetaData &	MD2,
		size_t	dim,
		double	minFreq = 0.05,
		double	maxFreq = 0.25
	)

compute error between two CTFS, return a single value

Definition at line 107 of file ctf.cpp.

{

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

    CTFDescription CTF1;
    CTFDescription CTF2;

    CTF1.enable_CTF=true;
    CTF1.enable_CTFnoise=false;
    CTF1.readFromMetadataRow(MD1,MD1.firstRowId());
    CTF1.produceSideInfo();

    CTF2.enable_CTF=true;
    CTF2.enable_CTFnoise=false;
    CTF2.readFromMetadataRow(MD2,MD2.firstRowId());
    CTF2.produceSideInfo();

    double iTm=1.0/CTF1.Tm;
    size_t xDim;
    size_t yDim;
    xDim = yDim = Xdim;
#define DEBUG
#ifdef DEBUG

    Image<double> img1(xDim,yDim);
    Image<double> img2(xDim,yDim);
    Image<double> img3(xDim,yDim);

    MultidimArray<double> &dummy1 = img1.data;
    MultidimArray<double> &dummy2 = img2.data;
    MultidimArray<double> &dummy3 = img3.data;
#endif

    double error =0.;
    double _freq=0.;
    minFreq /= CTF1.Tm;
    maxFreq /= CTF1.Tm;

    for (int i=0; i<(int)yDim; ++i)
    {
        FFT_IDX2DIGFREQ(i, yDim, YY(freq));
        YY(freq) *= iTm;
        for (int j=0; j<(int)xDim; ++j)
        {
            FFT_IDX2DIGFREQ(j, xDim, XX(freq));
            XX(freq) *= iTm;
            _freq = freq.module();
            if (_freq < minFreq || _freq > maxFreq)
                continue;
            //freq *= CTF1.Tm;
            CTF1.precomputeValues(XX(freq),YY(freq));
            CTF2.precomputeValues(XX(freq),YY(freq));
            error += fabs(CTF2.getValuePureWithoutDampingAt()- CTF1.getValuePureWithoutDampingAt());
#ifdef DEBUG

            double a = CTF1.getValuePureWithoutDampingAt();
            double b = CTF2.getValuePureWithoutDampingAt();
            DIRECT_A2D_ELEM(dummy1,i,j)=a;
            DIRECT_A2D_ELEM(dummy2,i,j)=b;
            DIRECT_A2D_ELEM(dummy3,i,j)=fabs(b-a);
#endif

        }
    }
#ifdef DEBUG
    img1.write("/tmp/img1.spi");
    img2.write("/tmp/img2.spi");
    img3.write("/tmp/img3.spi");
#endif
#undef DEBUG

    return error;
}

errorMaxFreqCTFs()

double errorMaxFreqCTFs	(	MetaData &	MD1,
		double	phaseRad = HALFPI
	)

Report at which resolution an astigmatism CTF is shifted in perpendicular directions by phaseRad degrees. Returns amsgtroms

Definition at line 187 of file ctf.cpp.

{
    CTFDescription CTF1;

    CTF1.enable_CTF=true;
    CTF1.enable_CTFnoise=false;
    CTF1.readFromMetadataRow(MD1,MD1.firstRowId());
    CTF1.produceSideInfo();


//#define DEBUG
#ifdef DEBUG
    std::cerr << "DEBUG_ROB: CTF1.DeltaU: " << CTF1.DeltafU << std::endl;
    std::cerr << "DEBUG_ROB: CTF1.DeltaV: " << CTF1.DeltafV << std::endl;
    std::cerr << "DEBUG_ROB: var: " << phaseRad/(CTF1.K1*abs(CTF1.DeltafU - CTF1.DeltafV)) << std::endl;
    std::cerr << "DEBUG_ROB: var: " << sqrt(phaseRad/(CTF1.K1*abs(CTF1.DeltafU - CTF1.DeltafV))) << std::endl;
    std::cerr << "DEBUG_ROB: var: " << 1/sqrt(phaseRad/(CTF1.K1*abs(CTF1.DeltafU - CTF1.DeltafV))) << std::endl;

#endif
#undef DEBUG
    //Armstrong ^-1
    //K1 = PI / 2 * 2 * lambda;
    return 1.0/sqrt(phaseRad/(CTF1.K1*abs(CTF1.DeltafU - CTF1.DeltafV)));
}

errorMaxFreqCTFs2D()

double errorMaxFreqCTFs2D	(	MetaData &	MD1,
		MetaData &	MD2,
		size_t	xDim = 256,
		double	phaseRad = HALFPI
	)

Report at which resolution these two CTF are shifted by phaseRad degrees returns amsgtroms

Definition at line 214 of file ctf.cpp.

{
    Matrix1D<double> freq(2); // Frequencies for Fourier plane

    CTFDescription CTF1;
    CTFDescription CTF2;

    CTF1.enable_CTF=true;
    CTF1.enable_CTFnoise=false;
    CTF1.readFromMetadataRow(MD1,MD1.firstRowId());
    CTF1.produceSideInfo();

    CTF2.enable_CTF=true;
    CTF2.enable_CTFnoise=false;
    CTF2.readFromMetadataRow(MD2,MD2.firstRowId());
    CTF2.produceSideInfo();

    double iTm=1.0/CTF1.Tm;
    size_t xDim;
    size_t yDim;
    xDim = yDim = Xdim;
//#define DEBUG
#ifdef DEBUG

    Image<double> arg1(xDim,yDim);
    Image<double> arg2(xDim,yDim);
    Image<double> argDiff(xDim,yDim);
    Image<double> ctf1(xDim,yDim);
    Image<double> ctf2(xDim,yDim);
    Image<double> ctfDiff(xDim,yDim);
    Image<double> aux(xDim,yDim);

    MultidimArray<double> &arg1Mul = arg1.data;
    MultidimArray<double> &arg2Mul = arg2.data;
    MultidimArray<double> &argDiffMul = argDiff.data;
    MultidimArray<double> &ctf1Mul = ctf1.data;
    MultidimArray<double> &ctf2Mul = ctf2.data;
    MultidimArray<double> &ctfDiffMul = ctfDiff.data;
    MultidimArray<double> &auxMul  = aux.data;
    int counterAux = 0 ;
#endif

    int counter = 0 ;
    //double _freq=0.;
    for (int i=0; i<(int)yDim; ++i)
    {
        FFT_IDX2DIGFREQ(i, yDim, YY(freq));
        YY(freq) *= iTm;
        for (int j=0; j<(int)xDim; ++j)
        {
            FFT_IDX2DIGFREQ(j, xDim, XX(freq));
            XX(freq) *= iTm;
            //_freq = freq.module();
            //freq *= CTF1.Tm;
            CTF1.precomputeValues(XX(freq),YY(freq));
            CTF2.precomputeValues(XX(freq),YY(freq));
            double a = CTF1.getValueArgument();
            double b = CTF2.getValueArgument();
            if (fabs(b-a) < phaseRad)
                counter++;
#ifdef DEBUG
            counterAux++;
            DIRECT_A2D_ELEM(argDiffMul,i,j)=fabs(b-a);
            DIRECT_A2D_ELEM(arg1Mul,i,j)=a;
            DIRECT_A2D_ELEM(arg2Mul,i,j)=b;
            a = CTF1.getValuePureWithoutDampingAt();
            b = CTF2.getValuePureWithoutDampingAt();
            DIRECT_A2D_ELEM(ctf1Mul,i,j)=a;
            DIRECT_A2D_ELEM(ctf2Mul,i,j)=b;
            DIRECT_A2D_ELEM(ctfDiffMul,i,j)=fabs(b-a);
#endif

        }
    }
    double areaLessHalfPIPixels = counter;
    double totalArePixels       = PI*Xdim*Xdim/4.0;
    double maxFreqA             = 1./(2.*CTF1.Tm);
    double resolutionA_1        = 0;
    if (areaLessHalfPIPixels > totalArePixels)
        resolutionA_1 = maxFreqA;
    else
        resolutionA_1 = areaLessHalfPIPixels * maxFreqA / totalArePixels;
    double resolutionA          = 1./ resolutionA_1;
#ifdef DEBUG
    Matrix2D<double>  R;
    R.initIdentity(3);
    R(2, 0) = 128.;
    R(2, 1) = 128.;
    applyGeometry(BSPLINE3, auxMul, arg1Mul, R.transpose(), IS_NOT_INV, true, 0.);
    aux.write("/tmp/arg1.spi");
    applyGeometry(BSPLINE3, auxMul, arg2Mul, R.transpose(), IS_NOT_INV, true, 0.);
    aux.write("/tmp/arg2.spi");
    applyGeometry(BSPLINE3, auxMul, argDiffMul, R.transpose(), IS_NOT_INV, true, 0.);
    aux.write("/tmp/argDiff.spi");
    applyGeometry(BSPLINE3, auxMul, ctf1Mul, R.transpose(), IS_NOT_INV, true, 0.);
    aux.write("/tmp/ctf1.spi");
    applyGeometry(BSPLINE3, auxMul, ctf2Mul, R.transpose(), IS_NOT_INV, true, 0.);
    aux.write("/tmp/ctf2.spi");
    applyGeometry(BSPLINE3, auxMul, ctfDiffMul, R.transpose(), IS_NOT_INV, true, 0.);
    aux.write("/tmp/ctfMDiff.spi");

    std::cerr << "DEBUG_ROB: counter: "    << counter << std::endl;
    std::cerr << "DEBUG_ROB: counterAux: " << counterAux << std::endl;
    std::cerr << "DEBUG_ROB: res in pixels: " << sqrt (counter/PI) << std::endl;
    // area < halfpi  area whole sprecta  normalize to .5
    std::cerr << "DEBUG_ROB: resolutionA_1: " << resolutionA_1 << std::endl;
    std::cerr << "DEBUG_ROB: resolutionA: " << resolutionA << std::endl;
#endif
#undef DEBUG
    return resolutionA;
    //divide between area
}

forcePhysicalMeaning() [1/2]

void CTFDescription1D::forcePhysicalMeaning

(

)

Force physical meaning.

Definition at line 1055 of file ctf.cpp.

{
    if (enable_CTF)
    {
        if (K < 0)
            K = 0;
        if (base_line < 0)
            base_line = 0;
        if (kV < 50)
            kV = 50;
        if (kV > 1000)
            kV = 1000;
        if (espr < 0)
            espr = 0;
        if (espr > 20)
            espr = 20;
        if (ispr < 0)
            ispr = 0;
        if (ispr > 20)
            ispr = 20;
        if (Cs < 0)
            Cs = 0;
        if (Cs > 20)
            Cs = 20;
        if (Ca < 0)
            Ca = 0;
        if (Ca > 3)
            Ca = 3;
        if (alpha < 0)
            alpha = 0;
        if (alpha > 5)
            alpha = 5;
        if (DeltaF < 0)
            DeltaF = 0;
        if (DeltaF > 1000)
            DeltaF = 1000;
        if (DeltaR < 0)
            DeltaR = 0;
        if (DeltaR > 1000)
            DeltaR = 1000;
        if (Q0 > 0.40)
            Q0 = 0.40;
        if (Q0 < 0)
            Q0 = 0;
        if (Defocus < 0)
            Defocus = 0;

    }
    if (enable_CTFnoise)
    {
        double min_sigma = XMIPP_MIN(sigma1, sigma1);
        double min_c = XMIPP_MIN(Gc1, Gc1);
        double min_sigma2 = XMIPP_MIN(sigma2, sigma2);
        double min_c2 = XMIPP_MIN(Gc2, Gc2);
        if (base_line < 0)
            base_line = 0;
        if (gaussian_K < 0)
            gaussian_K = 0;
        if (sigma1 < 0)
            sigma1 = 0;
        if (sigma1 > 100e3)
            sigma1 = 100e3;
        if (Gc1 < 0)
            Gc1 = 0;
        if (sq < 0)
            sq = 0;
        if (sqrt_K < 0)
            sqrt_K = 0;
        if (gaussian_K2 < 0)
            gaussian_K2 = 0;
        if (sigma2 < 0)
            sigma2 = 0;
        if (sigma2 > 100e3)
            sigma2 = 100e3;
        if (Gc2 < 0)
            Gc2 = 0;
        if (min_sigma > 0)
            if (sigma1 / min_sigma > 3)
            {
                sigma1 = 3.9 * sigma1;
            }
        if (min_c > 0)
            if (Gc1 / min_c > 3)
            {
                Gc1 = 3.9 * Gc1;
            }
        if (gaussian_K != 0)
        {
            if (Gc1*Tm < 0.01)
                Gc1 = 0.011 / Tm;
        }
        if (min_sigma2 > 0)
            if (sigma2 / min_sigma2 > 3)
            {
               sigma2 = 3.9 * sigma2;
            }
        if (min_c2 > 0)
            if (Gc2 / min_c2 > 3)
            {
                    Gc2 = 3.9 * Gc2;
            }
        if (gaussian_K2 != 0)
        {
            if (Gc2*Tm < 0.01)
                Gc2 = 0.011 / Tm;
        }
        if (phase_shift > PI || phase_shift < -PI) //Normalize phase shift between 0-PI
        {
            phase_shift = realWRAP(phase_shift,-PI,PI);//phase_shift - floor(phase_shift/3.14)*3.14;
        }
    }
}

forcePhysicalMeaning() [2/2]

void CTFDescription::forcePhysicalMeaning

(

)

Force physical meaning.

Definition at line 1781 of file ctf.cpp.

{
    CTFDescription1D::forcePhysicalMeaning();
    if (enable_CTF)
    {
        if (DeltafU < 0)
            DeltafU = 0;
        if (DeltafV < 0)
            DeltafV = 0;
    }
    if (enable_CTFnoise)
    {
        double min_sigma = XMIPP_MIN(sigmaU, sigmaV);
        double min_c = XMIPP_MIN(cU, cV);
        double min_sigma2 = XMIPP_MIN(sigmaU2, sigmaV2);
        double min_c2 = XMIPP_MIN(cU2, cV2);
        if (base_line < 0)
            base_line = 0;
        if (gaussian_K < 0)
            gaussian_K = 0;
        if (sigmaU < 0)
            sigmaU = 0;
        if (sigmaV < 0)
            sigmaV = 0;
        if (sigmaU > 100e3)
            sigmaU = 100e3;
        if (sigmaV > 100e3)
            sigmaV = 100e3;
        if (cU < 0)
            cU = 0;
        if (cV < 0)
            cV = 0;
        if (sqU < 0)
            sqU = 0;
        if (sqV < 0)
            sqV = 0;
        if (sqrt_K < 0)
            sqrt_K = 0;
        if (gaussian_K2 < 0)
            gaussian_K2 = 0;
        if (sigmaU2 < 0)
            sigmaU2 = 0;
        if (sigmaV2 < 0)
            sigmaV2 = 0;
        if (sigmaU2 > 100e3)
            sigmaU2 = 100e3;
        if (sigmaV2 > 100e3)
            sigmaV2 = 100e3;
        if (cU2 < 0)
            cU2 = 0;
        if (cV2 < 0)
            cV2 = 0;
        if (gaussian_angle < 0)
            gaussian_angle = 0;
        if (gaussian_angle > 90)
            gaussian_angle = 90;
        if (sqrt_angle < 0)
            sqrt_angle = 0;
        if (sqrt_angle > 90)
            sqrt_angle = 90;
        if (gaussian_angle2 < 0)
            gaussian_angle2 = 0;
        if (gaussian_angle2 > 90)
            gaussian_angle2 = 90;
        if (min_sigma > 0)
            if (ABS(sigmaU - sigmaV) / min_sigma > 3)
            {
                if (sigmaU < sigmaV)
                    sigmaV = 3.9 * sigmaU;
                else
                    sigmaU = 3.9 * sigmaV;
            }
        if (min_c > 0)
            if (ABS(cU - cV) / min_c > 3)
            {
                if (cU < cV)
                    cV = 3.9 * cU;
                else
                    cU = 3.9 * cV;
            }
        if (gaussian_K != 0)
        {
            if (cU*Tm < 0.01)
                cU = 0.011 / Tm;
            if (cV*Tm < 0.01)
                cV = 0.011 / Tm;
        }
        if (min_sigma2 > 0)
            if (ABS(sigmaU2 - sigmaV2) / min_sigma2 > 3)
            {
                if (sigmaU2 < sigmaV2)
                    sigmaV2 = 3.9 * sigmaU2;
                else
                    sigmaU2 = 3.9 * sigmaV2;
            }
        if (min_c2 > 0)
            if (ABS(cU2 - cV2) / min_c2 > 3)
            {
                if (cU2 < cV2)
                    cV2 = 3.9 * cU2;
                else
                    cU2 = 3.9 * cV2;
            }
        if (gaussian_K2 != 0)
        {
            if (cU2*Tm < 0.01)
                cU2 = 0.011 / Tm;
            if (cV2*Tm < 0.01)
                cV2 = 0.011 / Tm;
        }
    }
}

generateCTF() [1/4]

template<class T1 , class T2 >

void CTFDescription1D::generateCTF ( const MultidimArray< T1 > &  sample_image, MultidimArray< T2 > &  CTF, double  Ts = -1  )

inline

Generate CTF image. The sample image is used only to take its dimensions.

Definition at line 650 of file ctf.h.

    {
        if ( ZSIZE(sample_image) > 1 )
            REPORT_ERROR(ERR_MULTIDIM_DIM,"ERROR: Generate_CTF only works with 2D sample images, not 3D.");
        generateCTF(YSIZE(sample_image), XSIZE(sample_image), CTF, Ts);
        STARTINGX(CTF) = STARTINGX(sample_image);
        STARTINGY(CTF) = STARTINGY(sample_image);
    }

generateCTF() [2/4]

template<class T >

void CTFDescription1D::generateCTF ( int  Ydim, int  Xdim, MultidimArray< T > &  CTF, double  Ts = -1  )

inline

Generate CTF image.

Definition at line 690 of file ctf.h.

    {
        double iTs = initCTF(Ydim, Xdim, CTF, Ts);
        for (int i=0; i<Ydim; ++i)
        {
            double wy;
            FFT_IDX2DIGFREQ(i, YSIZE(CTF), wy);
            double fy=wy*iTs;
            for (int j=0; j<Xdim; ++j)
            {
                double wx;
                FFT_IDX2DIGFREQ(j, XSIZE(CTF), wx);
                double fx=wx*iTs;
                precomputeValues(fx);
                A2D_ELEM(CTF, i, j) = (T) getValueAt();
                #ifdef DEBUG
                        if (i == 0)
                            std::cout << i << " " << j << " " << YY(freq) << " " << XX(freq)
                            << " " << CTF(i, j) << std::endl;
                #endif
            }
        }
    }

generateCTF() [3/4]

template<class T1 , class T2 >

void CTFDescription::generateCTF ( const MultidimArray< T1 > &  sample_image, MultidimArray< T2 > &  CTF, double  Ts = -1  )

inline

Generate CTF image. The sample image is used only to take its dimensions.

Definition at line 1194 of file ctf.h.

    {
        if ( ZSIZE(sample_image) > 1 )
            REPORT_ERROR(ERR_MULTIDIM_DIM,"ERROR: Generate_CTF only works with 2D sample images, not 3D.");
        generateCTF(YSIZE(sample_image), XSIZE(sample_image), CTF, Ts);
        STARTINGX(CTF) = STARTINGX(sample_image);
        STARTINGY(CTF) = STARTINGY(sample_image);
    }

generateCTF() [4/4]

template<class T >

void CTFDescription::generateCTF ( int  Ydim, int  Xdim, MultidimArray< T > &  CTF, double  Ts = -1  )

inline

Generate CTF image.

Definition at line 1219 of file ctf.h.

    {
    double iTs = initCTF(Ydim, Xdim, CTF, Ts);
        for (int i=0; i<Ydim; ++i)
        {
            double wy;
            FFT_IDX2DIGFREQ(i, YSIZE(CTF), wy);
            double fy=wy*iTs;
            for (int j=0; j<Xdim; ++j)
            {
                double wx;
                FFT_IDX2DIGFREQ(j, XSIZE(CTF), wx);
                double fx=wx*iTs;
                precomputeValues(fx, fy);
                A2D_ELEM(CTF, i, j) = (T) getValueAt();
                #ifdef DEBUG
                        if (i == 0)
                            std::cout << i << " " << j << " " << fy << " " << fx
                            << " " << CTF(i, j) << std::endl;
                #endif
            }
        }
    }

generateCTFImageWith2CTFs()

void generateCTFImageWith2CTFs	(	const MetaData &	MD1,
		const MetaData &	MD2,
		int	Xdim,
		MultidimArray< double > &	imgOut
	)

Generate CTF 2D image with two CTFs. The two CTFs are in fn1 and fn2. The output image is written to the file fnOut and has size Xdim x Xdim.

Definition at line 67 of file ctf.cpp.

{
    CTFDescription CTF1;
    CTFDescription CTF2;
    CTF1.enable_CTF=true;
    CTF1.enable_CTFnoise=false;
    CTF1.readFromMetadataRow(MD1,MD1.firstRowId());
    CTF1.produceSideInfo();

    CTF2.enable_CTF=true;
    CTF2.enable_CTFnoise=false;
    CTF2.readFromMetadataRow(MD2,MD2.firstRowId());
    CTF2.produceSideInfo();

    imgOut.initZeros(Xdim,Xdim);
    Matrix1D<int> idx(2);
    Matrix1D<double> freq(2);
    FOR_ALL_ELEMENTS_IN_ARRAY2D(imgOut)
    {
        XX(idx) = j;
        YY(idx) = i;

        // Digital frequency
        FFT_idx2digfreq(imgOut, idx, freq);
        if (XX(freq)>=0 && XX(freq)<0.5)
        {
            digfreq2contfreq(freq, freq, CTF1.Tm);
            CTF1.precomputeValues(XX(freq),YY(freq));
            A2D_ELEM(imgOut,i,j)=CTF1.getValueAt();
        }
        else
        {
            digfreq2contfreq(freq, freq, CTF2.Tm);
            CTF2.precomputeValues(XX(freq),YY(freq));
            A2D_ELEM(imgOut,i,j)=CTF2.getValueAt();
        }
    }
    CenterFFT(imgOut,false);
}

generateCTFWithoutDamping() [1/2]

template<class T >

void CTFDescription1D::generateCTFWithoutDamping ( int  Ydim, int  Xdim, MultidimArray< T > &  CTF, double  Ts = -1  )

inline

Definition at line 716 of file ctf.h.

    {
        double iTs = initCTF(Ydim, Xdim, CTF, Ts=-1);
        for (int i=0; i<Ydim; ++i)
        {
            double wy;
            FFT_IDX2DIGFREQ(i, YSIZE(CTF), wy);
            double fy=wy*iTs;
            for (int j=0; j<Xdim; ++j)
            {
                double wx;
                FFT_IDX2DIGFREQ(j, XSIZE(CTF), wx);
                double fx=wx*iTs;
                precomputeValues(fx);
                A2D_ELEM(CTF, i, j) = (T) getValuePureWithoutDampingAt();
                #ifdef DEBUG
                        if (i == 0)
                            std::cout << i << " " << j << " " << YY(freq) << " " << XX(freq)
                            << " " << CTF(i, j) << std::endl;
                #endif
            }
        }
    }

generateCTFWithoutDamping() [2/2]

template<class T >

void CTFDescription::generateCTFWithoutDamping ( int  Ydim, int  Xdim, MultidimArray< T > &  CTF, double  Ts = -1  )

inline

Definition at line 1245 of file ctf.h.

    {
    double iTs = initCTF(Ydim, Xdim, CTF, Ts);
        for (int i=0; i<Ydim; ++i)
        {
            double wy;
            FFT_IDX2DIGFREQ(i, YSIZE(CTF), wy);
            double fy=wy*iTs;
            for (int j=0; j<Xdim; ++j)
            {
                double wx;
                FFT_IDX2DIGFREQ(j, XSIZE(CTF), wx);
                double fx=wx*iTs;
                precomputeValues(fx, fy);
                A2D_ELEM(CTF, i, j) = (T) getValuePureWithoutDampingAt();
                #ifdef DEBUG
                        if (i == 0)
                            std::cout << i << " " << j << " " << YY(freq) << " " << XX(freq)
                            << " " << CTF(i, j) << std::endl;
                #endif
            }
        }
    }

generateEnvelope()

template<class T >

void CTFDescription::generateEnvelope ( int  Ydim, int  Xdim, MultidimArray< T > &  CTF, double  Ts = -1  )

inline

Definition at line 1271 of file ctf.h.

    {
    double iTs = initCTF(Ydim, Xdim, CTF, Ts);
        for (int i=0; i<Ydim; ++i)
        {
            double wy;
            FFT_IDX2DIGFREQ(i, YSIZE(CTF), wy)
            double fy=wy*iTs;
            for (int j=0; j<Xdim; ++j)
            {
                double wx;
                FFT_IDX2DIGFREQ(j, XSIZE(CTF), wx)
                double fx=wx*iTs;
                precomputeValues(fx, fy);
                A2D_ELEM(CTF, i, j) = (T) -getValueDampingAt(); 
                #ifdef DEBUG
                        if (i == 0)
                            std::cout << i << " " << j << " " << YY(freq) << " " << XX(freq)
                            << " " << CTF(i, j) << std::endl;
                #endif
            }
        }
    }

generatePSDCTFImage()

void generatePSDCTFImage	(	MultidimArray< double > &	img,
		const MetaData &	MD
	)

Generate an image with the PSD and the CTF Before calling the function img must have the enhanced PSD. The enhanced PSD image is modified to add the CTF.

Definition at line 330 of file ctf.cpp.

{
    img.rangeAdjust(-1,1);
    CenterFFT(img,false);

    CTFDescription CTF;
    CTF.enable_CTF=true;
    CTF.enable_CTFnoise=false;
    CTF.readFromMetadataRow(MD,MD.firstRowId());
    CTF.produceSideInfo();

    Matrix1D<int> idx(2);
    Matrix1D<double> freq(2);
    FOR_ALL_ELEMENTS_IN_ARRAY2D(img)
    {
        XX(idx) = j;
        YY(idx) = i;

        // Digital frequency
        FFT_idx2digfreq(img, idx, freq);
        if (XX(freq)>=0 && XX(freq)<0.5)
        {
            digfreq2contfreq(freq, freq, CTF.Tm);
            CTF.precomputeValues(XX(freq),YY(freq));
            double aux=CTF.getValueAt();
            A2D_ELEM(img,i,j)=aux*aux;
        }
    }
    CenterFFT(img,true);
}

getAverageProfile() [1/2]

void CTFDescription1D::getAverageProfile	(	double	fmax,
		int	nsamples,
		MultidimArray< double > &	profiles
	)

Get radial average profiles. It returns the radially average CTF profiles (BGNOISE, ENVELOPE, PSD, CTF). Profiles have nsamples from 0 to fmax (1/A).

Definition at line 894 of file ctf.cpp.

{
    double step = fmax / nsamples;
    profiles.initZeros(nsamples, 4);

    for (int angle=0; angle < 360; angle++) //Angulo??? En 1D no hay. Con que itero?
    {
        double angle2 = float(angle);
        double cosinus = cos(angle2);
        double f;
        size_t i;
        for (i = 0, f = 0; i < YSIZE(profiles); i++, f += step)
        {
            double fx = f * cosinus;

            // Compute current frequencies.
            precomputeValues(fx);

            // Store values.
            double bgNoise = getValueNoiseAt();
            double ctf = getValuePureAt();
            double E = getValueDampingAt();

            A2D_ELEM(profiles, i, 0) += 10*log10(bgNoise);
            A2D_ELEM(profiles, i, 1) += 10*log10(bgNoise + E * E);
            A2D_ELEM(profiles, i, 2) += 10*log10(bgNoise + ctf * ctf);
            A2D_ELEM(profiles, i, 3) += getValuePureNoKAt();
        }
    }
    profiles*=1.0/360;
}

getAverageProfile() [2/2]

void CTFDescription::getAverageProfile	(	double	fmax,
		int	nsamples,
		MultidimArray< double > &	profiles
	)

Get radial average profiles. It returns the radially average CTF profiles (BGNOISE, ENVELOPE, PSD, CTF). Profiles have nsamples from 0 to fmax (1/A).

Definition at line 1616 of file ctf.cpp.

{
    double step = fmax / nsamples;
    profiles.initZeros(nsamples, 4);

    for(int angle=0; angle < 360; angle++)
    {
        double angle2 = float(angle);
        double sinus = sin(angle2);
        double cosinus = cos(angle2);
        double f;
        size_t i;
        for (i = 0, f = 0; i < YSIZE(profiles); i++, f += step)
        {
            double fx = f * cosinus;
            double fy = f * sinus;

            // Compute current frequencies.
            precomputeValues(fx, fy);

            // Store values.
            double bgNoise = getValueNoiseAt();
            double ctf = getValuePureAt();
            double E = getValueDampingAt();

            A2D_ELEM(profiles, i, 0) += 10*log10(bgNoise);
            A2D_ELEM(profiles, i, 1) += 10*log10(bgNoise + E * E);
            A2D_ELEM(profiles, i, 2) += 10*log10(bgNoise + ctf * ctf);
            A2D_ELEM(profiles, i, 3) += getValuePureNoKAt();
        }
    }
    profiles*=1.0/360;
}

getDeltafNoPrecomputed()

double CTFDescription::getDeltafNoPrecomputed ( double  X, double  Y  ) const

inline

Deltaf at a given direction.

Definition at line 1109 of file ctf.h.

    {
        if (fabs(X) < XMIPP_EQUAL_ACCURACY &&
            fabs(Y) < XMIPP_EQUAL_ACCURACY)
            return 0;
        double ellipsoid_ang = atan2(Y, X) - rad_azimuth;
        double cos_ellipsoid_ang_2 = cos(2*ellipsoid_ang);
        return(defocus_average + defocus_deviation*cos_ellipsoid_ang_2);
    }

getPhaseAt()

double CTFDescription::getPhaseAt ( ) const

inline

Get Phase of the CTF.

Definition at line 1063 of file ctf.h.

    {
        return K1 * precomputed.deltaf * precomputed.u2 + K2 *precomputed.u4;
    }

getProfile() [1/2]

void CTFDescription1D::getProfile	(	double	fmax,
		int	nsamples,
		MultidimArray< double > &	profiles
	)

Get profiles along a given direction. It returns the CTF profiles (BGNOISE, ENVELOPE, PSD, CTF) along the direction defined by angle. Profiles have nsamples from 0 to fmax (1/A).

Definition at line 863 of file ctf.cpp.

{
    double step = fmax / nsamples;

    profiles.resizeNoCopy(nsamples, 4);
    //double sinus = sin(angle);
    //double cosinus = cos(angle);
    double f;
    size_t i;

    for (i = 0, f = 0; i < YSIZE(profiles); i++, f += step)
    {
        double fx = f;

        // Compute current frequencies.
        precomputeValues(fx);

        // Store values.
        double bgNoise = getValueNoiseAt();
        double ctf = getValuePureAt();
        double E = getValueDampingAt();

        A2D_ELEM(profiles, i, 0) = 10*log10(bgNoise);
        A2D_ELEM(profiles, i, 1) = 10*log10(bgNoise + E * E);
        A2D_ELEM(profiles, i, 2) = 10*log10(bgNoise + ctf * ctf);
        A2D_ELEM(profiles, i, 3) = getValuePureNoKAt();
    }
}

getProfile() [2/2]

void CTFDescription::getProfile	(	double	angle,
		double	fmax,
		int	nsamples,
		MultidimArray< double > &	profiles
	)

Get profiles along a given direction. It returns the CTF profiles (BGNOISE, ENVELOPE, PSD, CTF) along the direction defined by angle. Profiles have nsamples from 0 to fmax (1/A).

Definition at line 1584 of file ctf.cpp.

{
    double step = fmax / nsamples;

    profiles.resizeNoCopy(nsamples, 4);
    double sinus = sin(angle);
    double cosinus = cos(angle);
    double f;
    size_t i;

    for (i = 0, f = 0; i < YSIZE(profiles); i++, f += step)
    {
        double fx = f * cosinus;
        double fy = f * sinus;

        // Compute current frequencies.
        precomputeValues(fx, fy);

        // Store values.
        double bgNoise = getValueNoiseAt();
        double ctf = getValuePureAt();
        double E = getValueDampingAt();

        A2D_ELEM(profiles, i, 0) = 10*log10(bgNoise);
        A2D_ELEM(profiles, i, 1) = 10*log10(bgNoise + E * E);
        A2D_ELEM(profiles, i, 2) = 10*log10(bgNoise + ctf * ctf);
        A2D_ELEM(profiles, i, 3) = getValuePureNoKAt();
    }
}

getSineAndCosineParts()

void CTFDescription1D::getSineAndCosineParts ( double &  sine_part, double &  cosine_part, double  E, double  u2, double  deltaf, bool  show  ) const

inline

Definition at line 572 of file ctf.h.

    {
        double u = sqrt(u2);
        double u4 = u2 * u2;
        double VPP;
        double check_VPP = round(VPP_radius*1000);
        if(check_VPP != 0)
            VPP = -phase_shift*(1-exp(-u2/(2*pow(VPP_radius,2.0))));
        else
            VPP = 0;
        double argument = VPP + K1 * deltaf * u2 + K2 * u4;
        //sincos(argument,&sine_part, &cosine_part); // OK
        sine_part = sin(argument);
                cosine_part = cos(argument);
        double Eespr = exp(-K3 * u4); // OK
        //CO: double Eispr=exp(-K4*u4); // OK
        double EdeltaF = bessj0(K5 * u2); // OK
        double EdeltaR = sinc(u * DeltaR); // OK
        double Ealpha = exp(-K6 * (K7 * u2 * u + deltaf * u) * (K7 * u2 * u + deltaf * u)); // OK
        // CO: double E=Eespr*Eispr*EdeltaF*EdeltaR*Ealpha;
        E = Eespr * EdeltaF * EdeltaR * Ealpha+envR0+envR1*precomputed.u+envR2*precomputed.u2;
        if (E < 0)
            E   = 0;
        if (show)
        {
            std::cout << " Deltaf=" << deltaf << std::endl;
            std::cout << " u,u2,u4=" << u << " " << u2 << " " << u4 << std::endl;
            std::cout << " K1,K2,sin=" << K1 << " " << K2 << " "
            << sine_part << std::endl;
            std::cout << " K3,Eespr=" << K3 << " " << Eespr << std::endl;
            //std::cout << " K4,Eispr=" << K4 << " " << /*Eispr*/ << std::endl;
            std::cout << " K5,EdeltaF=" << K5 << " " << EdeltaF << std::endl;
            std::cout << " EdeltaR=" << EdeltaR << std::endl;
            std::cout << " K6,K7,Ealpha=" << K6 << " " << K7 << " " << Ealpha
            << std::endl;
            std::cout << " Total atenuation(E)= " << E << std::endl;
            std::cout << " K,Q0,base_line=" << K << "," << Q0 << "," << base_line << std::endl;
        }
    }

getValueArgument()

double CTFDescription::getValueArgument ( bool  show = false ) const

inline

Compute pure CTF without damping at (U,V). Continuous frequencies.

Definition at line 1057 of file ctf.h.

    {
        return K1 * precomputed.deltaf * precomputed.u2 + K2 * precomputed.u4;
    }

getValueAt() [1/2]

double CTFDescription1D::getValueAt ( bool  show = false ) const

inline

Compute CTF at (U,V). Continuous frequencies.

Definition at line 417 of file ctf.h.

     {
         double pure_CTF = enable_CTF ? getValuePureAt(show) : 0;
         return enable_CTFnoise ? sqrt(pure_CTF*pure_CTF + getValueNoiseAt(show)) : pure_CTF;
     }

getValueAt() [2/2]

double CTFDescription::getValueAt ( bool  show = false ) const

inline

Compute CTF at (U,V). Continuous frequencies.

Definition at line 1050 of file ctf.h.

    {
        double pure_CTF = enable_CTF ? getValuePureAt(show) : 0;
        return enable_CTFnoise ? sqrt(pure_CTF*pure_CTF + getValueNoiseAt(show)) : pure_CTF;
    }

getValueDampingAt()

double CTFDescription1D::getValueDampingAt ( bool  show = false ) const

inline

Compute CTF damping at (U,V). Continuous frequencies.

Definition at line 424 of file ctf.h.

     {
         double Eespr = exp(-K3 * precomputed.u4); // OK
         double EdeltaF = bessj0(K5 * precomputed.u2); // OK
         double EdeltaR = SINC(precomputed.u * DeltaR); // OK
         double aux=K7 * precomputed.u2 * precomputed.u + precomputed.deltaf * precomputed.u;
         double Ealpha = exp(-K6 * aux * aux);
         double E = Eespr * EdeltaF * EdeltaR * Ealpha+envR0+envR1*precomputed.u+envR2*precomputed.u2;
         if (E < 0)
             E  = 0;
         if (show)
         {
             std::cout << "   Deltaf=" << precomputed.deltaf << std::endl;
             std::cout << "   u,u2,u4=" << precomputed.u << " " << precomputed.u2
             << " " << precomputed.u4 << std::endl;
             std::cout << "   K3,Eespr=" << K3 << " " << Eespr << std::endl;
             std::cout << "   K4,Eispr=" << K4 << " " << /*Eispr <<*/ std::endl;
             std::cout << "   K5,EdeltaF=" << K5 << " " << EdeltaF << std::endl;
             std::cout << "   EdeltaR=" << EdeltaR << std::endl;
             std::cout << "   K6,K7,Ealpha=" << K6 << " " << K7 << " " << Ealpha
             << std::endl;
             std::cout << "   Total atenuation(E)= " << E << std::endl;
             std::cout << "   CTFdamp=" << E << std::endl;
         }
         return -K*E;
     }

getValueNoiseAt() [1/2]

double CTFDescription1D::getValueNoiseAt ( bool  show = false ) const

inline

Compute noise at (X,Y). Continuous frequencies, notice it is squared.

Definition at line 506 of file ctf.h.

    {
        double c = Gc1;
        double sigmaG1 = sigma1;

        double c2 = Gc2;
        double sigmaG2 = sigma2;

        if(show)
        {
            std::cout
            << "   sq=" << sq << "\n"
            << "   c=" << c << "\n"
            << "   sigma=" << sigmaG1 << "\n"
            << "   c2=" << c2 << "\n"
            << "   sigma2=" << sigmaG2 << "\n"
            << "   gaussian_K=" << gaussian_K << "\n"
            << "   sqrt_K=" << sqrt_K << "\n"
            << "   base_line=" << base_line << "\n";
            std::cout << "   u=" << precomputed.u << "u_sqrt=" << precomputed.u_sqrt <<") CTFnoise="
            << base_line +
            gaussian_K*exp(-sigmaG1*(precomputed.u - c)*(precomputed.u - c)) +
            sqrt_K*exp(-sq*sqrt(precomputed.u)) -
            gaussian_K2*exp(-sigmaG2*(precomputed.u - c2)*(precomputed.u - c2)) << std::endl;
        }

        double aux=precomputed.u - c;
        double aux2=precomputed.u - c2;
        return base_line +
               gaussian_K*exp(-sigmaG1*aux*aux) +
               sqrt_K*exp(-sq*precomputed.u_sqrt) -
               gaussian_K2*exp(-sigmaG2*aux2*aux2)+
               bgR1*precomputed.u+bgR2*precomputed.u2+bgR3*precomputed.u3;
    }

getValueNoiseAt() [2/2]

double CTFDescription::getValueNoiseAt ( bool  show = false ) const

inline

Compute noise at (X,Y). Continuous frequencies, notice it is squared.

Definition at line 1121 of file ctf.h.

    {
        double ellipsoid_ang = precomputed.ang - rad_gaussian;
        double ellipsoid_ang2 = precomputed.ang - rad_gaussian2;
        double ellipsoid_sqrt_ang = precomputed.ang - rad_sqrt;
        double cos_sqrt_ang = cos(ellipsoid_sqrt_ang);
        double cos_sqrt_ang_2 = cos_sqrt_ang*cos_sqrt_ang;
        double sin_sqrt_ang_2 = 1.0-cos_sqrt_ang_2;
        double sq = sqrt(sqU * sqU * cos_sqrt_ang_2 + sqV * sqV * sin_sqrt_ang_2);

        double cos_ang = cos(ellipsoid_ang);
        double cos_ang_2 = cos_ang*cos_ang;
        double sin_ang_2 = 1.0-cos_ang_2;
        double c = sqrt(cU * cU * cos_ang_2 + cV * cV * sin_ang_2);
        double sigma = sqrt(sigmaU * sigmaU * cos_ang_2 + sigmaV * sigmaV * sin_ang_2);

        double cos_ang2 = cos(ellipsoid_ang2);
        double cos_ang2_2 = cos_ang2*cos_ang2;
        double sin_ang2_2 = 1.0-cos_ang2_2;
        double c2 = sqrt(cU2 * cU2 * cos_ang2_2 + cV2 * cV2 * sin_ang2_2);
        double sigma2 = sqrt(sigmaU2 * sigmaU2 * cos_ang2_2 + sigmaV2 * sigmaV2 * sin_ang2_2);

        if(show)
        {
            std::cout << "   ellipsoid_ang=" << RAD2DEG(ellipsoid_ang) << std::endl
            << "   ellipsoid_sqrt_ang=" << RAD2DEG(ellipsoid_sqrt_ang) << std::endl
            << "   sq=" << sq << "\n"
            << "   c=" << c << "\n"
            << "   sigma=" << sigma << "\n"
            << "   ellipsoid_ang2=" << RAD2DEG(ellipsoid_ang2) << std::endl
            << "   cU2=" << cU2 << " cV2=" << cV2 << "\n"
            << "   cos_ang2=" << cos_ang2 << " sin_ang2_2=" << sin_ang2_2 << "\n"
            << "   c2=" << c2 << "\n"
            << "   sigmaU2=" << sigma2 << "\n"
            << "   gaussian_K=" << gaussian_K << "\n"
            << "   sqrt_K=" << sqrt_K << "\n"
            << "   base_line=" << base_line << "\n";
            std::cout << "   u=" << precomputed.u << "u_sqrt=" << precomputed.u_sqrt <<") CTFnoise="
            << base_line +
            gaussian_K*exp(-sigma*(precomputed.u - c)*(precomputed.u - c)) +
            sqrt_K*exp(-sq*sqrt(precomputed.u)) -
            gaussian_K2*exp(-sigma2*(precomputed.u - c2)*(precomputed.u - c2)) << std::endl;
        }

        double aux=precomputed.u - c;
        double aux2=precomputed.u - c2;
        return base_line +
               gaussian_K*exp(-sigma*aux*aux) +
               sqrt_K*exp(-sq*precomputed.u_sqrt) -
               gaussian_K2*exp(-sigma2*aux2*aux2)+
               bgR1*precomputed.u+bgR2*precomputed.u2+bgR3*precomputed.u3;
    }

getValuePureAt()

double CTFDescription1D::getValuePureAt ( bool  show = false ) const

inline

Compute CTF pure at (U,V). Continuous frequencies.

Definition at line 452 of file ctf.h.

    {
        double VPP=0.0;
        double check_VPP = round(VPP_radius*1000);
        if(check_VPP != 0)
            VPP = -phase_shift*(1-exp(-precomputed.u2/(2*pow(VPP_radius,2.0))));
        else
            VPP = 0;
        double argument = VPP + K1 * precomputed.deltaf * precomputed.u2 + K2 *precomputed.u4;
        double sine_part;
        double cosine_part;
        //sincos(argument,&sine_part, &cosine_part);
        sine_part = sin(argument);
                cosine_part = cos(argument);// OK
        double Eespr = exp(-K3 * precomputed.u4); // OK
        //CO: double Eispr=exp(-K4*u4); // OK
        double EdeltaF = bessj0(K5 * precomputed.u2); // OK
        double EdeltaR = SINC(precomputed.u * DeltaR); // OK
        double aux=(K7 * precomputed.u2 * precomputed.u + precomputed.deltaf * precomputed.u);
        double Ealpha = exp(-K6 * aux * aux); // OK
        // CO: double E=Eespr*Eispr*EdeltaF*EdeltaR*Ealpha;
        double E = Eespr * EdeltaF * EdeltaR * Ealpha + envR0+envR1*precomputed.u+envR2*precomputed.u2;
        if (E < 0)
            E   = 0;

        if (show)
        {
            std::cout << "   Deltaf=" << precomputed.deltaf << std::endl;
            std::cout << "   u,u2,u4=" << precomputed.u << " " << precomputed.u2
            << " " << precomputed.u4 << std::endl;
            std::cout << "   K1,K2,argument=" << K1 << " " << K2 << " " << argument << std::endl;
            std::cout << "   K3,Eespr=" << K3 << " " << Eespr << std::endl;
            //std::cout << "   K4,Eispr=" << K4 << " " << /*Eispr <<*/ std::endl;
            std::cout << "   K5,EdeltaF=" << K5 << " " << EdeltaF << std::endl;
            std::cout << "   EdeltaR=" << EdeltaR << std::endl;
            std::cout << "   K6,K7,Ealpha=" << K6 << " " << K7 << " " << Ealpha
            << std::endl;
            std::cout << "   Total atenuation(E)= " << E << std::endl;
            std::cout << "   K,Q0,base_line=" << K << "," << Q0 << "," << base_line << std::endl;
            std::cout << "   VPP=" << VPP << " VPPRadius=" << VPP_radius << " phase shift=" << phase_shift << std::endl;
            std::cout << "   CTF="
            << -K*(Ksin*sine_part - Kcos*cosine_part)*E << std::endl;
        }
        return -K*(Ksin*sine_part - Kcos*cosine_part)*E;
    }

getValuePureNoDampingNoPrecomputedAt()

double CTFDescription::getValuePureNoDampingNoPrecomputedAt ( double  X, double  Y  ) const

inline

Compute CTF pure at (U,V). Continuous frequencies.

Definition at line 1087 of file ctf.h.

    {
        double u2 = X * X + Y * Y;
        //if(u2 > freq_max) return 0;
        double u4 = u2 * u2;
        double deltaf = getDeltafNoPrecomputed(X, Y);
        double VPP;
        double check_VPP = round(VPP_radius*1000);
        if(check_VPP != 0)
            VPP = -phase_shift*(1-exp(-u2/(2*pow(VPP_radius,2.0))));
        else
            VPP = 0;
        double argument = VPP + K1 * deltaf * u2 + K2 * u4;
        double sine_part;
        double cosine_part;
        //sincos(argument,&sine_part, &cosine_part); // OK
        sine_part = sin(argument);
        cosine_part = cos(argument);
        return -(Ksin*sine_part - Kcos*cosine_part);
    }

getValuePureNoKAt()

double CTFDescription1D::getValuePureNoKAt ( ) const

inline

Compute CTF pure at (U,V). Continuous frequencies.

Definition at line 499 of file ctf.h.

    {
        return K*getValuePureAt();
    }

getValuePureNoPrecomputedAt()

double CTFDescription1D::getValuePureNoPrecomputedAt ( double  X, bool  show = false  ) const

inline

Compute CTF pure at (U,V). Continuous frequencies.

Definition at line 613 of file ctf.h.

    {
        double u2 = X * X;
        double deltaf = Defocus;
        double sine_part = 0;
        double cosine_part = 0;
        double E = 0;
        getSineAndCosineParts(sine_part, cosine_part, E, u2, deltaf, show);
        if (show)
        {
            std::cout << " (X)=(" << X << ") CTF="
            << -K*(Ksin*sine_part - Kcos*cosine_part)*E + base_line << std::endl;
        }
        return -K*(Ksin*sine_part - Kcos*cosine_part)*E;
    }

getValuePureNoPrecomputedAtxy()

double CTFDescription::getValuePureNoPrecomputedAtxy ( double  X, double  Y, bool  show = false  ) const

inline

Compute CTF pure at (U,V). Continuous frequencies.

Definition at line 1069 of file ctf.h.

    {
        double u2 = X * X + Y * Y;
        //if (u2>=ua2) return 0;
        double deltaf = getDeltafNoPrecomputed(X, Y);
        double sine_part = 0;
        double cosine_part = 0;
        double E = 0;
        getSineAndCosineParts(sine_part, cosine_part, E, u2, deltaf, show);
        if (show)
        {
            std::cout << " (X,Y)=(" << X << "," << Y << ") CTF="
            << -K*(Ksin*sine_part - Kcos*cosine_part)*E + base_line << std::endl;
        }
        return -K*(Ksin*sine_part - Kcos*cosine_part)*E;
    }

getValuePureWithoutDampingAt()

double CTFDescription1D::getValuePureWithoutDampingAt ( bool  show = false ) const

inline

Compute pure CTF without damping at (U,V). Continuous frequencies.

Definition at line 542 of file ctf.h.

    {
        double VPP;
        double check_VPP = round(VPP_radius*1000);
        if(check_VPP != 0)
            VPP = -phase_shift*(1-exp(-precomputed.u2/(2*pow(VPP_radius,2.0))));
        else
            VPP = 0;
        double argument = VPP + K1 * precomputed.deltaf * precomputed.u2 + K2 * precomputed.u4;
        double sine_part;
        double cosine_part;
        //sincos(argument,&sine_part,&cosine_part);
        sine_part = sin(argument);
                cosine_part = cos(argument);// OK

        if (show)
        {
            std::cout << "   Deltaf=" << precomputed.deltaf << std::endl;
            std::cout << "   u,u2,u4=" << precomputed.u << " " << precomputed.u2
            << " " << precomputed.u4 << std::endl;
            std::cout << "   K1,K2,sin=" << K1 << " " << K2 << " "
            << std::endl;
            std::cout << "   Q0=" << Q0 << std::endl;
            std::cout << "   VPP=" << VPP << std::endl;
            std::cout << "   CTF without damping="
            << -(Ksin*sine_part - Kcos*cosine_part) << std::endl;
        }
        return -(Ksin*sine_part - Kcos*cosine_part);
    }

hasPhysicalMeaning() [1/2]

bool CTFDescription1D::hasPhysicalMeaning

(

)

Check physical meaning. true if the CTF parameters have physical meaning. Call this function after produstd::cing side information

Definition at line 929 of file ctf.cpp.

{
    bool retval;
    if (enable_CTF)
    {
        precomputeValues(0);
        retval =
            K >= 0       && base_line >= 0  &&
            kV >= 50     && kV <= 1000      &&
            espr >= 0    && espr <= 20      &&
            ispr >= 0    && ispr <= 20      &&
            Cs >= 0      && Cs <= 20        &&
            Ca >= 0      && Ca <= 7         &&
            alpha >= 0   && alpha <= 5      &&
            DeltaF >= 0  && DeltaF <= 1000  &&
            DeltaR >= 0  && DeltaR <= 100   &&
            Q0 >= 0      && Q0 <= 0.40      &&
            Defocus >= 0 && getValueAt() >= 0;
#ifdef DEBUG

        if (retval == false)
        {
            std::cout << *this << std::endl;
            std::cout << "K>=0       && base_line>=0  " << (K >= 0       && base_line >= 0) << std::endl
            << "kV>=50     && kV<=1000      " << (kV >= 50     && kV <= 1000)     << std::endl
            << "espr>=0    && espr<=20      " << (espr >= 0    && espr <= 20)     << std::endl
            << "ispr>=0    && ispr<=20      " << (ispr >= 0    && ispr <= 20)     << std::endl
            << "Cs>=0      && Cs<=20        " << (Cs >= 0      && Cs <= 20)       << std::endl
            << "Ca>=0      && Ca<=3         " << (Ca >= 0      && Ca <= 3)        << std::endl
            << "alpha>=0   && alpha<=5      " << (alpha >= 0   && alpha <= 5)     << std::endl
            << "DeltaF>=0  && DeltaF<=1000  " << (DeltaF >= 0  && DeltaF <= 1000) << std::endl
            << "DeltaR>=0  && DeltaR<=100   " << (DeltaR >= 0  && DeltaR <= 100)  << std::endl
            << "Q0>=0      && Q0<=0.4       " << (Q0 >= 0      && Q0 <= 0.4)      << std::endl
            << "Defocus>=0                  " << (DeltafU >= 0                    << std::endl
            << "getValueAt(0,0)>=0       " << (getValueAt() >= 0)         << std::endl
            ;
            std::cout << "getValueAt(0,0)=" << getValueAt(true) << std::endl;
        }
#endif

    }
    else
        retval = true;
    bool retval2;
    if (enable_CTFnoise)
    {
        double min_sigma = XMIPP_MIN(sigma1, sigma1);
        double min_c = XMIPP_MIN(Gc1, Gc1);
        double min_sigma2 = XMIPP_MIN(sigma2, sigma2);
        double min_c2 = XMIPP_MIN(Gc2, Gc2);
        retval2 =
            base_line >= 0       &&
            gaussian_K >= 0      &&
            sigma1 >= 0          &&
            sigma1 <= 100e3      &&
            Gc1 >= 0             &&
            sq >= 0              &&
            sqrt_K >= 0          &&
            gaussian_K2 >= 0     &&
            sigma2 >= 0          &&
            sigma2 <= 100e3      &&
            Gc2 >= 0             &&
            phase_shift >= 0.0 && phase_shift <= 3.14
            ;

        if (min_sigma > 0)
            retval2 = retval2 && sigma1 / min_sigma <= 3;
        if (min_c > 0)
            retval2 = retval2 && Gc1 / min_c <= 3;
        if (gaussian_K != 0)
            retval2 = retval2 && (Gc1 * Tm >= 0.01);
        if (min_sigma2 > 0)
            retval2 = retval2 && sigma2 / min_sigma2 <= 3;
        if (min_c2 > 0)
            retval2 = retval2 && Gc2 / min_c2 <= 3;
        if (gaussian_K2 != 0)
            retval2 = retval2 && (Gc2 * Tm >= 0.01);

#ifdef DEBUG

        if (retval2 == false)
        {
            std::cout << *this << std::endl;
            std::cout << "base_line>=0       &&        " << (base_line >= 0)           << std::endl
            << "gaussian_K>=0      &&        " << (gaussian_K >= 0)    << std::endl
            << "sigmaU>=0      && sigmaV>=0     " << (sigmaU >= 0      && sigmaV >= 0)   << std::endl
            << "sigmaU<=100e3      && sigmaV<=100e3       " << (sigmaU <= 100e3      && sigmaV <= 100e3)   << std::endl
            << "cU>=0       && cV>=0      " << (cU >= 0       && cV >= 0)   << std::endl
            << "sqU>=0      && sqV>=0      " << (sqU >= 0        && sqV >= 0)   << std::endl
            << "sqrt_K>=0      &&        " << (sqrt_K >= 0)     << std::endl
            << "gaussian_K2>=0     &&        " << (gaussian_K2 >= 0)    << std::endl
            << "sigmaU2>=0      && sigmaV2>=0     " << (sigmaU2 >= 0      && sigmaV2 >= 0)   << std::endl
            << "sigmaU2<=100e3     && sigmaV2<=100e3      " << (sigmaU2 <= 100e3     && sigmaV2 <= 100e3)  << std::endl
            << "cU2>=0       && cV2>=0      " << (cU2 >= 0      && cV2 >= 0)  << std::endl
            << "gaussian_angle>=0  && gaussian_angle<=90  " << (gaussian_angle >= 0  && gaussian_angle <= 90)  << std::endl
            << "sqrt_angle>=0      && sqrt_angle<=90      " << (sqrt_angle >= 0      && sqrt_angle <= 90)      << std::endl
            << "gaussian_angle2>=0 && gaussian_angle2<=90 " << (gaussian_angle2 >= 0 && gaussian_angle2 <= 90) << std::endl
            ;
            if (min_sigma > 0)
                std::cout << "ABS(sigmaU-sigmaV)/min_sigma<=3         " << (ABS(sigmaU - sigmaV) / min_sigma <= 3)     << std::endl;
            if (min_c > 0)
                std::cout << "ABS(cU-cV)/min_c<=3                     " << (ABS(cU - cV) / min_c <= 3)                 << std::endl;
            if (gaussian_K > 0)
                std::cout << "(cU*Tm>=0.01) && (cV*Tm>=0.01)          " << ((cU*Tm >= 0.01) && (cV*Tm >= 0.01))      << std::endl;
            if (min_sigma2 > 0)
                std::cout << "ABS(sigmaU2-sigmaV2)/min_sigma2<=3      " << (ABS(sigmaU2 - sigmaV2) / min_sigma2 <= 3)  << std::endl;
            if (min_c2 > 0)
                std::cout << "ABS(cU2-cV2)/min_c2<=3                  " << (ABS(cU2 - cV2) / min_c2 <= 3)              << std::endl;
            if (gaussian_K2 > 0)
                std::cout << "(cU2*Tm>=0.01) && (cV2*Tm>=0.01)        " << ((cU2*Tm >= 0.01) && (cV2*Tm >= 0.01))    << std::endl;
            std::cout << cV2*Tm << std::endl;
        }
#endif

    }
    else
        retval2 = true;
#ifdef DEBUG

#endif

    return retval && retval2;
}

hasPhysicalMeaning() [2/2]

bool CTFDescription::hasPhysicalMeaning

(

)

Check physical meaning. true if the CTF parameters have physical meaning. Call this function after produstd::cing side information

Definition at line 1653 of file ctf.cpp.

{
    bool retval;
    if (enable_CTF)
    {
        precomputeValues(0,0);
        retval =
            K >= 0       && base_line >= 0  &&
            kV >= 50     && kV <= 1000      &&
            espr >= 0    && espr <= 20      &&
            ispr >= 0    && ispr <= 20      &&
            Cs >= 0      && Cs <= 20        &&
            Ca >= 0      && Ca <= 7         &&
            alpha >= 0   && alpha <= 9      &&
            DeltaF >= 0  && DeltaF <= 1000  &&
            DeltaR >= 0  && DeltaR <= 100   &&
            Q0 >= 0      && Q0 <= 0.40      &&
            DeltafU >= 0 && DeltafV >= 0    &&
            getValueAt() >= 0;
#ifdef DEBUG

        if (retval == false)
        {
            std::cout << *this << std::endl;
            std::cout << "K>=0       && base_line>=0  " << (K >= 0       && base_line >= 0) << std::endl
            << "kV>=50     && kV<=1000      " << (kV >= 50     && kV <= 1000)     << std::endl
            << "espr>=0    && espr<=20      " << (espr >= 0    && espr <= 20)     << std::endl
            << "ispr>=0    && ispr<=20      " << (ispr >= 0    && ispr <= 20)     << std::endl
            << "Cs>=0      && Cs<=20        " << (Cs >= 0      && Cs <= 20)       << std::endl
            << "Ca>=0      && Ca<=3         " << (Ca >= 0      && Ca <= 7)        << std::endl
            << "alpha>=0   && alpha<=5      " << (alpha >= 0   && alpha <= 5)     << std::endl
            << "DeltaF>=0  && DeltaF<=1000  " << (DeltaF >= 0  && DeltaF <= 1000) << std::endl
            << "DeltaR>=0  && DeltaR<=100   " << (DeltaR >= 0  && DeltaR <= 100)  << std::endl
            << "Q0>=0      && Q0<=0.4       " << (Q0 >= 0      && Q0 <= 0.4)      << std::endl
            << "DeltafU>=0 && DeltafV>=0    " << (DeltafU >= 0 && DeltafV >= 0)   << std::endl
            << "getValueAt(0,0)>=0       " << (getValueAt() >= 0)         << std::endl
            ;
            std::cout << "getValueAt(0,0)=" << getValueAt(true) << std::endl;
        }
#endif

    }
    else
        retval = true;
    bool retval2;
    if (enable_CTFnoise)
    {
        double min_sigma = XMIPP_MIN(sigmaU, sigmaV);
        double min_c = XMIPP_MIN(cU, cV);
        double min_sigma2 = XMIPP_MIN(sigmaU2, sigmaV2);
        double min_c2 = XMIPP_MIN(cU2, cV2);
        retval2 =
            base_line >= 0       &&
            gaussian_K >= 0      &&
            sigmaU >= 0          && sigmaV >= 0          &&
            sigmaU <= 100e3      && sigmaV <= 100e3       &&
            cU >= 0              && cV >= 0              &&
            sqU >= 0             && sqV >= 0             &&
            sqrt_K >= 0          &&
            gaussian_K2 >= 0     &&
            sigmaU2 >= 0         && sigmaV2 >= 0          &&
            sigmaU2 <= 100e3     && sigmaV2 <= 100e3      &&
            cU2 >= 0             && cV2 >= 0              &&
            gaussian_angle >= 0  && gaussian_angle <= 90  &&
            sqrt_angle >= 0      && sqrt_angle <= 90      &&
            gaussian_angle2 >= 0 && gaussian_angle2 <= 90 &&
            phase_shift >= -PI   && phase_shift <= PI
            ;
        if (min_sigma > 0)
            retval2 = retval2 && ABS(sigmaU - sigmaV) / min_sigma <= 3;
        if (min_c > 0)
            retval2 = retval2 && ABS(cU - cV) / min_c <= 3;
        if (gaussian_K != 0)
            retval2 = retval2 && (cU * Tm >= 0.01) && (cV * Tm >= 0.01);
        if (min_sigma2 > 0)
            retval2 = retval2 && ABS(sigmaU2 - sigmaV2) / min_sigma2 <= 3;
        if (min_c2 > 0)
            retval2 = retval2 && ABS(cU2 - cV2) / min_c2 <= 3;
        if (gaussian_K2 != 0)
            retval2 = retval2 && (cU2 * Tm >= 0.01) && (cV2 * Tm >= 0.01);
#ifdef DEBUG

        if (retval2 == false)
        {
            std::cout << *this << std::endl;
            std::cout << "base_line>=0       &&        " << (base_line >= 0)           << std::endl
            << "gaussian_K>=0      &&        " << (gaussian_K >= 0)    << std::endl
            << "sigmaU>=0      && sigmaV>=0     " << (sigmaU >= 0      && sigmaV >= 0)   << std::endl
            << "sigmaU<=100e3      && sigmaV<=100e3       " << (sigmaU <= 100e3      && sigmaV <= 100e3)   << std::endl
            << "cU>=0       && cV>=0      " << (cU >= 0       && cV >= 0)   << std::endl
            << "sqU>=0      && sqV>=0      " << (sqU >= 0        && sqV >= 0)   << std::endl
            << "sqrt_K>=0      &&        " << (sqrt_K >= 0)     << std::endl
            << "gaussian_K2>=0     &&        " << (gaussian_K2 >= 0)    << std::endl
            << "sigmaU2>=0      && sigmaV2>=0     " << (sigmaU2 >= 0      && sigmaV2 >= 0)   << std::endl
            << "sigmaU2<=100e3     && sigmaV2<=100e3      " << (sigmaU2 <= 100e3     && sigmaV2 <= 100e3)  << std::endl
            << "cU2>=0       && cV2>=0      " << (cU2 >= 0      && cV2 >= 0)  << std::endl
            << "gaussian_angle>=0  && gaussian_angle<=90  " << (gaussian_angle >= 0  && gaussian_angle <= 90)  << std::endl
            << "sqrt_angle>=0      && sqrt_angle<=90      " << (sqrt_angle >= 0      && sqrt_angle <= 90)      << std::endl
            << "gaussian_angle2>=0 && gaussian_angle2<=90 " << (gaussian_angle2 >= 0 && gaussian_angle2 <= 90) << std::endl
            ;
            if (min_sigma > 0)
                std::cout << "ABS(sigmaU-sigmaV)/min_sigma<=3         " << (ABS(sigmaU - sigmaV) / min_sigma <= 3)     << std::endl;
            if (min_c > 0)
                std::cout << "ABS(cU-cV)/min_c<=3                     " << (ABS(cU - cV) / min_c <= 3)                 << std::endl;
            if (gaussian_K > 0)
                std::cout << "(cU*Tm>=0.01) && (cV*Tm>=0.01)          " << ((cU*Tm >= 0.01) && (cV*Tm >= 0.01))      << std::endl;
            if (min_sigma2 > 0)
                std::cout << "ABS(sigmaU2-sigmaV2)/min_sigma2<=3      " << (ABS(sigmaU2 - sigmaV2) / min_sigma2 <= 3)  << std::endl;
            if (min_c2 > 0)
                std::cout << "ABS(cU2-cV2)/min_c2<=3                  " << (ABS(cU2 - cV2) / min_c2 <= 3)              << std::endl;
            if (gaussian_K2 > 0)
                std::cout << "(cU2*Tm>=0.01) && (cV2*Tm>=0.01)        " << ((cU2*Tm >= 0.01) && (cV2*Tm >= 0.01))    << std::endl;
            std::cout << cV2*Tm << std::endl;
        }
#endif

    }
    else
        retval2 = true;
#ifdef DEBUG

#endif

    return retval && retval2;
}

initCTF()

template<class T >

double CTFDescription1D::initCTF ( int  Ydim, int  Xdim, MultidimArray< T > &  CTF, double  Ts = -1  ) const

inline

Function to initialize CTF to avoid duplicated code.

Definition at line 676 of file ctf.h.

    {
        CTF.resizeNoCopy(Ydim, Xdim);
        if (Ts<0)
            Ts=Tm;
        #ifdef DEBUG
            std::cout << "CTF:\n" << *this << std::endl;
        #endif
        double iTs=1.0/Ts;
        return iTs;
    }

lookFor() [1/2]

void CTFDescription1D::lookFor	(	int	n,
		const Matrix1D< double > &	u,
		Matrix1D< double > &	freq,
		int	iwhat = 0
	)

Returns the continuous frequency of the zero, maximum or minimum number n in the direction u. u must be a unit vector, n=1,2,... Returns (-1,-1) if it is not found 'iwhat' can be 0 (zero), 1(max), or -1 (min)

Definition at line 701 of file ctf.cpp.

{
    double wmax = 1 / (2 * Tm);
    double wstep = wmax / 300;
    int found = 0;
    double last_ctf = getValuePureNoPrecomputedAt(0);
    double ctf=0.0;
    double state=1;

    double w = 0;

    while (w <= wmax)
    {
        V2_BY_CT(freq, u, w);
        ctf = getValuePureNoPrecomputedAt(XX(freq));

        switch (iwhat)
        {
            case 0: // Looking for zeroes
                if (SGN(ctf) != SGN(last_ctf))
                    found++;
                break;
            case 1: // Looking for maxima
                if (w>0)
                {
                    if (state==1) // Going up
                    {
                        if (ctf<last_ctf)
                        {
                            found++;
                            state=-1;
                        }
                    }
                    else // Going down
                    {
                        if (ctf>last_ctf)
                            state=1;
                    }
                }
                break;
            case -1: // Looking for minima
                if (w>0)
                {
                    if (state==-1) // Going down
                    {
                        if (ctf>last_ctf)
                        {
                            found++;
                            state=1;
                        }
                    }
                    else // Going up
                    {
                        if (ctf<last_ctf)
                            state=-1;
                    }
                }
                break;
        }
        if (found == n)
        {
            break;
        }

        last_ctf = ctf;
        w += wstep;
    }
    if (found != n)
    {

        VECTOR_R2(freq, -1, -1);
    }
    else
    {
        // Compute more accurate zero
#ifdef DEBUG
        std::cout << n << " zero: w=" << w << " (" << wmax << ") freq="
        << (u*w).transpose()
        << " last_ctf=" << last_ctf << " ctf=" << ctf << " ";
#endif

        switch (iwhat)
        {
            case 0:
                w += ctf * wstep / (last_ctf - ctf);
                break;
            default:
                w-=wstep;
        }
        V2_BY_CT(freq, u, w);
#ifdef DEBUG

        std::cout << " final w= " << w << " final freq=" << freq.transpose() << std::endl;
#endif
    }
}

lookFor() [2/2]

void CTFDescription::lookFor	(	int	n,
		const Matrix1D< double > &	u,
		Matrix1D< double > &	freq,
		int	iwhat = 0
	)

Returns the continuous frequency of the zero, maximum or minimum number n in the direction u. u must be a unit vector, n=1,2,... Returns (-1,-1) if it is not found 'iwhat' can be 0 (zero), 1(max), or -1 (min)

Definition at line 1428 of file ctf.cpp.

{
    double wmax = 1 / (2 * Tm);
    double wstep = wmax / 300;
    int found = 0;
    double last_ctf = getValuePureNoDampingNoPrecomputedAt(0,0);
    double ctf=0.0;
    double state=1; //getValuePureWithoutDampingAt()
    double w = 0;
    while (w <= wmax)
    {
        V2_BY_CT(freq, u, w);
        ctf = getValuePureNoDampingNoPrecomputedAt(XX(freq),YY(freq));
        switch (iwhat)
        {
            case 0: // Looking for zeroes
                if (SGN(ctf) != SGN(last_ctf))
                    found++;
                break;
            case 1: // Looking for maxima
                if (w>0)
                {
                    if (state==1) // Going up
                    {
                        if (ctf<last_ctf)
                        {
                            found++;
                            state=-1;
                        }
                    }
                    else // Going down
                    {
                        if (ctf>last_ctf)
                            state=1;
                    }
                }
                break;
            case -1: // Looking for minima
                if (w>0)
                {
                    if (state==-1) // Going down
                    {
                        if (ctf>last_ctf)
                        {
                            found++;
                            state=1;
                        }
                    }
                    else // Going up
                    {
                        if (ctf<last_ctf)
                            state=-1;
                    }
                }
                break;
        }
        if (found == n)
            break;

        last_ctf = ctf;
        w += wstep;
    }
    if (found != n)
    {
        VECTOR_R2(freq, -1, -1);
    }
    else
    {
        // Compute more accurate zero
#ifdef DEBUG
        std::cout << n << " zero: w=" << w << " (" << wmax << ") freq="
        << (u*w).transpose()
        << " last_ctf=" << last_ctf << " ctf=" << ctf << " ";
#endif

        switch (iwhat)
        {
            case 0:
                w += ctf * wstep / (last_ctf - ctf);
                break;
            default:
                w-=wstep;
        }
        V2_BY_CT(freq, u, w);
#ifdef DEBUG

        std::cout << " final w= " << w << " final freq=" << freq.transpose() << std::endl;
#endif
    }
}

precomputeValues() [1/6]

void CTFDescription1D::precomputeValues ( double  X )

inline

Precompute values for a given frequency.

Definition at line 376 of file ctf.h.

     {
         precomputed.ang = 0;
         precomputed.u2 = X * X;
         precomputed.u = sqrt(precomputed.u2);
         precomputed.u3 = precomputed.u2 * precomputed.u;
         precomputed.u4 = precomputed.u2 * precomputed.u2;
         precomputed.u_sqrt = sqrt(precomputed.u);

         if (fabs(X) < XMIPP_EQUAL_ACCURACY)
             precomputed.deltaf=0;
         else
         {

             /*
              * For a derivation of this formulae confer
              * Principles of Electron Optics page 1380
              * in particular term defocus and twofold axial astigmatism
              * take into account that a1 and a2 are the coefficient
              * of the zernike polynomials difference of defocus at 0
              * and at 45 degrees. In this case a2=0
              */
             precomputed.deltaf= Defocus;//(defocus_average + defocus_deviation*cos_ellipsoid_ang_2);

         }
     }

precomputeValues() [2/6]

void CTFDescription1D::precomputeValues

(

const MultidimArray< double > &

cont_x_freq

)

Precompute values for an image.

Definition at line 682 of file ctf.cpp.

{
    precomputedImage.reserve(MULTIDIM_SIZE(cont_x_freq));
        precomputedImageXdim=XSIZE(cont_x_freq);

        FOR_ALL_ELEMENTS_IN_ARRAY2D(cont_x_freq)
        {
            double X=A2D_ELEM(cont_x_freq,i,j);
            precomputeValues(X);
            if (fabs(X) < XMIPP_EQUAL_ACCURACY)
                precomputed.deltaf=0;
            else
                precomputed.deltaf=-1;
            precomputedImage.push_back(precomputed);
        }
}

precomputeValues() [3/6]

void CTFDescription1D::precomputeValues ( int  i )

inline

Precompute values for a given frequency.

Definition at line 407 of file ctf.h.

     {
         precomputed=precomputedImage[i+precomputedImageXdim];
         if (precomputed.deltaf==-1)
         {
             precomputed.deltaf= Defocus;
         }
     }

precomputeValues() [4/6]

void CTFDescription::precomputeValues ( double  X, double  Y  )

inline

Precompute values for a given frequency.

Definition at line 1002 of file ctf.h.

    {
        precomputed.ang=atan2(Y, X);
        precomputed.u2 = X * X + Y * Y;
        precomputed.u = sqrt(precomputed.u2);
        precomputed.u3 = precomputed.u2 * precomputed.u;
        precomputed.u4 = precomputed.u2 * precomputed.u2;
        precomputed.u_sqrt = sqrt(precomputed.u);

        if (fabs(X) < XMIPP_EQUAL_ACCURACY &&
            fabs(Y) < XMIPP_EQUAL_ACCURACY)
            precomputed.deltaf=0;
        else
        {
            double ellipsoid_ang = precomputed.ang - rad_azimuth;
            /*
             * For a derivation of this formulae confer
             * Principles of Electron Optics page 1380
             * in particular term defocus and twofold axial astigmatism
             * take into account that a1 and a2 are the coefficient
             * of the zernike polynomials difference of defocus at 0
             * and at 45 degrees. In this case a2=0
             */
            double cos_ellipsoid_ang_2 = cos(2*ellipsoid_ang);
            precomputed.deltaf= (defocus_average + defocus_deviation*cos_ellipsoid_ang_2);
        }
    }

precomputeValues() [5/6]

void CTFDescription::precomputeValues	(	const MultidimArray< double > &	cont_x_freq,
		const MultidimArray< double > &	cont_y_freq
	)

Precompute values for an image.

Definition at line 1406 of file ctf.cpp.

{
    precomputedImage.reserve(MULTIDIM_SIZE(cont_x_freq));
    precomputedImageXdim=XSIZE(cont_x_freq);

    FOR_ALL_ELEMENTS_IN_ARRAY2D(cont_x_freq)
    {
        double X=A2D_ELEM(cont_x_freq,i,j);
        double Y=A2D_ELEM(cont_y_freq,i,j);
        precomputeValues(X, Y);
        if (fabs(X) < XMIPP_EQUAL_ACCURACY &&
            fabs(Y) < XMIPP_EQUAL_ACCURACY)
            precomputed.deltaf=0;
        else
            precomputed.deltaf=-1;
        precomputedImage.push_back(precomputed);
    }
}

precomputeValues() [6/6]

void CTFDescription::precomputeValues ( int  i, int  j  )

inline

Precompute values for a given frequency.

Definition at line 1035 of file ctf.h.

    {

        precomputed=precomputedImage[i*precomputedImageXdim+j];

        if (precomputed.deltaf==-1)
        {
            double ellipsoid_ang = precomputed.ang - rad_azimuth;
            double cos_ellipsoid_ang_2 = cos(2*ellipsoid_ang);
            precomputed.deltaf= (defocus_average + defocus_deviation*cos_ellipsoid_ang_2);

        }
    }

produceSideInfo() [1/2]

void CTFDescription1D::produceSideInfo

(

)

Produce Side information.

Definition at line 645 of file ctf.cpp.

{
    // Change units
    double local_Cs = Cs * 1e7;
    double local_Ca = Ca * 1e7;
    double local_kV = kV * 1e3;
    double local_ispr = ispr * 1e6;

    lambda=12.2643247/sqrt(local_kV*(1.+0.978466e-6*local_kV)); // See http://en.wikipedia.org/wiki/Electron_diffraction
    //
    // Phase shift for spherical aberration
    // X(u)=-PI*deltaf(u)*lambda*u^2+PI/2*Cs*lambda^3*u^4
    // ICE: X(u)=-PI/2*deltaf(u)*lambda*u^2+PI/2*Cs*lambda^3*u^4
    //          = K1*deltaf(u)*u^2         +K2*u^4
    K1 = PI * lambda;
    K2 = PI / 2 * local_Cs * lambda * lambda * lambda;

    // Envelope
    // D(u)=Ed(u)*Ealpha(u)
    // Ed(u)=exp(-1/2*PI^2*lambda^2*D^2*u^4)
    // Ealpha(u)=exp(-PI^2*alpha^2*u^2*(Cs*lambda^2*u^2+Deltaf(u))^2)
    // ICE: Eespr(u)=exp(-(1/4*PI*Ca*lambda*espr/kV)^2*u^4/log2)
    // ICE: Eispr(u)=exp(-(1/2*PI*Ca*lambda*ispr)^2*u^4/log2)
    // ICE: EdeltaF(u)=bessj0(PI*DeltaF*lambda*u^2)
    // ICE: EdeltaR(u)=sinc(u*DeltaR)
    // ICE: Ealpha(u)=exp(-PI^2*alpha^2*(Cs*lambda^2*u^3+Deltaf(u)*u)^2)
    // CO: K3=pow(0.25*PI*Ca*lambda*(espr/kV,2)/log(2); Both combines in new K3
    // CO: K4=pow(0.5*PI*Ca*lambda*ispr,2)/log(2);
    K3 = pow(0.25 * PI * local_Ca * lambda * (espr / kV + 2 * local_ispr), 2) / log(2.0);
    K5 = PI * DeltaF * lambda;
    K6 = PI * PI * alpha * alpha;
    K7 = local_Cs * lambda * lambda;
    Ksin = sqrt(1-Q0*Q0);
    Kcos = Q0;
}

produceSideInfo() [2/2]

void CTFDescription::produceSideInfo

(

)

Produce Side information.

Definition at line 1392 of file ctf.cpp.

{
    CTFDescription1D::produceSideInfo();
    // Add parameters for 2D
    rad_azimuth = DEG2RAD(azimuthal_angle);
    rad_gaussian = DEG2RAD(gaussian_angle);
    rad_gaussian2 = DEG2RAD(gaussian_angle2);
    rad_sqrt = DEG2RAD(sqrt_angle);
    defocus_average   = -(DeltafU + DeltafV) * 0.5;
    defocus_deviation = -(DeltafU - DeltafV) * 0.5;
}

read() [1/2]

void CTFDescription1D::read	(	const FileName &	fn,
		bool	disable_if_not_K = true
	)

Read from file. An exception is thrown if the file cannot be open.

If no K or sqrt_K are given then it is assumed that the user does not want to activate that part and the noise or the CTF are removed from the model unless the disable_if_not_K is set to false

Definition at line 427 of file ctf.cpp.

{
    if (fn.isMetaData())
    {
        MetaDataVec md;
        md.read(fn);
        MDRowVec row;
        md.getRow(row, md.firstRowId());
        readFromMdRow(row, disable_if_not_K);
    }
}

read() [2/2]

void CTFDescription::read	(	const FileName &	fn,
		bool	disable_if_not_K = true
	)

Read from file. An exception is thrown if the file cannot be open.

If no K or sqrt_K are given then it is assumed that the user does not want to activate that part and the noise or the CTF are removed from the model unless the disable_if_not_K is set to false

Definition at line 1220 of file ctf.cpp.

{
    if (fn.isMetaData())
    {
        MetaDataVec md;
        md.read(fn);
        MDRowVec row;
        md.getRow(row, md.firstRowId());
        readFromMdRow(row, disable_if_not_K);
    }
}

readFromMdRow() [1/2]

void CTFDescription1D::readFromMdRow	(	const MDRow &	row,
		bool	disable_if_not_K = true
	)

Same as previuous reading function but providing the MDRow

Definition at line 365 of file ctf.cpp.

{
    row.getValueOrDefault(MDL_CTF_SAMPLING_RATE, Tm, 1);

    if (enable_CTF)
    {
        if (row.containsLabel(MDL_CTF_DEFOCUSU))
        {
            row.getValueOrDefault(MDL_CTF_VOLTAGE, kV, 100);
            row.getValueOrDefault(MDL_CTF_DEFOCUSU, Defocus, 0);
            row.getValueOrDefault(MDL_CTF_CS, Cs, 0);
            row.getValueOrDefault(MDL_CTF_CA, Ca, 0);
            row.getValueOrDefault(MDL_CTF_ENERGY_LOSS, espr, 0);
            row.getValueOrDefault(MDL_CTF_LENS_STABILITY, ispr, 0);
            row.getValueOrDefault(MDL_CTF_CONVERGENCE_CONE, alpha, 0);
            row.getValueOrDefault(MDL_CTF_LONGITUDINAL_DISPLACEMENT, DeltaF, 0);
            row.getValueOrDefault(MDL_CTF_TRANSVERSAL_DISPLACEMENT, DeltaR, 0);
            row.getValueOrDefault(MDL_CTF_Q0, Q0, 0);
            row.getValueOrDefault(MDL_CTF_K, K, 1);
            row.getValueOrDefault(MDL_CTF_ENV_R0, envR0, 0);
            row.getValueOrDefault(MDL_CTF_ENV_R1, envR1, 0);
            row.getValueOrDefault(MDL_CTF_ENV_R2, envR2, 0);
        }
        else if (row.containsLabel(MDL_CTF_MODEL))
        {
            FileName fnctf;
            row.getValue(MDL_CTF_MODEL,fnctf);
            MetaDataVec ctfparam;
            ctfparam.read(fnctf);
            readFromMetadataRow(ctfparam,ctfparam.firstRowId(), disable_if_not_K);
        }

        if (K == 0 && disable_if_not_K)
            enable_CTF = false;
    }
    if (enable_CTFnoise)
    {
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_K, gaussian_K, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_SIGMAU, sigma1, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_CU, Gc1, 0);
        row.getValueOrDefault(MDL_CTF_BG_SQRT_K, sqrt_K, 0);
        row.getValueOrDefault(MDL_CTF_BG_SQRT_U, sq, 0);
        row.getValueOrDefault(MDL_CTF_BG_BASELINE, base_line, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_K, gaussian_K2, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_SIGMAU, sigma2, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_CU, Gc2, 0);
        row.getValueOrDefault(MDL_CTF_BG_R1, bgR1, 0);
        row.getValueOrDefault(MDL_CTF_BG_R2, bgR2, 0);
        row.getValueOrDefault(MDL_CTF_BG_R3, bgR3, 0);

        if (gaussian_K == 0 && sqrt_K == 0 && base_line == 0 && gaussian_K2 == 0 &&
            disable_if_not_K)
            enable_CTFnoise = false;
    }
}

readFromMdRow() [2/2]

void CTFDescription::readFromMdRow	(	const MDRow &	row,
		bool	disable_if_not_K = true
	)

Same as previuous reading function but providing the MDRow

Definition at line 1172 of file ctf.cpp.

{
    CTFDescription1D::readFromMdRow(row, disable_if_not_K);
    if (enable_CTF)
    {
        if (row.containsLabel(MDL_CTF_DEFOCUSU))
        {
            row.getValueOrDefault(MDL_CTF_DEFOCUSU, DeltafU, 0);
            row.getValueOrDefault(MDL_CTF_DEFOCUSV, DeltafV, DeltafU);
            row.getValueOrDefault(MDL_CTF_DEFOCUS_ANGLE, azimuthal_angle, 0);
            row.getValueOrDefault(MDL_CTF_PHASE_SHIFT, phase_shift, 0);
            row.getValueOrDefault(MDL_CTF_VPP_RADIUS, VPP_radius, 0);

        }
        else if (row.containsLabel(MDL_CTF_MODEL))
        {
            FileName fnctf;
            row.getValue(MDL_CTF_MODEL,fnctf);
            MetaDataVec ctfparam;
            ctfparam.read(fnctf);
            readFromMetadataRow(ctfparam, ctfparam.firstRowId(), disable_if_not_K);
        }

    }
    if (enable_CTFnoise)
    {
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_SIGMAU, sigmaU, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_SIGMAV, sigmaV, sigmaU);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_CU, cU, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_CV, cV, cU);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN_ANGLE, gaussian_angle, 0);
        row.getValueOrDefault(MDL_CTF_BG_SQRT_U, sqU, 0);
        row.getValueOrDefault(MDL_CTF_BG_SQRT_V, sqV, sqU);
        row.getValueOrDefault(MDL_CTF_BG_SQRT_ANGLE, sqrt_angle, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_SIGMAU, sigmaU2, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_SIGMAV, sigmaV2, sigmaU2);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_CU, cU2, 0);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_CV, cV2, cU2);
        row.getValueOrDefault(MDL_CTF_BG_GAUSSIAN2_ANGLE, gaussian_angle2, 0);
    }
}

readFromMetadataRow() [1/2]

void CTFDescription1D::readFromMetadataRow	(	const MetaData &	MD,
		size_t	id,
		bool	disable_if_not_K = true
	)

Read from 1 row of a metadata file.

If no K or sqrt_K are given then it is assumed that the user does not want to activate that part and the noise or the CTF are removed from the model unless the disable_if_not_K is set to false This function should be used usually if you have all ctf parameters in columns format metadata or after calling fillExpand having CTF_MODEL

Definition at line 421 of file ctf.cpp.

{
    std::unique_ptr<const MDRow> row = md.getRow(id);
    readFromMdRow(*row, disable_if_not_K);
}

readFromMetadataRow() [2/2]

void CTFDescription::readFromMetadataRow	(	const MetaData &	MD,
		size_t	id,
		bool	disable_if_not_K = true
	)

Read from 1 row of a metadata file.

If no K or sqrt_K are given then it is assumed that the user does not want to activate that part and the noise or the CTF are removed from the model unless the disable_if_not_K is set to false This function should be used usually if you have all ctf parameters in columns format metadata or after calling fillExpand having CTF_MODEL

Definition at line 1214 of file ctf.cpp.

{
    std::unique_ptr<const MDRow> row = md.getRow(id);
    readFromMdRow(*row, disable_if_not_K);
}

readParams() [1/2]

void CTFDescription1D::readParams

(

XmippProgram *

program

)

Read parameters from the command line.

Definition at line 524 of file ctf.cpp.

{
    kV=Tm=Cs=0;
    if (program->checkParam("--ctf_similar_to"))
        read(program->getParam("--ctf_similar_to"));
    if (program->checkParam("--sampling_rate"))
        Tm=program->getDoubleParam("--sampling_rate");
    if (Tm==0)
        REPORT_ERROR(ERR_ARG_MISSING,"--sampling_rate");
    if (program->checkParam("--voltage"))
        kV=program->getDoubleParam("--voltage");
    if (kV==0)
        REPORT_ERROR(ERR_ARG_MISSING,"--voltage");
    if (program->checkParam("--spherical_aberration"))
        Cs=program->getDoubleParam("--spherical_aberration");
    if (program->checkParam("--defocusU"))
        Defocus=program->getDoubleParam("--defocusU");
    if (program->checkParam("--Q0"))
        Q0=program->getDoubleParam("--Q0");
    if (program->checkParam("--phase_shift"))
    {
        phase_shift=program->getDoubleParam("--phase_shift");
        phase_shift=(phase_shift*PI)/180;
    }
    else
        phase_shift = 0.0;
    if (program->checkParam("--VPP_radius"))
        VPP_radius=program->getDoubleParam("--VPP_radius");
    else
        VPP_radius = 0.0;
    Ca=program->getDoubleParam("--chromatic_aberration");
    espr=program->getDoubleParam("--energy_loss");
    ispr=program->getDoubleParam("--lens_stability");
    alpha=program->getDoubleParam("--convergence_cone");
    DeltaF=program->getDoubleParam("--longitudinal_displace");
    DeltaR=program->getDoubleParam("--transversal_displace");
    K=program->getDoubleParam("--K");
}

readParams() [2/2]

void CTFDescription::readParams

(

XmippProgram *

program

)

Read parameters from the command line.

Definition at line 1297 of file ctf.cpp.

{
    CTFDescription1D::readParams(program);
    if (program->checkParam("--defocusU"))
        DeltafU=program->getDoubleParam("--defocusU");
    if (program->checkParam("--defocusV"))
        DeltafV=program->getDoubleParam("--defocusV");
    else
        DeltafV=DeltafU;
    azimuthal_angle=program->getDoubleParam("--azimuthal_angle");
}

setRow() [1/2]

void CTFDescription1D::setRow

(

MDRow &

row

)

const

Write current CTF model to row

Definition at line 440 of file ctf.cpp.

{
    row.setValue(MDL_CTF_SAMPLING_RATE, Tm);
    if (enable_CTF)
    {
        row.setValue(MDL_CTF_VOLTAGE, kV);
        row.setValue(MDL_CTF_DEFOCUSU, Defocus);
        row.setValue(MDL_CTF_CS, Cs);
        row.setValue(MDL_CTF_CA, Ca);
        row.setValue(MDL_CTF_ENERGY_LOSS, espr);
        row.setValue(MDL_CTF_LENS_STABILITY, ispr);
        row.setValue(MDL_CTF_CONVERGENCE_CONE, alpha);
        row.setValue(MDL_CTF_LONGITUDINAL_DISPLACEMENT, DeltaF);
        row.setValue(MDL_CTF_TRANSVERSAL_DISPLACEMENT, DeltaR);
        row.setValue(MDL_CTF_Q0, Q0);
        row.setValue(MDL_CTF_K, K);
        row.setValue(MDL_CTF_ENV_R0, envR0);
        row.setValue(MDL_CTF_ENV_R1, envR1);
        row.setValue(MDL_CTF_ENV_R2, envR2);
    }
    if (enable_CTFnoise)
    {
        row.setValue(MDL_CTF_BG_GAUSSIAN_K, gaussian_K);
        row.setValue(MDL_CTF_BG_GAUSSIAN_SIGMAU, sigma1);
        row.setValue(MDL_CTF_BG_GAUSSIAN_CU, Gc1);
        row.setValue(MDL_CTF_BG_SQRT_K, sqrt_K);
        row.setValue(MDL_CTF_BG_SQRT_U, sq);
        row.setValue(MDL_CTF_BG_BASELINE, base_line);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_K, gaussian_K2);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_SIGMAU, sigma2);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_CU, Gc2);
        row.setValue(MDL_CTF_BG_R1, bgR1);
        row.setValue(MDL_CTF_BG_R2, bgR2);
        row.setValue(MDL_CTF_BG_R3, bgR3);
    }
    if (isLocalCTF)
    {
        row.setValue(MDL_CTF_X0, x0);
        row.setValue(MDL_CTF_XF, xF);
        row.setValue(MDL_CTF_Y0, y0);
        row.setValue(MDL_CTF_YF, yF);
    }
}

setRow() [2/2]

void CTFDescription::setRow

(

MDRow &

row

)

const

Write current model to row

Definition at line 1233 of file ctf.cpp.

{
    CTFDescription1D::setRow(row);
    if (enable_CTF)
    {
        row.setValue(MDL_CTF_DEFOCUSU, DeltafU);
        row.setValue(MDL_CTF_DEFOCUSV, DeltafV);
        row.setValue(MDL_CTF_DEFOCUS_ANGLE, azimuthal_angle);

    }
    if (enable_CTFnoise)
    {
        row.setValue(MDL_CTF_BG_GAUSSIAN_SIGMAU, sigmaU);
        row.setValue(MDL_CTF_BG_GAUSSIAN_SIGMAV, sigmaV);
        row.setValue(MDL_CTF_BG_GAUSSIAN_CU, cU);
        row.setValue(MDL_CTF_BG_GAUSSIAN_CV, cV);
        row.setValue(MDL_CTF_BG_GAUSSIAN_ANGLE, gaussian_angle);
        row.setValue(MDL_CTF_BG_SQRT_U, sqU);
        row.setValue(MDL_CTF_BG_SQRT_V, sqV);
        row.setValue(MDL_CTF_BG_SQRT_ANGLE, sqrt_angle);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_SIGMAU, sigmaU2);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_SIGMAV, sigmaV2);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_CU, cU2);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_CV, cV2);
        row.setValue(MDL_CTF_BG_GAUSSIAN2_ANGLE, gaussian_angle2);
        if(VPP_radius != 0.0)
        {
            row.setValue(MDL_CTF_PHASE_SHIFT, phase_shift);
            row.setValue(MDL_CTF_VPP_RADIUS, VPP_radius);
        }


    }
    if (isLocalCTF)
    {
        row.setValue(MDL_CTF_X0, x0);
        row.setValue(MDL_CTF_XF, xF);
        row.setValue(MDL_CTF_Y0, y0);
        row.setValue(MDL_CTF_YF, yF);
    }
}

write() [1/2]

void CTFDescription1D::write

(

const FileName &

fn

)

Write to file. An exception is thrown if the file cannot be open.

Definition at line 484 of file ctf.cpp.

{
    MDRowVec row;
    setRow(row);

    MetaDataVec md;
    md.setColumnFormat(false);
    md.addRow(row);
    md.write(fn);
}

write() [2/2]

void CTFDescription::write

(

const FileName &

fn

)

Write to file. An exception is thrown if the file cannot be open.

Definition at line 1275 of file ctf.cpp.

{
    MDRowVec row;
    setRow(row);

    MetaDataVec md;
    md.setColumnFormat(false);
    md.addRow(row);
    md.write(fn);
}

Variable Documentation

alpha

double CTFDescription1D::alpha

Convergence cone semiangle (in mrad). Typical value 0.5.

Definition at line 255 of file ctf.h.

ang

double PrecomputedForCTF::ang

Definition at line 90 of file ctf.h.

azimuthal_angle

double CTFDescription::azimuthal_angle

Azimuthal angle (between X and U) in degrees.

Definition at line 832 of file ctf.h.

base_line

double CTFDescription1D::base_line

Global base_line.

Definition at line 277 of file ctf.h.

bgR1

double CTFDescription1D::bgR1

Definition at line 295 of file ctf.h.

bgR2

double CTFDescription1D::bgR2

Definition at line 296 of file ctf.h.

bgR3

double CTFDescription1D::bgR3

Definition at line 297 of file ctf.h.

Ca

double CTFDescription1D::Ca

Chromatic aberration (in milimeters). Typical value 2.

Definition at line 248 of file ctf.h.

Cs

double CTFDescription1D::Cs

Spherical aberration (in milimeters). Typical value 5.6.

Definition at line 246 of file ctf.h.

cU

double CTFDescription::cU

Gaussian center for U.

Definition at line 875 of file ctf.h.

cU2

double CTFDescription::cU2

Second Gaussian center for U.

Definition at line 893 of file ctf.h.

cV

double CTFDescription::cV

Gaussian center for V.

Definition at line 877 of file ctf.h.

cV2

double CTFDescription::cV2

Second Gaussian center for V.

Definition at line 895 of file ctf.h.

D

double CTFDescription1D::D

Standard error of defocus Gaussian function due to chromatic aberration. in Angstroms

Definition at line 229 of file ctf.h.

Defocus

double CTFDescription1D::Defocus

Defocus (in Angstroms). Negative values are underfocused.

Definition at line 244 of file ctf.h.

defocus_average

double CTFDescription::defocus_average

Definition at line 802 of file ctf.h.

defocus_deviation

double CTFDescription::defocus_deviation

Definition at line 804 of file ctf.h.

deltaf

double PrecomputedForCTF::deltaf

Definition at line 91 of file ctf.h.

DeltaF

double CTFDescription1D::DeltaF

Longitudinal mechanical displacement (ansgtrom). Typical value 100.

Definition at line 257 of file ctf.h.

DeltafU

double CTFDescription::DeltafU

Global gain. By default, 1.

Standard error of defocus Gaussian function due to chromatic aberration. in AmstrongSampling rate (A/pixel) Accelerating Voltage (in KiloVolts) Defocus in U (in Angstroms). Negative values are underfocused

Definition at line 828 of file ctf.h.

DeltafV

double CTFDescription::DeltafV

Defocus in V (in Angstroms). Negative values are underfocused.

Definition at line 830 of file ctf.h.

DeltaR

double CTFDescription1D::DeltaR

Transversal mechanical displacement (ansgtrom). Typical value 3.

Definition at line 259 of file ctf.h.

enable_CTF

bool CTFDescription1D::enable_CTF

Enable CTF part.

Definition at line 275 of file ctf.h.

enable_CTFnoise

bool CTFDescription1D::enable_CTFnoise

Enable CTFnoise part.

Definition at line 273 of file ctf.h.

envR0

double CTFDescription1D::envR0

Definition at line 299 of file ctf.h.

envR1

double CTFDescription1D::envR1

Definition at line 300 of file ctf.h.

envR2

double CTFDescription1D::envR2

Definition at line 301 of file ctf.h.

espr

double CTFDescription1D::espr

Mean energy loss (eV) due to interaction with sample. Typical value 1

Definition at line 251 of file ctf.h.

freq_max

double CTFDescription1D::freq_max

Definition at line 303 of file ctf.h.

gaussian_angle

double CTFDescription::gaussian_angle

Gaussian angle.

Definition at line 879 of file ctf.h.

gaussian_angle2

double CTFDescription::gaussian_angle2

Second Gaussian angle.

Definition at line 897 of file ctf.h.

gaussian_K

double CTFDescription1D::gaussian_K

Gain for the gaussian term.

Definition at line 279 of file ctf.h.

gaussian_K2

double CTFDescription1D::gaussian_K2

Gain for the second Gaussian term.

Definition at line 289 of file ctf.h.

Gc1

double CTFDescription1D::Gc1

Gaussian center.

Definition at line 283 of file ctf.h.

Gc2

double CTFDescription1D::Gc2

Second Gaussian center.

Definition at line 293 of file ctf.h.

isLocalCTF

bool CTFDescription1D::isLocalCTF

Local CTF determination.

Definition at line 271 of file ctf.h.

ispr

double CTFDescription1D::ispr

Objective lens stability (deltaI/I) (ppm). Typical value 1.

Definition at line 253 of file ctf.h.

K

double CTFDescription1D::K

Global gain. By default, 1.

Definition at line 238 of file ctf.h.

K1

double CTFDescription1D::K1

Definition at line 218 of file ctf.h.

K2

double CTFDescription1D::K2

Definition at line 219 of file ctf.h.

K3

double CTFDescription1D::K3

Definition at line 220 of file ctf.h.

K4

double CTFDescription1D::K4

Definition at line 221 of file ctf.h.

K5

double CTFDescription1D::K5

Definition at line 222 of file ctf.h.

K6

double CTFDescription1D::K6

Definition at line 223 of file ctf.h.

K7

double CTFDescription1D::K7

Definition at line 224 of file ctf.h.

Kcos

double CTFDescription1D::Kcos

Definition at line 226 of file ctf.h.

Ksin

double CTFDescription1D::Ksin

Definition at line 225 of file ctf.h.

kV

double CTFDescription1D::kV

Accelerating Voltage (in KiloVolts)

Definition at line 242 of file ctf.h.

lambda

double CTFDescription1D::lambda

Definition at line 214 of file ctf.h.

phase_shift

double CTFDescription1D::phase_shift

Definition at line 305 of file ctf.h.

precomputed

PrecomputedForCTF CTFDescription1D::precomputed

Definition at line 231 of file ctf.h.

precomputedImage

std::vector<PrecomputedForCTF> CTFDescription1D::precomputedImage

Definition at line 233 of file ctf.h.

precomputedImageXdim

int CTFDescription1D::precomputedImageXdim

Definition at line 235 of file ctf.h.

Q0

double CTFDescription1D::Q0

Factor for the importance of the Amplitude contrast.

Definition at line 261 of file ctf.h.

rad_azimuth

double CTFDescription::rad_azimuth

Definition at line 800 of file ctf.h.

rad_gaussian

double CTFDescription::rad_gaussian

Definition at line 806 of file ctf.h.

rad_gaussian2

double CTFDescription::rad_gaussian2

Definition at line 808 of file ctf.h.

rad_sqrt

double CTFDescription::rad_sqrt

Definition at line 810 of file ctf.h.

sigma1

double CTFDescription1D::sigma1

Gaussian width.

Definition at line 281 of file ctf.h.

sigma2

double CTFDescription1D::sigma2

Second Gaussian width.

Definition at line 291 of file ctf.h.

sigmaU

double CTFDescription::sigmaU

Spherical aberration (in milimeters). Typical value 5.6.

Chromatic aberration (in milimeters). Typical value 2 Mean energy loss (eV) due to interaction with sample. Typical value 1 Objective lens stability (deltaI/I) (ppm). Typical value 1 Convergence cone semiangle (in mrad). Typical value 0.5 Longitudinal mechanical displacement (ansgtrom). Typical value 100 Transversal mechanical displacement (ansgtrom). Typical value 3 Factor for the importance of the Amplitude contrast. In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined Local CTF determination Enable CTFnoise part Enable CTF part Global base_line Gain for the gaussian term Gaussian width U

Definition at line 871 of file ctf.h.

sigmaU2

double CTFDescription::sigmaU2

Second Gaussian width U.

Definition at line 889 of file ctf.h.

sigmaV

double CTFDescription::sigmaV

Gaussian width V.

Definition at line 873 of file ctf.h.

sigmaV2

double CTFDescription::sigmaV2

Second Gaussian width V.

Definition at line 891 of file ctf.h.

sq

double CTFDescription1D::sq

Sqrt width.

Definition at line 287 of file ctf.h.

sqrt_angle

double CTFDescription::sqrt_angle

Sqrt angle.

Definition at line 887 of file ctf.h.

sqrt_K

double CTFDescription1D::sqrt_K

Gain for the square root term.

Definition at line 285 of file ctf.h.

sqU

double CTFDescription::sqU

Gain for the square root term.

Sqrt width U

Definition at line 883 of file ctf.h.

sqV

double CTFDescription::sqV

Sqrt width V.

Definition at line 885 of file ctf.h.

Tm

double CTFDescription1D::Tm

Sampling rate (A/pixel)

Definition at line 240 of file ctf.h.

u

double PrecomputedForCTF::u

Definition at line 86 of file ctf.h.

u2

double PrecomputedForCTF::u2

Definition at line 87 of file ctf.h.

u3

double PrecomputedForCTF::u3

Definition at line 88 of file ctf.h.

u4

double PrecomputedForCTF::u4

Definition at line 89 of file ctf.h.

u_sqrt

double PrecomputedForCTF::u_sqrt

Definition at line 85 of file ctf.h.

VPP_radius

double CTFDescription1D::VPP_radius

Definition at line 306 of file ctf.h.

x0

double CTFDescription1D::x0

In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined.

Definition at line 263 of file ctf.h.

xF

double CTFDescription1D::xF

In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined.

Definition at line 265 of file ctf.h.

y0

double CTFDescription1D::y0

In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined.

Definition at line 267 of file ctf.h.

yF

double CTFDescription1D::yF

In the case of local CTF determination x0,xF,y0,yF determines the region where the CTF is determined.

Definition at line 269 of file ctf.h.

Friends

operator<< [1/2]

std::ostream& operator<< ( std::ostream &  out, const CTFDescription1D &  ctf  )

friend

Show.

Definition at line 564 of file ctf.cpp.

{
    if (ctf.enable_CTF)
    {
        out
        << "sampling_rate=        " << ctf.Tm              << std::endl
        << "voltage=              " << ctf.kV              << std::endl
        << "defocusU=              " << ctf.Defocus         << std::endl
        << "spherical_aberration= " << ctf.Cs              << std::endl
        << "chromatic_aberration= " << ctf.Ca              << std::endl
        << "energy_loss=          " << ctf.espr            << std::endl
        << "lens_stability=       " << ctf.ispr            << std::endl
        << "convergence_cone=     " << ctf.alpha           << std::endl
        << "longitudinal_displace=" << ctf.DeltaF          << std::endl
        << "transversal_displace= " << ctf.DeltaR          << std::endl
        << "envR0=                " << ctf.envR0           << std::endl
        << "envR1=                " << ctf.envR1           << std::endl
        << "envR2=                " << ctf.envR2           << std::endl
        << "Q0=                   " << ctf.Q0              << std::endl
        << "K=                    " << ctf.K               << std::endl
        ;
    }
    if (ctf.enable_CTFnoise)
    {
        out
        << "gaussian_K=           " << ctf.gaussian_K      << std::endl
        << "sigma1=               " << ctf.sigma1          << std::endl
        << "Gc1=                  " << ctf.Gc1             << std::endl
        << "sqrt_K=               " << ctf.sqrt_K          << std::endl
        << "sq=                   " << ctf.sq              << std::endl
        << "bg1=                  " << ctf.bgR1            << std::endl
        << "bg2=                  " << ctf.bgR2            << std::endl
        << "bg3=                  " << ctf.bgR3            << std::endl
        << "base_line=            " << ctf.base_line       << std::endl
        << "gaussian_K2=          " << ctf.gaussian_K2     << std::endl
        << "sigma2=               " << ctf.sigma2          << std::endl
        << "Gc2=                  " << ctf.Gc2             << std::endl
        << "phase_shift=          " << ctf.phase_shift     << std::endl
        << "VPP_radius=           " << ctf.VPP_radius      << std::endl
        ;
    }
    return out;
}

operator<< [2/2]

std::ostream& operator<< ( std::ostream &  out, const CTFDescription &  ctf  )

friend

Show.

Definition at line 1310 of file ctf.cpp.

{
    if (ctf.enable_CTF)
    {
        out
        << "sampling_rate=        " << ctf.Tm               << std::endl
        << "voltage=              " << ctf.kV               << std::endl
        << "defocusU=             " << ctf.DeltafU         << std::endl
        << "defocusV=             " << ctf.DeltafV         << std::endl
        << "azimuthal_angle=      " << ctf.azimuthal_angle << std::endl
        << "spherical_aberration= " << ctf.Cs               << std::endl
        << "chromatic_aberration= " << ctf.Ca               << std::endl
        << "energy_loss=          " << ctf.espr             << std::endl
        << "lens_stability=       " << ctf.ispr             << std::endl
        << "convergence_cone=     " << ctf.alpha            << std::endl
        << "longitudinal_displace=" << ctf.DeltaF           << std::endl
        << "transversal_displace= " << ctf.DeltaR           << std::endl
        << "envR0=                " << ctf.envR0            << std::endl
        << "envR1=                " << ctf.envR1            << std::endl
        << "envR2=                " << ctf.envR2            << std::endl
        << "Q0=                   " << ctf.Q0               << std::endl
        << "K=                    " << ctf.K                << std::endl
        ;
    }
    if (ctf.enable_CTFnoise)
    {
        out
        << "gaussian_K=           " << ctf.gaussian_K      << std::endl
        << "sigmaU=               " << ctf.sigmaU          << std::endl
        << "sigmaV=               " << ctf.sigmaV          << std::endl
        << "cU=                   " << ctf.cU              << std::endl
        << "cV=                   " << ctf.cV              << std::endl
        << "gaussian_angle=       " << ctf.gaussian_angle  << std::endl
        << "sqrt_K=               " << ctf.sqrt_K          << std::endl
        << "sqU=                  " << ctf.sqU             << std::endl
        << "sqV=                  " << ctf.sqV             << std::endl
        << "sqrt_angle=           " << ctf.sqrt_angle      << std::endl
        << "bg1=                  " << ctf.bgR1            << std::endl
        << "bg2=                  " << ctf.bgR2            << std::endl
        << "bg3=                  " << ctf.bgR3            << std::endl
        << "base_line=            " << ctf.base_line       << std::endl
        << "gaussian_K2=          " << ctf.gaussian_K2     << std::endl
        << "sigmaU2=              " << ctf.sigmaU2         << std::endl
        << "sigmaV2=              " << ctf.sigmaV2         << std::endl
        << "cU2=                  " << ctf.cU2             << std::endl
        << "cV2=                  " << ctf.cV2             << std::endl
        << "gaussian_angle2=      " << ctf.gaussian_angle2 << std::endl
        << "phase_shift=          " << ctf.phase_shift     << std::endl
        << "VPP_radius=           " << ctf.VPP_radius      << std::endl
        ;
    }
    return out;
}