Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

EMAN::EMAN2Ctf Class Reference

EMAN2Ctf is the default CTF model used in EMAN2. More...

#include <ctf.h>

Inheritance diagram for EMAN::EMAN2Ctf:

Inheritance graph
[legend]
Collaboration diagram for EMAN::EMAN2Ctf:

Collaboration graph
[legend]
List of all members.

Public Member Functions

vector< float > get_snr ()
void set_snr (const vector< float > &vf)
vector< float > get_background ()
void set_background (const vector< float > &vf)
 EMAN2Ctf ()
 EMAN2Ctf (const vector< float > &vf)
 ~EMAN2Ctf ()
vector< float > compute_1d (int size, float ds, CtfType type, XYData *struct_factor=0)
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

Public Attributes

float dfdiff
float dfang
float ampcont
float dsbg
vector< float > background
vector< float > snr

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)

Detailed Description

EMAN2Ctf is the default CTF model used in EMAN2.

Definition at line 222 of file ctf.h.


Constructor & Destructor Documentation

EMAN2Ctf::EMAN2Ctf  ) 
 

Definition at line 470 of file ctf.cpp.

References ampcont, background, dfang, dfdiff, dsbg, and snr.

00471 {
00472         defocus = 0;
00473         dfdiff = 0;
00474         dfang = 0;
00475         bfactor = 0;
00476         ampcont = 0;
00477         voltage = 0;
00478         cs = 0;
00479         apix = 1.0;
00480         dsbg=-1;
00481         background.clear();
00482         snr.clear();
00483 }

EMAN::EMAN2Ctf::EMAN2Ctf const vector< float > &  vf  )  [inline]
 

Definition at line 244 of file ctf.h.

00244 {from_vector(vf);}      //for unpickling

EMAN2Ctf::~EMAN2Ctf  ) 
 

Definition at line 486 of file ctf.cpp.

00487 {
00488 }


Member Function Documentation

float EMAN::EMAN2Ctf::calc_amp1  )  [inline, private]
 

Definition at line 264 of file ctf.h.

References sqrt().

Referenced by compute_1d(), and compute_2d_complex().

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

float EMAN::EMAN2Ctf::calc_amplitude float  gamma  )  [inline, private]
 

Definition at line 302 of file ctf.h.

References sqrt(), and v.

Referenced by compute_2d_complex().

00303                 {
00304                         float t1 = sqrt(1.0f - ampcont * ampcont/10000.0f) * sin(gamma);
00305                         float v = (t1 + ampcont/100.0f * cos(gamma));
00306                         return v;
00307                 }

float EMAN::EMAN2Ctf::calc_ctf1 float  g,
float  gamma,
float  s
[inline, private]
 

Definition at line 296 of file ctf.h.

Referenced by compute_1d(), and compute_2d_complex().

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

float EMAN::EMAN2Ctf::calc_g1  )  [inline, private]
 

Definition at line 275 of file ctf.h.

Referenced by compute_1d(), and compute_2d_complex().

00276                 {
00277                         float lambda = calc_lambda();
00278                         float g1 = 2.5e6f * cs * lambda * lambda * lambda;
00279                         return g1;
00280                 }

float EMAN::EMAN2Ctf::calc_g2  )  [inline, private]
 

Definition at line 282 of file ctf.h.

Referenced by compute_1d(), and compute_2d_complex().

00283                 {
00284                         float lambda = calc_lambda();
00285                         float g2 = 5000.0f * -defocus * lambda;
00286                         return g2;
00287                 }

float EMAN::EMAN2Ctf::calc_gamma float  g1,
float  g2,
float  s
[inline, private]
 

Definition at line 289 of file ctf.h.

Referenced by compute_1d(), and compute_2d_complex().

00290                 {
00291                         float s2 = s * s;
00292                         float gamma = (float) (-2 * M_PI * (g1 * s2 * s2 + g2 * s2));
00293                         return gamma;
00294                 }

float EMAN::EMAN2Ctf::calc_lambda  )  [inline, private]
 

Definition at line 269 of file ctf.h.

References sqrt().

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

float EMAN::EMAN2Ctf::calc_noise float  s  )  [inline, private]
 

Definition at line 309 of file ctf.h.

Referenced by compute_1d(), and compute_2d_complex().

00310                 {
00311                         int si=(int)(s/dsbg);
00312                         if (si>(int)background.size()||si<0) return background.back();
00313                         return background[si];
00314                 }

