EMAN::EMAN1Ctf Class Reference

EMAN1Ctf is the CTF model used in EMAN1. More...

#include <ctf.h>

Inheritance diagram for EMAN::EMAN1Ctf:

Collaboration diagram for EMAN::EMAN1Ctf:

Public Member Functions
	EMAN1Ctf ()
	EMAN1Ctf (const vector< float > &vf)
	~EMAN1Ctf ()
vector< float >	compute_1d (int size, float ds, CtfType type, XYData *struct_factor=0)
vector< float >	compute_1d_fromimage (int size, float ds, EMData *image)
void	compute_2d_real (EMData *image, CtfType type, XYData *struct_factor=0)
void	compute_2d_complex (EMData *image, CtfType type, XYData *struct_factor=0)
int	from_string (const string &ctf)
string	to_string () const
void	from_dict (const Dict &dict)
Dict	to_dict () const
void	from_vector (const vector< float > &vctf)
vector< float >	to_vector () const
void	copy_from (const Ctf *new_ctf)
bool	equal (const Ctf *ctf1) const
float	zero (int n) const
float	get_defocus () const
float	get_bfactor () const
float	get_phase () const
void	set_phase (float phase)
Public Member Functions inherited from EMAN::Ctf
virtual	~Ctf ()

Public Attributes
float	amplitude
float	ampcont
float	noise1
float	noise2
float	noise3
float	noise4
Public Attributes inherited from EMAN::Ctf
float	defocus
float	bfactor
float	voltage
float	cs
float	apix

Private Member Functions
float	calc_amp1 ()
float	calc_lambda ()
float	calc_g1 ()
float	calc_g2 ()
float	calc_gamma (float g1, float g2, float s)
float	calc_ctf1 (float g, float gamma, float s)
float	calc_amplitude (float gamma)
float	calc_noise (float s)
float	calc_snr (float g1, float gamma, float s)

Additional Inherited Members
Public Types inherited from EMAN::Ctf
enum	CtfType {   CTF_AMP , CTF_SIGN , CTF_BACKGROUND , CTF_SNR ,   CTF_SNR_SMOOTH , CTF_WIENER_FILTER , CTF_TOTAL , CTF_FITREF ,   CTF_NOISERATIO , CTF_INTEN , CTF_POWEVAL , CTF_ALIFILT ,   CTF_ABS }

Detailed Description

EMAN1Ctf is the CTF model used in EMAN1.

Definition at line 119 of file ctf.h.

Constructor & Destructor Documentation

EMAN1Ctf() [1/2]

EMAN1Ctf::EMAN1Ctf

(

)

Definition at line 39 of file ctf.cpp.

