ctf.cpp File Reference

#include "ctf.h"
#include "core/multidim_array.h"
#include "core/xmipp_fftw.h"
#include "core/xmipp_image.h"
#include "core/xmipp_program.h"
#include "core/metadata_vec.h"

Include dependency graph for ctf.cpp:

Go to the source code of this file.

Macros
#define	DEBUG

Functions
bool	containsCTFBasicLabels (const MetaData &md)
void	groupCTFMetaData (const MetaDataDb &imgMd, MetaDataDb &ctfMd, std::vector< MDLabel > &groupbyLabels)
void	generateCTFImageWith2CTFs (const MetaData &MD1, const MetaData &MD2, int Xdim, MultidimArray< double > &imgOut)
double	errorBetween2CTFs (MetaData &MD1, MetaData &MD2, size_t Xdim, double minFreq, double maxFreq)
double	errorMaxFreqCTFs (MetaData &MD1, double phaseRad)
double	errorMaxFreqCTFs2D (MetaData &MD1, MetaData &MD2, size_t Xdim, double phaseRad)
void	generatePSDCTFImage (MultidimArray< double > &img, const MetaData &MD)
std::ostream &	operator<< (std::ostream &out, const CTFDescription1D &ctf)
std::ostream &	operator<< (std::ostream &out, const CTFDescription &ctf)

Macro Definition Documentation

DEBUG

#define DEBUG

Function Documentation

containsCTFBasicLabels()

bool containsCTFBasicLabels

(

const MetaData &

md

)

Check that a metadata contains ALL CTF_BASIC_LABELS labels

Definition at line 33 of file ctf.cpp.

{
    for(int i=0; i < CTF_BASIC_LABELS_SIZE; i++)
        if (!md.containsLabel(CTF_BASIC_LABELS[i]))
            return false;
    return true;
}

groupCTFMetaData()

void groupCTFMetaData	(	const MetaDataDb &	imgMd,
		MetaDataDb &	ctfMd,
		std::vector< MDLabel > &	groupbyLabels
	)

From a give images metadata, group by CTF_BASIC_LABELS and fill a ctfs metadata. Params: imgMd: input images metadata. ctfMd: the ctfs metadata that will be filled.

Raise error if neither CTF_MODEL or ALL CTF_BASIC_LABELS are found in input images metadata.

Definition at line 41 of file ctf.cpp.

{
  //number of different CTFs
  if (imgMd.containsLabel(MDL_CTF_MODEL))
  {
      ctfMd.aggregate(imgMd, AGGR_COUNT, MDL_CTF_MODEL, MDL_CTF_MODEL, MDL_COUNT);
      ctfMd.fillExpand(MDL_CTF_MODEL);
  }
  else if (containsCTFBasicLabels(imgMd))
  {
      groupbyLabels.clear();
      for(int i=0; i < CTF_ALL_LABELS_SIZE; i++)
          if (imgMd.containsLabel(CTF_ALL_LABELS[i]))
              groupbyLabels.push_back(CTF_ALL_LABELS[i]);
      if (imgMd.containsLabel(MDL_MICROGRAPH_ID))
          groupbyLabels.push_back(MDL_MICROGRAPH_ID);
      else
          REPORT_ERROR(ERR_MD_MISSINGLABEL,"ERROR: Input metadata does not have micrographId");
      ctfMd.aggregateGroupBy(imgMd, AGGR_COUNT, groupbyLabels, MDL_CTF_DEFOCUSU, MDL_COUNT);
  }
  else
      REPORT_ERROR(ERR_MD_MISSINGLABEL,"Expecting CTF_MODEL or (MDL_CTF_DEFOCUSU, MDL_CTF_DEFOCUSV, MDL_CTF_DEFOCUS_ANGLE) labels");

}

operator<<() [1/2]

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

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
	)

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;
}