vector< float > EMAN2Ctf::compute_1d int  size,
float  ds,
CtfType  type,
XYData struct_factor = 0
[virtual]
 

Implements EMAN::Ctf.

Definition at line 643 of file ctf.cpp.

References Assert, background, calc_amp1(), calc_ctf1(), calc_g1(), calc_g2(), calc_gamma(), calc_noise(), div(), EMAN::XYData::get_yatx(), max_int(), min_int(), snr, x, and y.

00644 {
00645         Assert(size > 0);
00646 
00647 //      float tmp_f1 =  sqrt((float) 2) * size / 2;
00648 //      int np = (int) ceil(tmp_f1) + 2;
00649         int np=size/2;
00650         vector < float >r;
00651 
00652         r.resize(np);
00653 
00654 //      float ds = 1 / (apix * size);
00655         float s = 0;
00656         float g1 = calc_g1();
00657         float g2 = calc_g2();
00658         float amp1 = calc_amp1();
00659 
00660         switch (type) {
00661         case CTF_AMP:
00662                 for (int i = 0; i < np; i++) {
00663                         float gamma = calc_gamma(g1, g2, s);
00664                         r[i] = calc_ctf1(amp1, gamma, s);
00665                         s += ds;
00666                 }
00667                 break;
00668 
00669         case CTF_SIGN:
00670                 for (int i = 0; i < np; i++) {
00671                         float gamma = calc_gamma(g1, g2, s);
00672                         r[i] = calc_ctf1(amp1, gamma, s)>=0?1.0f:-1.0f;
00673                         s += ds;
00674                 }
00675                 break;
00676 
00677         case CTF_BACKGROUND:
00678                 for (int i = 0; i < np; i++) {
00679                         float f = s/dsbg;
00680                         int j = (int)floor(f);
00681                         f-=j;
00682                         if (j>(int)background.size()-2) r[i]=background.back();
00683                         else r[i]=background[j]*(1.0f-f)+background[j+1]*f;
00684                         s+=ds;
00685                 }
00686                 break;
00687 
00688         case CTF_SNR:
00689                 for (int i = 0; i < np; i++) {
00690                         float f = s/dsbg;
00691                         int j = (int)floor(f);
00692                         f-=j;
00693                         if (j>(int)snr.size()-2) r[i]=snr.back();
00694                         else r[i]=snr[j]*(1.0f-f)+snr[j+1]*f;
00695 //                      printf("%d\t%f\n",j,snr[j]);
00696                         s+=ds;
00697                 }
00698                 break;
00699         case CTF_SNR_SMOOTH:
00700                 // This apparently complicated routine tries to make a nice smooth and accurate SNR curve. It does this
00701                 // by fitting local regions of the SNR vs the theoretical SNR (theoretical CTF^2/measured background),
00702                 // then taking the slope of the result times the theoretical SNR to produce a local SNR estimate
00703 
00704                 { // <- is to permit new temporary value allocation
00705                         vector < float >tsnr;   // theoretical SNR
00706                         tsnr.resize(np);
00707                         vector < float >dsnr;   // data SNR
00708                         dsnr.resize(np);
00709                         
00710                         float s0=s;
00711                         
00712                         for (int i = 0; i < np; i++) {
00713                                 float gamma = calc_gamma(g1, g2, s);
00714                                 tsnr[i] = calc_ctf1(amp1, gamma, s);            // ctf amp
00715 
00716                                 // background value
00717                                 float f = s/dsbg;
00718                                 int j = (int)floor(f);
00719                                 f-=j;
00720                                 float bg;
00721                                 if (j>(int)background.size()-2) bg=background.back();
00722                                 else bg=background[j]*(1.0f-f)+background[j+1]*f;
00723                                 if (bg <=0) bg=.001;
00724 
00725                                 tsnr[i] = tsnr[i]*tsnr[i]/bg;           // This is now a SNR curve
00726                                 if (sf && s) {
00727                                         tsnr[i] *= sf->get_yatx(s);
00728                                 }
00729 
00730                                 
00731                                 // This is the SNR computed from the data without fitting
00732                                 if (j>(int)snr.size()-2) dsnr[i]=snr.back();
00733                                 else dsnr[i]=snr[j]*(1.0f-f)+snr[j+1]*f;
00734                                 
00735                                 s+=ds;
00736                         }
00737 
00738                         int npsm=np/25;                 // 1/2 number of points to smooth over, 25 is arbitrary
00739                         if (npsm<2) npsm=2;
00740                         
00741                         s=s0;
00742                         for (int i = 1; i < np; i++) {
00743                                 // simple linear regression embedded here
00744                                 double sum = 0;
00745                                 double sum_x = 0;
00746                                 double sum_y = 0;
00747                                 double sum_xx = 0;
00748                                 double sum_xy = 0;
00749 
00750                                 for (int k=max_int(i-npsm,1); k<=min_int(i+npsm,np); k++) {
00751                                         double y = dsnr[k];
00752                                         double x = tsnr[k];
00753 
00754                                         sum_x += x;
00755                                         sum_y += y;
00756                                         sum_xx += x * x;
00757                                         sum_xy += x * y;
00758                                         sum++;
00759                                 }
00760 
00761                                 double div = sum * sum_xx - sum_x * sum_x;
00762                                 if (div == 0) {
00763                                         div = 0.0000001f;
00764                                 }
00765 
00766         //                      *intercept = (float) ((sum_xx * sum_y - sum_x * sum_xy) / div);
00767         //                      *slope = (float) ((sum * sum_xy - sum_x * sum_y) / div);
00768 
00769                                 r[i]=(float) ((sum * sum_xy - sum_x * sum_y) / div)*tsnr[i];
00770                                 if (r[i]<0) r[i]=0;
00771                                 
00772                                 s+=ds;
00773                         }
00774                         r[0]=0;
00775                 }
00776                 break;
00777 
00778         case CTF_WIENER_FILTER:
00779 //              if (!sf) {
00780 //                      LOGERR("CTF computation error, no SF found\n");
00781 //                      return r;
00782 //              }
00783 
00784                 for (int i = 0; i < np; i++) {
00785                         float f = s/dsbg;
00786                         int j = (int)floor(f);
00787                         float bg;
00788                         f-=j;
00789                         if (j>(int)snr.size()-2) {
00790 /*                              r[i]=snr.back();
00791                                 bg=background.back();*/
00792                                 r[i]=0;
00793                         }
00794                         else {
00795                                 r[i]=snr[j]*(1.0f-f)+snr[j+1]*f;
00796                                 bg=background[j]*(1.0f-f)+background[j+1]*f;
00797                         }
00798                         if (r[i]<0) r[i]=0;
00799                         r[i]=r[i]/(r[i]+1.0f);          // Full Wiener filter assuming perfect image with noise
00800 //                      r[i]=sqrt(r[i]/bg)/(r[i]+1.0);  // Wiener filter with 1/CTF term (sort of) to restore image then filter
00801                         s+=ds;
00802                 }
00803                 r[0]=0;
00804                 break;
00805 
00806         case CTF_TOTAL:
00807 
00808                 for (int i = 0; i < np; i++) {
00809                         float gamma = calc_gamma(g1, g2, s);
00810                         if (sf) {
00811                                 r[i] = calc_ctf1(amp1, gamma, s);
00812                                 r[i] = r[i] * r[i] * sf->get_yatx(s) + calc_noise(s);
00813                         }
00814                         else {
00815                                 r[i] = calc_ctf1(amp1, gamma, s);
00816                                 r[i] = r[i] * r[i] + calc_noise(s);
00817                         }
00818                         s += ds;
00819                 }
00820                 break;
00821         default:
00822                 break;
00823         }
00824 
00825         return r;
00826 }