{
        defocus = 0;
        bfactor = 0;
        amplitude = 0;
        ampcont = 0;
        noise1 = 0;
        noise2 = 0;
        noise3 = 0;
        noise4 = 0;
        voltage = 0;
        cs = 0;
        apix = 0;
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

EMAN1Ctf() [2/2]

EMAN::EMAN1Ctf::EMAN1Ctf ( const vector< float > &  vf )

inline

Definition at line 136 of file ctf.h.

{from_vector(vf);}      //for unpickling

References from_vector().

~EMAN1Ctf()

EMAN1Ctf::~EMAN1Ctf

(

)

Definition at line 55 of file ctf.cpp.

{
}

Member Function Documentation

calc_amp1()

float EMAN::EMAN1Ctf::calc_amp1 ( )

inlineprivate

Definition at line 172 of file ctf.h.

                {
                        return (sqrt(1 - ampcont * ampcont/10000.0f));
                }

References ampcont, and sqrt().

Referenced by compute_1d(), and compute_2d_complex().

calc_amplitude()

float EMAN::EMAN1Ctf::calc_amplitude ( float  gamma )

inlineprivate

Definition at line 210 of file ctf.h.

                {
                        float t1 = sqrt(1.0f - ampcont * ampcont/10000.0f) * sin(gamma);
                        float v = amplitude * (t1 + ampcont/100.0f * cos(gamma));
                        return v;
                }

References ampcont, amplitude, and sqrt().

Referenced by compute_2d_complex().

calc_ctf1()

float EMAN::EMAN1Ctf::calc_ctf1 ( float  g, float  gamma, float  s  )

inlineprivate

Definition at line 204 of file ctf.h.

                {
                        float r = amplitude * exp(-(bfactor/4.0f * s * s)) * (g * sin(gamma) + ampcont/100.0f * cos(gamma));
                        return r;
                }

References ampcont, amplitude, and EMAN::Ctf::bfactor.

Referenced by calc_snr(), compute_1d(), and compute_2d_complex().

calc_g1()

float EMAN::EMAN1Ctf::calc_g1 ( )

inlineprivate

Definition at line 183 of file ctf.h.

                {
                        float lambda = calc_lambda();
                        float g1 = 2.5e6f * cs * lambda * lambda * lambda;
                        return g1;
                }

References calc_lambda(), and EMAN::Ctf::cs.

Referenced by compute_1d(), and compute_2d_complex().

calc_g2()

float EMAN::EMAN1Ctf::calc_g2 ( )

inlineprivate

Definition at line 190 of file ctf.h.

                {
                        float lambda = calc_lambda();
                        float g2 = 5000.0f * -defocus * lambda;
                        return g2;
                }

References calc_lambda(), and EMAN::Ctf::defocus.

Referenced by compute_1d(), and compute_2d_complex().

calc_gamma()

float EMAN::EMAN1Ctf::calc_gamma ( float  g1, float  g2, float  s  )

inlineprivate

Definition at line 197 of file ctf.h.

                {
                        float s2 = s * s;
                        float gamma = (float) (-2 * M_PI * (g1 * s2 * s2 + g2 * s2));
                        return gamma;
                }

Referenced by compute_1d(), and compute_2d_complex().

calc_lambda()

float EMAN::EMAN1Ctf::calc_lambda ( )

inlineprivate

Definition at line 177 of file ctf.h.

                {
                        float lambda = 12.2639f / sqrt(voltage * 1000.0f + 0.97845f * voltage * voltage);
                        return lambda;
                }

References sqrt(), and EMAN::Ctf::voltage.

Referenced by calc_g1(), and calc_g2().

calc_noise()

float EMAN::EMAN1Ctf::calc_noise ( float  s )

inlineprivate

Definition at line 217 of file ctf.h.

                {
                        float ns = (float) M_PI / 2 * noise4 * s;
                        float ns2 = ns * ns;
                        float n = noise3 * exp(-ns2 - s * noise2 - sqrt(fabs(s)) * noise1);
                        return n;
                }

References noise1, noise2, noise3, noise4, and sqrt().

Referenced by calc_snr(), compute_1d(), and compute_2d_complex().

calc_snr()

float EMAN::EMAN1Ctf::calc_snr ( float  g1, float  gamma, float  s  )

inlineprivate

Definition at line 225 of file ctf.h.

                {
                        float ctf1 = calc_ctf1(g1, gamma, s);
                        float ctf2 = ctf1 * ctf1 / calc_noise(s);
                        return ctf2;
                }

References calc_ctf1(), and calc_noise().

Referenced by compute_1d().

compute_1d()

vector< float > EMAN1Ctf::compute_1d ( int  size, float  ds, CtfType  type, XYData *  struct_factor = 0  )

virtual

Implements EMAN::Ctf.

Definition at line 176 of file ctf.cpp.

{
        Assert(size > 0);
 
        float tmp_f1 =  sqrt((float) 2) * size / 2;
        int np = (int) ceil(tmp_f1) + 2;
        vector < float >r;
 
        r.resize(np);
 
//      float ds = 1 / (apix * size * CTFOS);
        float s = 0;
        float g1 = calc_g1();
        float g2 = calc_g2();
        float amp1 = calc_amp1();
 
        switch (type) {
        case CTF_AMP:
                for (int i = 0; i < np; i++) {
                        float gamma = calc_gamma(g1, g2, s);
                        r[i] = calc_ctf1(amp1, gamma, s);
                        s += ds;
                }
                break;
 
        case CTF_ABS:
                for (int i = 0; i < np; i++) {
                        float gamma = calc_gamma(g1, g2, s);
                        r[i] = fabs(calc_ctf1(amp1, gamma, s));
                        s += ds;
                }
                break;
 
        case CTF_SIGN:
                for (int i = 0; i < np; i++) {
                        float gamma = calc_gamma(g1, g2, s);
                        r[i] = calc_ctf1(amp1, gamma, s)>0?1.0f:-1.0f;
                        s += ds;
                }
                break;
 
        case CTF_BACKGROUND:
                for (int i = 0; i < np; i++) {
                        r[i] = calc_noise(s);
                        s += ds;
                }
                break;
 
        case CTF_SNR:
        case CTF_SNR_SMOOTH:
//              if (!sf) {
//                      LOGERR("CTF computation error, no SF found\n");
//                      return r;
//              }
 
                for (int i = 0; i < np; i++) {
                        float gamma = calc_gamma(g1, g2, s);
                        r[i] = calc_snr(amp1, gamma, s);
                        if (s && sf) {
                                r[i] *= sf->get_yatx(s);
                        }
                        s += ds;
                }
 
                break;
 
        case CTF_WIENER_FILTER:
                if (!sf) {
                        LOGERR("CTF computation error, no SF found\n");
                        return r;
                }
 
                for (int i = 0; i < np; i++) {
                        float gamma = calc_gamma(g1, g2, s);
                        r[i] = calc_snr(amp1, gamma, s);
                        if (s && sf) {
                                r[i] *= sf->get_yatx(s);
                        }
 
                        r[i] = 1.0f / (1.0f + 1.0f / r[i]);
                        s += ds;
                }
                break;
 
        case CTF_TOTAL:
                if (!sf) {
                        LOGERR("CTF computation error, no SF found\n");
                        return r;
                }
 
                for (int i = 0; i < np; i++) {
                        float gamma = calc_gamma(g1, g2, s);
                        if (sf) {
                                r[i] = calc_ctf1(amp1, gamma, s);
                                r[i] = r[i] * r[i] * sf->get_yatx(s) + calc_noise(s);
                        }
                        else {
                                r[i] = calc_ctf1(amp1, gamma, s);
                                r[i] = r[i] * r[i] + calc_noise(s);
                        }
                        s += ds;
                }
                break;
        default:
                break;
        }
 
        return r;
}

References Assert, calc_amp1(), calc_ctf1(), calc_g1(), calc_g2(), calc_gamma(), calc_noise(), calc_snr(), EMAN::Ctf::CTF_ABS, EMAN::Ctf::CTF_AMP, EMAN::Ctf::CTF_BACKGROUND, EMAN::Ctf::CTF_SIGN, EMAN::Ctf::CTF_SNR, EMAN::Ctf::CTF_SNR_SMOOTH, EMAN::Ctf::CTF_TOTAL, EMAN::Ctf::CTF_WIENER_FILTER, EMAN::XYData::get_yatx(), LOGERR, and sqrt().

compute_1d_fromimage()

vector< float > EMAN1Ctf::compute_1d_fromimage ( int  size, float  ds, EMData *  image  )

virtual

Implements EMAN::Ctf.

Definition at line 293 of file ctf.cpp.

{
        vector < float >r;
 
        printf("Sorry, this function hasn't been implemented for EMAN1Ctf\n");
        
        int np=size/2;
        r.resize(np);
 
        return r;
}

compute_2d_complex()

void EMAN1Ctf::compute_2d_complex ( EMData *  image, CtfType  type, XYData *  struct_factor = 0  )

virtual

Implements EMAN::Ctf.

Definition at line 306 of file ctf.cpp.

{
        // Discovered that whomever wrote these apparently never tested them. They do not follow the correct
        // conventions, and the results are rubbish!
        throw InvalidParameterException("EMAN1Ctf compute_2d_complex is broken, please use EMAN2Ctf instead");
        
        if (!image) {
                LOGERR("image is null. cannot computer 2D complex CTF");
                return;
        }
 
        if (image->is_complex() == false) {
                LOGERR("compute_2d_complex can only work on complex images");
                return;
        }
 
        int nx = image->get_xsize();
        int ny = image->get_ysize();
 
        if (nx != ny + 2) {
                LOGERR("compute_2d_complex only works on (nx, nx-2) images");
                return;
        }
 
        float ds = 1.0f / (apix * ny);
        image->to_one();
 
        float *d = image->get_data();
        float g1 = calc_g1();
        float g2 = calc_g2();
 
        if (type == CTF_BACKGROUND) {
                for (int y = 0; y < ny; y++) {
                        int ynx = y * nx;
 
                        for (int x = 0; x < nx / 2; x++) {
                                float s = (float) hypot(x, y - ny / 2.0f) * ds;
                                d[x * 2 + ynx] = calc_noise(s);
                                d[x * 2 + ynx + 1] = 0;                 // The phase is somewhat arbitrary
                        }
                }
        }
        else if (type == CTF_AMP) {
                for (int y = 0; y < ny; y++) {
                        int ynx = y * nx;
 
                        for (int x = 0; x < nx / 2; x++) {
                                float s = (float)hypot((float) x, (float) y - ny / 2) * ds;
                                float gamma = calc_gamma(g1, g2, s);
//                              float v = fabs(calc_amplitude(gamma));          // There should NOT be an fabs() here!  10/30/18
                                float v = calc_amplitude(gamma);
                                d[x * 2 + ynx] = v;
                                d[x * 2 + ynx + 1] = 0;
                        }
                }
        }
        else if (type == CTF_ABS) {
                for (int y = 0; y < ny; y++) {
                        int ynx = y * nx;
 
                        for (int x = 0; x < nx / 2; x++) {
                                float s = (float)hypot((float) x, (float) y - ny / 2) * ds;
                                float gamma = calc_gamma(g1, g2, s);
//                              float v = fabs(calc_amplitude(gamma));          // There should NOT be an fabs() here!  10/30/18
                                float v = calc_amplitude(gamma);
                                d[x * 2 + ynx] = fabs(v);
                                d[x * 2 + ynx + 1] = 0;
                        }
                }
        }
        else if (type == CTF_SIGN) {
                for (int y = 0; y < ny; y++) {
                        int ynx = y * nx;
                        for (int x = 0; x < nx / 2; x++) {
                                float s = (float)hypot(x, y - ny / 2.0f) * ds;
                                float gamma = calc_gamma(g1, g2, s);
                                float v = calc_amplitude(gamma);
                                d[x * 2 + ynx] = v > 0 ? 1.0f : -1.0f;
                                d[x * 2 + ynx + 1] = 0;
                        }
                }
 
        }
        else if (type == CTF_SNR || type == CTF_SNR_SMOOTH) {
                float amp1 = calc_amp1();
 
                for (int y = 0; y < ny; y++) {
                        int ynx = y * nx;
 
                        for (int x = 0; x < nx / 2; x++) {
 
                                float s = (float)hypot(x, y - ny / 2.0f) * ds;
                                float gamma = calc_gamma(g1, g2, s);
                                float f = calc_ctf1(amp1, gamma, s);
                                float noise = calc_noise(s);
                                f = f * f / noise;
 
                                if (s && sf) {
                                        f *= sf->get_yatx(s);
                                }
                                d[x * 2 + ynx] *= f;
                                d[x * 2 + ynx + 1] = 0;
                        }
                }
        }
        else if (type == CTF_WIENER_FILTER) {
                float amp1 = calc_amp1();
 
                for (int y = 0; y < ny; y++) {
                        int ynx = y * nx;
 
                        for (int x = 0; x < nx / 2; x++) {
 
                                float s = (float)hypot(x, y - ny / 2.0f) * ds;
                                float gamma = calc_gamma(g1, g2, s);
                                float f = calc_ctf1(amp1, gamma, s);
                                float noise = calc_noise(s);
                                f = f * f / noise;
 
                                if (s) {
                                        f *= sf->get_yatx(s);
                                }
                                f = 1.0f / (1.0f + 1.0f / f);
                                d[x * 2 + ynx] *= f;
                                d[x * 2 + ynx + 1] = 0;
                        }
                }
        }
        else if (type == CTF_TOTAL) {
                float amp1 = calc_amp1();
 
                for (int y = 0; y < ny; y++) {
                        int ynx = y * nx;
 
                        for (int x = 0; x < nx / 2; x++) {
 
                                float s = (float)hypot(x, y - ny / 2.0f) * ds;
                                float gamma = calc_gamma(g1, g2, s);
                                float f = calc_ctf1(amp1, gamma, s);
                                float noise = calc_noise(s);
                                f = f * f;
 
                                if (sf && s) {
                                        f *= sf->get_yatx(s);
                                }
                                f+=noise;
 
                                d[x * 2 + ynx] *= f;
                                d[x * 2 + ynx + 1] = 0;
                        }
                }
        }
 
        image->update();
}

References EMAN::Ctf::apix, calc_amp1(), calc_amplitude(), calc_ctf1(), calc_g1(), calc_g2(), calc_gamma(), calc_noise(), EMAN::Ctf::CTF_ABS, EMAN::Ctf::CTF_AMP, EMAN::Ctf::CTF_BACKGROUND, EMAN::Ctf::CTF_SIGN, EMAN::Ctf::CTF_SNR, EMAN::Ctf::CTF_SNR_SMOOTH, EMAN::Ctf::CTF_TOTAL, EMAN::Ctf::CTF_WIENER_FILTER, EMAN::XYData::get_yatx(), InvalidParameterException, LOGERR, x, and y.

compute_2d_real()

void EMAN1Ctf::compute_2d_real ( EMData *  image, CtfType  type, XYData *  struct_factor = 0  )

virtual

Implements EMAN::Ctf.

Definition at line 287 of file ctf.cpp.

{
 
 
}

copy_from()

void EMAN1Ctf::copy_from ( const Ctf *  new_ctf )

virtual

Implements EMAN::Ctf.

Definition at line 157 of file ctf.cpp.

{
        if (new_ctf) {
                const EMAN1Ctf *c = static_cast<const EMAN1Ctf *>(new_ctf);
                defocus = c->defocus;
                bfactor = c->bfactor;
                amplitude = c->amplitude;
                ampcont = c->ampcont;
                noise1 = c->noise1;
                noise2 = c->noise2;
                noise3 = c->noise3;
                noise4 = c->noise4;
                voltage = c->voltage;
                cs = c->cs;
                apix = c->apix;
        }
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

equal()

bool EMAN1Ctf::equal ( const Ctf *  ctf1 ) const

virtual

Implements EMAN::Ctf.

Definition at line 464 of file ctf.cpp.

{
        if (ctf1) {
                const EMAN1Ctf *c = static_cast<const EMAN1Ctf *>(ctf1);
                if (defocus == c->defocus &&
                        bfactor == c->bfactor &&
                        amplitude == c->amplitude &&
                        ampcont == c->ampcont &&
                        noise1 == c->noise1 &&
                        noise2 == c->noise2 &&
                        noise3 == c->noise3 &&
                        noise4 == c->noise4 && voltage == c->voltage && cs == c->cs && apix == c->apix) {
                        return true;
                }
        }
        return false;
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

from_dict()

void EMAN1Ctf::from_dict ( const Dict &  dict )

virtual

Implements EMAN::Ctf.

Definition at line 79 of file ctf.cpp.

{
        defocus = dict["defocus"];
        bfactor = dict["bfactor"];
        amplitude = dict["amplitude"];
        ampcont = dict["ampcont"];
        noise1 = dict["noise1"];
        noise2 = dict["noise2"];
        noise3 = dict["noise3"];
        noise4 = dict["noise4"];
        voltage = dict["voltage"];
        cs = dict["cs"];
        apix = dict["apix"];
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

from_string()

int EMAN1Ctf::from_string ( const string &  ctf )

virtual

Implements EMAN::Ctf.

Definition at line 60 of file ctf.cpp.

{
        Assert(ctf != "");
        char type;
        int pos;
        int i = sscanf(ctf.c_str(), "%c%f %f %f %f %f %f %f %f %f %f %f%n",
                                   &type,&defocus, &bfactor, &amplitude, &ampcont, &noise1,
                                   &noise2, &noise3, &noise4, &voltage, &cs, &apix, &pos);
        defocus*=-1.0;          // different convention in EMAN2
        ampcont*=100.0;         // different convention in EMAN2
        bfactor*=4.0;           // again
        if (pos==-1) {
                const char *s=ctf.c_str();
                throw InvalidValueException(s," Invalid CTF string");
        }
                
        return 0;
}

References ampcont, amplitude, EMAN::Ctf::apix, Assert, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, InvalidValueException, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

from_vector()

void EMAN1Ctf::from_vector ( const vector< float > &  vctf )

virtual

Implements EMAN::Ctf.

Definition at line 112 of file ctf.cpp.

{
        defocus = vctf[0];
        bfactor = vctf[1];
        amplitude = vctf[2];
        ampcont = vctf[3];
        noise1 = vctf[4];
        noise2 = vctf[5];
        noise3 = vctf[6];
        noise4 = vctf[7];
        voltage = vctf[8];
        cs = vctf[9];
        apix = vctf[10];
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

Referenced by EMAN1Ctf(), and get_ctf().

get_bfactor()

float EMAN::EMAN1Ctf::get_bfactor ( ) const

inline

Definition at line 162 of file ctf.h.

                {
                        return bfactor;
                }

References EMAN::Ctf::bfactor.

get_defocus()

float EMAN::EMAN1Ctf::get_defocus ( ) const

inline

Definition at line 158 of file ctf.h.

                {
                        return defocus;
                }

References EMAN::Ctf::defocus.

get_phase()

float EMAN::EMAN1Ctf::get_phase ( ) const

inlinevirtual

Implements EMAN::Ctf.

Definition at line 167 of file ctf.h.

{ return 0.0; } 

set_phase()

void EMAN::EMAN1Ctf::set_phase ( float  phase )

inlinevirtual

Implements EMAN::Ctf.

Definition at line 169 of file ctf.h.

{ }

to_dict()

Dict EMAN1Ctf::to_dict ( ) const

virtual

Implements EMAN::Ctf.

Definition at line 94 of file ctf.cpp.

{
        Dict dict;
        dict["defocus"] = defocus;
        dict["bfactor"] = bfactor;
        dict["amplitude"] = amplitude;
        dict["ampcont"] = ampcont;
        dict["noise1"] = noise1;
        dict["noise2"] = noise2;
        dict["noise3"] = noise3;
        dict["noise4"] = noise4;
        dict["voltage"] = voltage;
        dict["cs"] = cs;
        dict["apix"] = apix;
 
        return dict;
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

to_string()

string EMAN1Ctf::to_string ( ) const

virtual

Implements EMAN::Ctf.

Definition at line 147 of file ctf.cpp.

{
        char ctf[1024];
        sprintf(ctf, "O%1.10g %1.10g %1.10g %1.10g %1.10g %1.10g %1.10g %1.10g %1.10g %1.10g %1.10g",
                        -defocus, bfactor/4.0, amplitude, ampcont/100.0, noise1, noise2, noise3, noise4, voltage, cs,
                        apix);
 
        return string(ctf);
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

to_vector()

vector< float > EMAN1Ctf::to_vector ( ) const

virtual

Implements EMAN::Ctf.

Definition at line 127 of file ctf.cpp.

{
        vector<float> vctf;
 
        vctf.push_back(defocus);
        vctf.push_back(bfactor);
        vctf.push_back(amplitude);
        vctf.push_back(ampcont);
        vctf.push_back(noise1);
        vctf.push_back(noise2);
        vctf.push_back(noise3);
        vctf.push_back(noise4);
        vctf.push_back(voltage);
        vctf.push_back(cs);
        vctf.push_back(apix);
 
        return vctf;
}

References ampcont, amplitude, EMAN::Ctf::apix, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, noise1, noise2, noise3, noise4, and EMAN::Ctf::voltage.

Referenced by EMAN::MrcIO::read_mrc_header().

zero()

float EMAN1Ctf::zero ( int  n ) const

virtual

Implements EMAN::Ctf.

Definition at line 482 of file ctf.cpp.

{ return 0; }

Member Data Documentation

ampcont

float EMAN::EMAN1Ctf::ampcont

Definition at line 125 of file ctf.h.

Referenced by calc_amp1(), calc_amplitude(), calc_ctf1(), copy_from(), EMAN1Ctf(), equal(), from_dict(), from_string(), from_vector(), to_dict(), to_string(), and to_vector().

amplitude

float EMAN::EMAN1Ctf::amplitude

Definition at line 124 of file ctf.h.

Referenced by calc_amplitude(), calc_ctf1(), copy_from(), EMAN1Ctf(), equal(), from_dict(), from_string(), from_vector(), to_dict(), to_string(), and to_vector().

noise1

float EMAN::EMAN1Ctf::noise1

Definition at line 126 of file ctf.h.

Referenced by calc_noise(), copy_from(), EMAN1Ctf(), equal(), from_dict(), from_string(), from_vector(), to_dict(), to_string(), and to_vector().

noise2

float EMAN::EMAN1Ctf::noise2

Definition at line 127 of file ctf.h.

Referenced by calc_noise(), copy_from(), EMAN1Ctf(), equal(), from_dict(), from_string(), from_vector(), to_dict(), to_string(), and to_vector().

noise3

float EMAN::EMAN1Ctf::noise3

Definition at line 128 of file ctf.h.

Referenced by calc_noise(), copy_from(), EMAN1Ctf(), equal(), from_dict(), from_string(), from_vector(), to_dict(), to_string(), and to_vector().

noise4

float EMAN::EMAN1Ctf::noise4

Definition at line 129 of file ctf.h.

Referenced by calc_noise(), copy_from(), EMAN1Ctf(), equal(), from_dict(), from_string(), from_vector(), to_dict(), to_string(), and to_vector().

---

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

• ctf.h
• ctf.cpp