void EMAN2Ctf::compute_2d_complex EMData image,
CtfType  type,
XYData struct_factor = 0
[virtual]
 

Implements EMAN::Ctf.

Definition at line 837 of file ctf.cpp.

References background, calc_amp1(), calc_amplitude(), calc_ctf1(), calc_g1(), calc_g2(), calc_gamma(), calc_noise(), dsbg, EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::XYData::get_yatx(), EMAN::EMData::get_ysize(), EMAN::Util::hypot_fast(), EMAN::EMData::is_complex(), LOGERR, nx, ny, snr, EMAN::EMData::to_one(), EMAN::EMData::update(), v, x, and y.

00838 {
00839         if (!image) {
00840                 LOGERR("image is null. cannot computer 2D complex CTF");
00841                 return;
00842         }
00843 
00844         if (image->is_complex() == false) {
00845                 LOGERR("compute_2d_complex can only work on complex images");
00846                 return;
00847         }
00848 
00849         int nx = image->get_xsize();
00850         int ny = image->get_ysize();
00851 
00852         if ((ny%2==1 && nx!=ny+1) || (ny%2==0 && nx != ny + 2)) {
00853                 printf("nx=%d  ny=%d\n",nx,ny);
00854                 LOGERR("compute_2d_complex only works on (nx, nx-2) images");
00855                 return;
00856         }
00857 
00858         float ds = 1.0f / (apix * ny);
00859         image->to_one();
00860 
00861         float *d = image->get_data();
00862         float g1 = calc_g1();
00863         float g2 = calc_g2();
00864         float amp1 = calc_amp1();
00865 
00866         if (type == CTF_BACKGROUND) {
00867                 for (int y = -ny/2; y < ny/2; y++) {
00868                         int y2=(y+ny)%ny;
00869                         int ynx = y2 * nx;
00870 
00871                         for (int x = 0; x < nx / 2; x++) {
00872                                 float s = (float) Util::hypot_fast(x, y ) * ds;
00873                                 d[x * 2 + ynx] = calc_noise(s);
00874                                 d[x * 2 + ynx + 1] = 0;                 // The phase is somewhat arbitrary
00875                         }
00876                 }
00877         }
00878         else if (type == CTF_AMP) {
00879                 for (int y = -ny/2; y < ny/2; y++) {
00880                         int y2=(y+ny)%ny;
00881                         int ynx = y2 * nx;
00882 
00883                         for (int x = 0; x < nx / 2; x++) {
00884                                 float s = (float)Util::hypot_fast(x,y ) * ds;
00885                                 float gamma = calc_gamma(g1, g2, s);
00886                                 float v = calc_ctf1(amp1, gamma, s);
00887 //                              float v = calc_amplitude(gamma);
00888                                 d[x * 2 + ynx] = v;
00889                                 d[x * 2 + ynx + 1] = 0;
00890                         }
00891                 }
00892         }
00893         else if (type == CTF_SIGN) {
00894                 for (int y = -ny/2; y < ny/2; y++) {
00895                         int y2=(y+ny)%ny;
00896                         int ynx = y2 * nx;
00897                         for (int x = 0; x < nx / 2; x++) {
00898                                 float s = (float)Util::hypot_fast(x,y ) * ds;
00899                                 float gamma = calc_gamma(g1, g2, s);
00900                                 float v = calc_amplitude(gamma);
00901                                 d[x * 2 + ynx] = v >= 0 ? 1.0f : -1.0f;
00902                                 d[x * 2 + ynx + 1] = 0;
00903                         }
00904                 }
00905         }
00906         else if (type == CTF_SNR) {
00907 
00908                 for (int y = -ny/2; y < ny/2; y++) {
00909                         int y2=(y+ny)%ny;
00910                         int ynx = y2 * nx;
00911 
00912                         for (int x = 0; x < nx / 2; x++) {
00913 
00914                                 float s = (float)Util::hypot_fast(x,y ) * ds;
00915                                 float f = s/dsbg;
00916                                 int j = (int)floor(f);
00917                                 f-=j;
00918                                 if (j>(int)snr.size()-2) d[x*2+ynx]=snr.back();
00919                                 else d[x*2+ynx]=snr[j]*(1.0f-f)+snr[j+1]*f;
00920                                 d[x * 2 + ynx + 1] = 0;
00921                         }
00922                 }
00923                 d[0]=0;
00924         }
00925         else if (type == CTF_SNR_SMOOTH) {
00926                 for (int y = -ny/2; y < ny/2; y++) {
00927                         int y2=(y+ny)%ny;
00928                         int ynx = y2 * nx;
00929 
00930                         for (int x = 0; x < nx / 2; x++) {
00931 
00932                                 float s = (float)Util::hypot_fast(x,y ) * ds;
00933                                 float f = s/dsbg;
00934                                 int j = (int)floor(f);
00935                                 f-=j;
00936                                 if (j>(int)snr.size()-2) d[x*2+ynx]=snr.back();
00937                                 else d[x*2+ynx]=snr[j]*(1.0f-f)+snr[j+1]*f;
00938                                 d[x * 2 + ynx + 1] = 0;
00939                         }
00940                 }
00941                 d[0]=0;
00942         }
00943         else if (type == CTF_WIENER_FILTER) {
00944                 if (dsbg==0) printf("Warning, DSBG set to 0\n");
00945                 for (int y = -ny/2; y < ny/2; y++) {
00946                         int y2=(y+ny)%ny;
00947                         int ynx = y2 * nx;
00948 
00949                         for (int x = 0; x < nx / 2; x++) {
00950 
00951                                 float s = (float)Util::hypot_fast(x,y ) * ds;
00952                                 float f = s/dsbg;
00953                                 int j = (int)floor(f);
00954                                 float bg,snrf;
00955                                 f-=j;
00956                                 if (j>(int)snr.size()-2) {
00957 /*                                      bg=background.back();
00958                                         d[x*2+ynx]=snr.back()/(snr.back()+1.0);*/
00959                                         d[x*2+ynx]=0;
00960                                 }
00961                                 else {
00962                                         bg=background[j]*(1.0f-f)+background[j+1]*f;
00963                                         snrf=snr[j]*(1.0f-f)+snr[j+1]*f;
00964 
00965 //                                      printf("%d\t%f\n",x,sqrt(snrf/bg)/(snrf+1.0));
00966                                         if (snrf<0) snrf=0.0;
00967 //                                      d[x*2+ynx]=sqrt(snrf/bg)/(snrf+1.0);    // Note that this is a Wiener filter with a 1/CTF term to compensate for the filtration already applied, but needs to be multiplied by the structure factor
00968                                         d[x*2+ynx]=snrf/(snrf+1);       // This is just the simple Wiener filter
00969 
00970                                 }
00971                                 d[x * 2 + ynx + 1] = 0;
00972                         }
00973                 }
00974                 d[0]=0;
00975         }
00976         else if (type == CTF_TOTAL) {
00977                 float amp1 = calc_amp1();
00978 
00979                 for (int y = -ny/2; y < ny/2; y++) {
00980                         int y2=(y+ny)%ny;
00981                         int ynx = y2 * nx;
00982 
00983                         for (int x = 0; x < nx / 2; x++) {
00984 
00985                                 float s = (float)Util::hypot_fast(x,y ) * ds;
00986                                 float gamma = calc_gamma(g1, g2, s);
00987                                 float f = calc_ctf1(amp1, gamma, s);
00988                                 float noise = 0;
00989                                 f = f * f;
00990 
00991                                 if (sf && s) {
00992                                         f *= sf->get_yatx(s);
00993                                 }
00994                                 f+=noise;
00995 
00996                                 d[x * 2 + ynx] *= f;
00997                                 d[x * 2 + ynx + 1] = 0;
00998                         }
00999                 }
01000         }
01001         else printf("Unknown CTF image mode\n");
01002 
01003         image->update();
01004 }

void EMAN2Ctf::compute_2d_real EMData image,
CtfType  type,
XYData struct_factor = 0
[virtual]
 

Implements EMAN::Ctf.

Definition at line 829 of file ctf.cpp.

00830 {
00831 
00832 
00833 }

void EMAN2Ctf::copy_from const Ctf new_ctf  )  [virtual]
 

Implements EMAN::Ctf.

Definition at line 622 of file ctf.cpp.

References ampcont, EMAN::Ctf::apix, background, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, dfang, dfdiff, dsbg, snr, and EMAN::Ctf::voltage.

00623 {
00624         if (new_ctf) {
00625                 const EMAN2Ctf *c = static_cast<const EMAN2Ctf *>(new_ctf);
00626                 defocus = c->defocus;
00627                 dfdiff = c->dfdiff;
00628                 dfang = c->dfang;
00629                 bfactor = c->bfactor;
00630                 ampcont = c->ampcont;
00631                 voltage = c->voltage;
00632                 cs = c->cs;
00633                 apix = c->apix;
00634                 dsbg = c->dsbg;
00635                 background = c->background;
00636                 snr = c->snr;
00637         }
00638 }

bool EMAN2Ctf::equal const Ctf ctf1  )  const [virtual]
 

Implements EMAN::Ctf.

Definition at line 1008 of file ctf.cpp.

References ampcont, EMAN::Ctf::apix, background, EMAN::Ctf::bfactor, EMAN::Ctf::cs, EMAN::Ctf::defocus, dfang, dfdiff, dsbg, snr, and EMAN::Ctf::voltage.

01009 {
01010         if (ctf1) {
01011                 const EMAN2Ctf *c = static_cast<const EMAN2Ctf *>(ctf1);
01012                 if (defocus != c->defocus ||
01013                         dfdiff != c->dfdiff ||
01014                         dfang != c->dfang ||
01015                         bfactor != c->bfactor ||
01016                         ampcont != c->ampcont ||
01017                         voltage != c->voltage ||
01018                         cs != c->cs ||
01019                         apix != c->apix ||
01020                         dsbg != c->dsbg ||
01021                         background.size() != c->background.size() ||
01022                         snr.size() != c->snr.size()
01023                         ) return false;
01024 
01025                 for (unsigned int i=0; i<background.size(); i++) {
01026                         if (background[i]!=c->background[i]) return false;
01027                 }
01028                 for (unsigned int i=0; i<snr.size(); i++) {
01029                         if (snr[i]!=c->snr[i]) return false;
01030                 }
01031                 return true;
01032         }
01033         return false;
01034 }

void EMAN2Ctf::from_dict const Dict dict  )  [virtual]
 

Implements EMAN::Ctf.

Definition at line 548 of file ctf.cpp.

References ampcont, background, dfang, dfdiff, dsbg, and snr.

00549 {
00550         defocus = (float)dict["defocus"];
00551         dfdiff = (float)dict["dfdiff"];
00552         dfang = (float)dict["dfang"];
00553         bfactor = (float)dict["bfactor"];
00554         ampcont = (float)dict["ampcont"];
00555         voltage = (float)dict["voltage"];
00556         cs = (float)dict["cs"];
00557         apix = (float)dict["apix"];
00558         dsbg = (float)dict["dsbg"];
00559         background = dict["background"];
00560         snr = dict["snr"];
00561 }

int EMAN2Ctf::from_string const string &  ctf  )  [virtual]
 

Implements EMAN::Ctf.

Definition at line 491 of file ctf.cpp.

References ampcont, Assert, background, dfang, dfdiff, dsbg, InvalidValueException, snr, and v.

00492 {
00493         Assert(ctf != "");
00494         char type=' ';
00495         int pos,i,j;
00496         int bglen=0,snrlen=0;
00497         float v;
00498         const char *s=ctf.c_str();
00499 
00500         sscanf(s, "%c%f %f %f %f %f %f %f %f %f %d%n",
00501                                    &type,&defocus, &dfdiff,&dfang,&bfactor,&ampcont,&voltage, &cs, &apix,&dsbg,&bglen,&pos);
00502         if (type!='E') throw InvalidValueException(type,"Trying to initialize Ctf object with bad string");
00503 
00504 
00505         background.resize(bglen);
00506         for (i=0; i<bglen; i++) {
00507                 if (sscanf(s+pos,",%f%n",&v,&j)<1) return(1);
00508                 background[i]=v;
00509                 pos+=j;
00510         }
00511 
00512         sscanf(s+pos," %d%n",&snrlen,&j);
00513         pos+=j;
00514         snr.resize(snrlen);
00515         for (i=0; i<snrlen; i++) {
00516                 if (sscanf(s+pos,",%f%n",&v,&j)<1) return(1);
00517                 snr[i]=v;
00518                 pos+=j;
00519         }
00520 
00521         return 0;
00522 
00523 }

void EMAN2Ctf::from_vector const vector< float > &  vctf  )  [virtual]
 

Implements EMAN::Ctf.

Definition at line 581 of file ctf.cpp.

References ampcont, background, dfang, dfdiff, dsbg, and snr.

00582 {
00583         int i;
00584         defocus = vctf[0];
00585         dfdiff = vctf[1];
00586         dfang = vctf[2];
00587         bfactor = vctf[3];
00588         ampcont = vctf[4];
00589         voltage = vctf[5];
00590         cs = vctf[6];
00591         apix = vctf[7];
00592         dsbg = vctf[8];
00593         background.resize((int)vctf[9]);
00594         for (i=0; i<(int)vctf[9]; i++) background[i]=vctf[i+10];
00595         snr.resize((int)vctf[i+10]);
00596         for (int j=0; j<(int)vctf[i+10]; j++) snr[j]=vctf[i+j+11];
00597 }

vector<float> EMAN::EMAN2Ctf::get_background  )  [inline]
 

Definition at line 239 of file ctf.h.

00239 { return background;}

vector<float> EMAN::EMAN2Ctf::get_snr  )  [inline]
 

Definition at line 237 of file ctf.h.

00237 { return snr;}

void EMAN::EMAN2Ctf::set_background const vector< float > &  vf  )  [inline]
 

Definition at line 240 of file ctf.h.

00240 {background = vf;}

void EMAN::EMAN2Ctf::set_snr const vector< float > &  vf  )  [inline]
 

Definition at line 238 of file ctf.h.

00238 {snr = vf;}

Dict EMAN2Ctf::to_dict  )  const [virtual]
 

Implements EMAN::Ctf.

Definition at line 563 of file ctf.cpp.

00564 {
00565         Dict dict;
00566         dict["defocus"] = defocus;
00567         dict["dfdiff"] = dfdiff;
00568         dict["dfang"] = dfang;
00569         dict["bfactor"] = bfactor;
00570         dict["ampcont"] = ampcont;
00571         dict["voltage"] = voltage;
00572         dict["cs"] = cs;
00573         dict["apix"] = apix;
00574         dict["dsbg"] = dsbg;
00575         dict["background"] = background;
00576         dict["snr"] = snr;
00577 
00578         return dict;
00579 }

string EMAN2Ctf::to_string  )  const [virtual]
 

Implements EMAN::Ctf.

Definition at line 525 of file ctf.cpp.

References ampcont, background, dfang, dfdiff, dsbg, and snr.

00526 {
00527         char ctf[256];
00528         sprintf(ctf, "E%1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %1.4g %d",
00529                         defocus, dfdiff, dfang, bfactor, ampcont, voltage, cs, apix, dsbg,(int)background.size());
00530 
00531         string ret=ctf;
00532         for (int i=0; i<(int)background.size(); i++) {
00533                 sprintf(ctf,",%1.3g",background[i]);
00534                 ret+=ctf;
00535         }
00536 
00537         sprintf(ctf, " %d",(int)snr.size());
00538         ret+=ctf;
00539         for (int i=0; i<(int)snr.size(); i++) {
00540                 sprintf(ctf,",%1.3g",snr[i]);
00541                 ret+=ctf;
00542         }
00543 
00544 
00545         return ret;
00546 }

vector< float > EMAN2Ctf::to_vector  )  const [virtual]
 

Implements EMAN::Ctf.

Definition at line 599 of file ctf.cpp.

References ampcont, background, dfang, dfdiff, dsbg, and snr.

00600 {
00601         vector<float> vctf;
00602 
00603         vctf.push_back(defocus);
00604         vctf.push_back(dfdiff);
00605         vctf.push_back(dfang);
00606         vctf.push_back(bfactor);
00607         vctf.push_back(ampcont);
00608         vctf.push_back(voltage);
00609         vctf.push_back(cs);
00610         vctf.push_back(apix);
00611         vctf.push_back(dsbg);
00612         vctf.push_back((float)background.size());
00613         for (unsigned int i=0; i<background.size(); i++) vctf.push_back(background[i]);
00614         vctf.push_back((float)snr.size());
00615         for (unsigned int j=0; j<snr.size(); j++) vctf.push_back(snr[j]);
00616 
00617         return vctf;
00618 }


Member Data Documentation

float EMAN::EMAN2Ctf::ampcont
 

Definition at line 229 of file ctf.h.

Referenced by copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector().

vector<float> EMAN::EMAN2Ctf::background
 

Definition at line 234 of file ctf.h.

Referenced by compute_1d(), compute_2d_complex(), copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector().

float EMAN::EMAN2Ctf::dfang
 

Definition at line 227 of file ctf.h.

Referenced by copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector().

float EMAN::EMAN2Ctf::dfdiff
 

Definition at line 226 of file ctf.h.

Referenced by copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector().

float EMAN::EMAN2Ctf::dsbg
 

Definition at line 233 of file ctf.h.

Referenced by compute_2d_complex(), copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector().

vector<float> EMAN::EMAN2Ctf::snr
 

Definition at line 235 of file ctf.h.

Referenced by compute_1d(), compute_2d_complex(), copy_from(), EMAN2Ctf(), equal(), from_dict(), from_string(), from_vector(), to_string(), and to_vector().


The documentation for this class was generated from the following files:
Generated on Thu Dec 9 13:47:20 2010 for EMAN2 by  doxygen 1.3.9.1