ProgPdbConverter Class Reference

#include <volume_from_pdb.h>

Inheritance diagram for ProgPdbConverter:

Collaboration diagram for ProgPdbConverter:

Public Member Functions
	ProgPdbConverter ()
void	defineParams ()
void	readParams ()
void	produceSideInfo ()
void	show ()
void	run ()
void	blobProperties () const
void	atomBlobDescription (const std::string &_element, double &weight, double &radius) const
void	computeProteinGeometry ()
void	createProteinAtHighSamplingRate ()
void	createProteinAtLowSamplingRate ()
void	createProteinUsingScatteringProfiles ()
Public Member Functions inherited from XmippProgram
const char *	getParam (const char *param, int arg=0)
const char *	getParam (const char *param, const char *subparam, int arg=0)
int	getIntParam (const char *param, int arg=0)
int	getIntParam (const char *param, const char *subparam, int arg=0)
double	getDoubleParam (const char *param, int arg=0)
double	getDoubleParam (const char *param, const char *subparam, int arg=0)
float	getFloatParam (const char *param, int arg=0)
float	getFloatParam (const char *param, const char *subparam, int arg=0)
void	getListParam (const char *param, StringVector &list)
int	getCountParam (const char *param)
bool	checkParam (const char *param)
bool	existsParam (const char *param)
void	addParamsLine (const String &line)
void	addParamsLine (const char *line)
ParamDef *	getParamDef (const char *param) const
virtual void	quit (int exit_code=0) const
virtual int	tryRun ()
void	initProgress (size_t total, size_t stepBin=60)
void	setProgress (size_t value=0)
void	endProgress ()
void	processDefaultComment (const char *param, const char *left)
void	setDefaultComment (const char *param, const char *comment)
virtual void	initComments ()
void	setProgramName (const char *name)
void	addUsageLine (const char *line, bool verbatim=false)
void	clearUsage ()
void	addExampleLine (const char *example, bool verbatim=true)
void	addSeeAlsoLine (const char *seeAlso)
void	addKeywords (const char *keywords)
const char *	name () const
virtual void	usage (int verb=0) const
virtual void	usage (const String &param, int verb=2)
int	version () const
virtual void	show () const
virtual void	read (int argc, const char **argv, bool reportErrors=true)
virtual void	read (int argc, char **argv, bool reportErrors=true)
void	read (const String &argumentsLine)
	XmippProgram ()
	XmippProgram (int argc, const char **argv)
virtual	~XmippProgram ()

Public Attributes
double	Ts
FileName	fn_pdb
FileName	fn_out
FileName	fn_outPDB
struct blobtype	blob
int	output_dim_x
int	output_dim_y
int	output_dim_z
int	orig_x
int	orig_y
int	orig_z
bool	origGiven
bool	useBlobs
bool	usePoorGaussian
bool	useFixedGaussian
bool	doCenter
bool	noHet
double	sigmaGaussian
std::string	intensityColumn
	Column for the intensity (if any). Only valid for fixed_gaussians. More...
int	M
double	highTs
Matrix2D< double >	periodicTable
AtomInterpolator	atomProfiles
Matrix1D< double >	centerOfMass
Matrix1D< double >	limit
Image< double >	Vhigh
Image< double >	Vlow
Public Attributes inherited from XmippProgram
bool	doRun
bool	runWithoutArgs
int	verbose
	Verbosity level. More...
int	debug

Additional Inherited Members
Protected Member Functions inherited from XmippProgram
void	defineCommons ()
Protected Attributes inherited from XmippProgram
int	errorCode
ProgramDef *	progDef
	Program definition and arguments parser. More...
std::map< String, CommentList >	defaultComments
int	argc
	Original command line arguments. More...
const char **	argv

Detailed Description

Parameter class for the PDB Phantom program

Definition at line 37 of file volume_from_pdb.h.

Constructor & Destructor Documentation

ProgPdbConverter()

ProgPdbConverter::ProgPdbConverter

(

)

Empty constructor

Definition at line 35 of file volume_from_pdb.cpp.

{
    blob.radius = 2;   // Blob radius in voxels
    blob.order  = 2;   // Order of the Bessel function
    blob.alpha  = 3.6; // Smoothness parameter
    output_dim_x = -1;
    output_dim_y = -1;
    output_dim_z = -1;

    fn_pdb = "";
    Ts = 1;
    highTs = 1.0/12.0;
    useBlobs=false;
    usePoorGaussian=false;
    useFixedGaussian=false;
    doCenter=false;
    noHet=false;

    // Periodic table for the blobs
    periodicTable.resize(12, 2);
    periodicTable(0, 0) = atomRadius("H");
    periodicTable(0, 1) = atomCharge("H");
    periodicTable(1, 0) = atomRadius("C");
    periodicTable(1, 1) = atomCharge("C");
    periodicTable(2, 0) = atomRadius("N");
    periodicTable(2, 1) = atomCharge("N");
    periodicTable(3, 0) = atomRadius("O");
    periodicTable(3, 1) = atomCharge("O");
    periodicTable(4, 0) = atomRadius("P");
    periodicTable(4, 1) = atomCharge("P");
    periodicTable(5, 0) = atomRadius("S");
    periodicTable(5, 1) = atomCharge("S");
    periodicTable(6, 0) = atomRadius("Fe");
    periodicTable(6, 1) = atomCharge("Fe");
    periodicTable(7, 0) = atomRadius("K");
    periodicTable(7, 1) = atomCharge("K");
    periodicTable(8, 0) = atomRadius("F");
    periodicTable(8, 1) = atomCharge("F");
    periodicTable(9, 0) = atomRadius("Mg");
    periodicTable(9, 1) = atomCharge("Mg");
    periodicTable(10, 0) = atomRadius("Cl");
    periodicTable(10, 1) = atomCharge("Cl");
    periodicTable(11, 0) = atomRadius("Ca");
    periodicTable(11, 1) = atomCharge("Ca");

    // Correct the atom weights by the blob weight
    for (size_t i = 0; i < MAT_YSIZE(periodicTable); i++)
    {
        periodicTable(i, 1) /=
            basvolume(periodicTable(i, 0) / highTs, blob.alpha, blob.order, 3);
    }
}

Member Function Documentation

atomBlobDescription()

void ProgPdbConverter::atomBlobDescription	(	const std::string &	_element,
		double &	weight,
		double &	radius
	)		const

Definition at line 129 of file volume_from_pdb.cpp.

{
    int idx = -1;
    weight = radius = 0;
    switch (_element[0])
    {
    case 'H':
        idx = 0;
        break;
    case 'C':
        idx = 1;
        break;
    case 'N':
        idx = 2;
        break;
    case 'O':
        idx = 3;
        break;
    case 'P':
        idx = 4;
        break;
    case 'S':
        idx = 5;
        break;
    case 'E': //iron Fe
        idx = 6;
        break;
    case 'K':
        idx = 7;
        break;
    case 'F':
        idx = 8;
        break;
    case 'G': // Magnesium Mg
        idx = 9;
        break;
    case 'L': // Chlorine Cl
        idx = 10;
        break;
    case 'A': // Calcium Ca
        idx = 11;
        break;
    default:
        if (verbose>0)
            std::cout << "Unknown :" << _element << std::endl;
        return;
    }
    radius = periodicTable(idx, 0);
    weight = periodicTable(idx, 1);
}

blobProperties()

void ProgPdbConverter::blobProperties

(

)

const

Definition at line 437 of file volume_from_pdb.cpp.

{
    std::ofstream fh_out;
    fh_out.open((fn_out + "_Fourier_profile.txt").c_str());
    if (!fh_out)
        REPORT_ERROR(ERR_IO_NOWRITE, fn_out);
    fh_out << "# Freq(1/A) 10*log10(|Blob(f)|^2) Ts=" << highTs << std::endl;
    

    for(double w=0; w < 1.0 / (2*highTs); w += 1.0 / (highTs * 500))
    {
        double H = kaiser_Fourier_value(w * highTs, periodicTable(0, 0) / highTs,
                                        blob.alpha, blob.order);
        fh_out << w << " " << 10*log10(H*H) << std::endl;
    }
    fh_out.close();
}

computeProteinGeometry()

void ProgPdbConverter::computeProteinGeometry

(

)

Definition at line 261 of file volume_from_pdb.cpp.

{
    Matrix1D<double> limit0(3), limitF(3);
    computePDBgeometry(fn_pdb, centerOfMass, limit0, limitF, intensityColumn);
    if (doCenter)
    {
        limit0-=centerOfMass;
        limitF-=centerOfMass;
    }
    limit.resize(3);
    XX(limit) = XMIPP_MAX(ABS(XX(limit0)), ABS(XX(limitF)));
    YY(limit) = XMIPP_MAX(ABS(YY(limit0)), ABS(YY(limitF)));
    ZZ(limit) = XMIPP_MAX(ABS(ZZ(limit0)), ABS(ZZ(limitF)));

    // Update output size if necessary
    if (output_dim_x == -1)
    {
        int max_dim = XMIPP_MAX(CEIL(ZZ(limit) * 2 / Ts) + 5, CEIL(YY(limit) * 2 / Ts) + 5);
        max_dim = XMIPP_MAX(max_dim, CEIL(XX(limit) * 2 / Ts) + 5);
        if (useBlobs)
        {
            output_dim_x = (int)NEXT_POWER_OF_2(max_dim);
            output_dim_y = output_dim_x;
            output_dim_z = output_dim_x;
        }
        else
        {
            output_dim_x = max_dim+10;
            output_dim_y = output_dim_x;
            output_dim_z = output_dim_x;
        }
    }
    else
    {
        if (output_dim_y == -1)
        {
            output_dim_y = output_dim_x;
            output_dim_z = output_dim_x;
        }
    }
}

createProteinAtHighSamplingRate()

void ProgPdbConverter::createProteinAtHighSamplingRate

(

)

Definition at line 304 of file volume_from_pdb.cpp.

{
    // Create an empty volume to hold the protein
    int finalDim_x, finalDim_y, finalDim_z;
    if (highTs!=Ts)
    {
        finalDim_x=(int)NEXT_POWER_OF_2(output_dim_x / (highTs/Ts));
        finalDim_y=(int)NEXT_POWER_OF_2(output_dim_y / (highTs/Ts));
        finalDim_z=(int)NEXT_POWER_OF_2(output_dim_z / (highTs/Ts));
    }
    else
    {
        finalDim_x=output_dim_x;
        finalDim_y=output_dim_y;
        finalDim_z=output_dim_z;
    }
    Vhigh().initZeros(finalDim_x,finalDim_y,finalDim_z);
    if (!origGiven)
        Vhigh().setXmippOrigin();
    else
    {
        STARTINGX(Vhigh()) = orig_x;
        STARTINGY(Vhigh()) = orig_y;
        STARTINGZ(Vhigh()) = orig_z;
    }
    if (verbose)
        std::cout << "The highly sampled volume is of size " << XSIZE(Vhigh())
        << std::endl;
    std::cout << "Size: "; Vhigh().printShape(); std::cout << std::endl;

    // Declare centered PDB
    PDBRichPhantom centered_pdb;

    // Read centered pdb
    centered_pdb.read(fn_pdb.c_str());

    Matrix1D<double> r(3);
    bool useBFactor = intensityColumn=="Bfactor";
    // Iterate the list of atoms modifying data if needed
    for (auto& atom : centered_pdb.atomList) {
        if (doCenter) {
            atom.x -= XX(centerOfMass);
            atom.y -= YY(centerOfMass);
            atom.z -= ZZ(centerOfMass);
        }
        VECTOR_R3(r, atom.x, atom.y, atom.z);
        r /= highTs;

        // Characterize atom
        double weight, radius;
        if (!useFixedGaussian)
        {
            if (noHet && atom.record == "HETATM")
                continue;
            atomBlobDescription(atom.atomType, weight, radius);
        }
        else
        {
            radius=4.5*sigmaGaussian;
            if (useBFactor)
                weight=atom.bfactor;
            else
                weight=atom.occupancy;
        }
        blob.radius = radius;
        if (usePoorGaussian)
            radius=XMIPP_MAX(radius/Ts,4.5);
        double GaussianSigma2=(radius/(3*sqrt(2.0)));
        if (useFixedGaussian)
            GaussianSigma2=sigmaGaussian;
        GaussianSigma2*=GaussianSigma2;
        double GaussianNormalization = 1.0/pow(2*PI*GaussianSigma2,1.5);

        // Find the part of the volume that must be updated
        int k0 = XMIPP_MAX(FLOOR(ZZ(r) - radius), STARTINGZ(Vhigh()));
        int kF = XMIPP_MIN(CEIL(ZZ(r) + radius), FINISHINGZ(Vhigh()));
        int i0 = XMIPP_MAX(FLOOR(YY(r) - radius), STARTINGY(Vhigh()));
        int iF = XMIPP_MIN(CEIL(YY(r) + radius), FINISHINGY(Vhigh()));
        int j0 = XMIPP_MAX(FLOOR(XX(r) - radius), STARTINGX(Vhigh()));
        int jF = XMIPP_MIN(CEIL(XX(r) + radius), FINISHINGX(Vhigh()));

        // Fill the volume with this atom
        Matrix1D<double> rdiff(3);
        for (int k = k0; k <= kF; k++)
            for (int i = i0; i <= iF; i++)
                for (int j = j0; j <= jF; j++)
                {
                    VECTOR_R3(rdiff, XX(r) - j, YY(r) - i, ZZ(r) - k);
                    rdiff*=highTs;
                    if (useBlobs)
                        Vhigh(k, i, j) += weight * blob_val(rdiff.module(), blob);
                    else if (usePoorGaussian || useFixedGaussian)
                        Vhigh(k, i, j) += weight *
                                          exp(-rdiff.module()*rdiff.module()/(2*GaussianSigma2))*
                                          GaussianNormalization;
                }
    }
    
    // Save centered PDB
    if (doCenter && !fn_outPDB.empty())
    {
        centered_pdb.write(fn_outPDB);
    }
}

createProteinAtLowSamplingRate()

void ProgPdbConverter::createProteinAtLowSamplingRate

(

)

Definition at line 410 of file volume_from_pdb.cpp.

{
    // Compute the integer downsapling factor
    int M = FLOOR(Ts / highTs);
    double current_Ts = highTs;

    // Use Bsplines pyramid if possible
    int levels = FLOOR(log10((double)M) / log10(2.0) + XMIPP_EQUAL_ACCURACY);
    pyramidReduce(xmipp_transformation::BSPLINE3, Vlow(), Vhigh(), levels);
    current_Ts *= pow(2.0, levels);
    Vhigh.clear();

    // Now scale using Bsplines
    int new_output_dim = CEIL(XSIZE(Vlow()) * current_Ts / Ts);
    scaleToSize(xmipp_transformation::BSPLINE3, Vhigh(), Vlow(),
                new_output_dim, new_output_dim, new_output_dim);
    Vlow() = Vhigh();
    if (!origGiven)
        Vlow().setXmippOrigin();

    // Return to the desired size
    Vlow().selfWindow(FIRST_XMIPP_INDEX(output_dim_x), FIRST_XMIPP_INDEX(output_dim_y),
                  FIRST_XMIPP_INDEX(output_dim_z), LAST_XMIPP_INDEX(output_dim_x),
                  LAST_XMIPP_INDEX(output_dim_y), LAST_XMIPP_INDEX(output_dim_z));
}

createProteinUsingScatteringProfiles()

void ProgPdbConverter::createProteinUsingScatteringProfiles

(

)

Definition at line 456 of file volume_from_pdb.cpp.

{
    // Create an empty volume to hold the protein
    Vlow().initZeros(output_dim_x,output_dim_y,output_dim_z);
    if (!origGiven) {
        Vlow().setXmippOrigin();
    }
    else
    {
        STARTINGX(Vlow()) = orig_x;
        STARTINGY(Vlow()) = orig_y;
        STARTINGZ(Vlow()) = orig_z;
    }

    //Save centered PDB
    PDBRichPhantom centered_pdb;

    // Read centered pdb
    centered_pdb.read(fn_pdb.c_str());

    Matrix1D<double> r(3);
    bool useBFactor = intensityColumn=="Bfactor";
    // Iterate the list of atoms modifying data if needed
    for (auto& atom : centered_pdb.atomList) {
        // Check if heteroatoms are allowed and current atom is one of them
        if (noHet && atom.record == "HETATM")
            continue;

        if (doCenter) {
            atom.x -= XX(centerOfMass);
            atom.y -= YY(centerOfMass);
            atom.z -= ZZ(centerOfMass);
        }
        VECTOR_R3(r, atom.x, atom.y, atom.z);
        r /= Ts;

        // Characterize atom
        try
        {
            double radius=atomProfiles.atomRadius(atom.atomType[0]);
            double radius2=radius*radius;

            // Find the part of the volume that must be updated
            const MultidimArray<double> &mVlow=Vlow();
            int k0 = XMIPP_MAX(FLOOR(ZZ(r) - radius), STARTINGZ(mVlow));
            int kF = XMIPP_MIN(CEIL(ZZ(r) + radius), FINISHINGZ(mVlow));
            int i0 = XMIPP_MAX(FLOOR(YY(r) - radius), STARTINGY(mVlow));
            int iF = XMIPP_MIN(CEIL(YY(r) + radius), FINISHINGY(mVlow));
            int j0 = XMIPP_MAX(FLOOR(XX(r) - radius), STARTINGX(mVlow));
            int jF = XMIPP_MIN(CEIL(XX(r) + radius), FINISHINGX(mVlow));

            // Fill the volume with this atom
            for (int k = k0; k <= kF; k++)
            {
                double zdiff=ZZ(r) - k;
                double zdiff2=zdiff*zdiff;
                for (int i = i0; i <= iF; i++)
                {
                    double ydiff=YY(r) - i;
                    double zydiff2=zdiff2+ydiff*ydiff;
                    for (int j = j0; j <= jF; j++)
                    {
                        double xdiff=XX(r) - j;
                        double rdiffModule2=zydiff2+xdiff*xdiff;
                        if (rdiffModule2<radius2)
                        {
                            double rdiffModule=sqrt(rdiffModule2);
                            A3D_ELEM(mVlow,k, i, j) += atomProfiles.volumeAtDistance(
                                                 atom.atomType[0],rdiffModule);
                        }
                    }
                }
            }
        }
        catch (XmippError XE)
        {
            if (verbose)
                std::cerr << "Ignoring atom of type *" << atom.atomType << "*" << std::endl;
        }
    }

    // Save centered PDB
    if (doCenter && !fn_outPDB.empty())
    {
        centered_pdb.write(fn_outPDB);
    }
}

defineParams()

void ProgPdbConverter::defineParams ( )

virtual

Params definitions

Reimplemented from XmippProgram.

Definition at line 181 of file volume_from_pdb.cpp.

{
    addUsageLine("Covert a PDB file to a volume.");
    addExampleLine("Sample at 1.6A and limit the frequency to 10A",false);
    addExampleLine("   xmipp_volume_from_pdb -i 1o7d.pdb --sampling 1.6");
    addExampleLine("   xmipp_transform_filter -i 1o7d.vol -o 1o7dFiltered.vol --fourier low_pass 10 raised_cosine 0.05 --sampling 1.6");

    addParamsLine("   -i <pdb_file>                     : File to process");
    addParamsLine("  [-o <fn_root>]                     : Root name for output");
    addParamsLine("  [--sampling <Ts=1>]                : Sampling rate (Angstroms/pixel)");
    addParamsLine("  [--high_sampling_rate <highTs=0.08333333>]: Sampling rate before downsampling");
    addParamsLine("  [--size <output_dim_x=-1> <output_dim_y=-1> <output_dim_z=-1>]: Final size in pixels (must be a power of 2, if blobs are used)");
    addParamsLine("  [--orig <orig_x=0> <orig_y=0> <orig_z=0>]: Define origin of the output volume");
    addParamsLine("                                      : If just one dimension is introduced dim_x = dim_y = dim_z");
    addParamsLine("  [--centerPDB]                       : Center PDB with the center of mass");
    addParamsLine("  [--oPDB]                            : Save centered PDB");
    addParamsLine("  [--noHet]                           : Heteroatoms are not converted");
    addParamsLine("  [--blobs]                           : Use blobs instead of scattering factors");
    addParamsLine("  [--poor_Gaussian]                   : Use a simple Gaussian adapted to each atom");
    addParamsLine("  [--fixed_Gaussian <std=-1>]         : Use a fixed Gausian for each atom with");
    addParamsLine("                                     :  this standard deviation");
    addParamsLine("                                     :  If not given, the standard deviation is taken from the PDB file");
    addParamsLine("  [--intensityColumn <intensity_type=occupancy>]   : Where to write the intensity in the PDB file");
    addParamsLine("     where <intensity_type> occupancy Bfactor     : Valid values: occupancy, Bfactor");
}

produceSideInfo()

void ProgPdbConverter::produceSideInfo

(

)

Produce side information. Produce the atomic profiles.

Definition at line 89 of file volume_from_pdb.cpp.

{
    if (useFixedGaussian && sigmaGaussian<0)
    {
        // Check if it is a pseudodensity volume
        std::ifstream fh_pdb;
        fh_pdb.open(fn_pdb.c_str());
        if (!fh_pdb)
            REPORT_ERROR(ERR_IO_NOTEXIST, fn_pdb);
        while (!fh_pdb.eof())
        {
            // Read an ATOM line
            std::string line;
            getline(fh_pdb, line);
            if (line == "")
                continue;
            std::string kind = line.substr(0,6);
            if (kind!="REMARK")
                continue;
            std::vector< std::string > results;
            splitString(line," ",results);
            if (useFixedGaussian && results[1]=="fixedGaussian")
                sigmaGaussian=textToFloat(results[2]);
            if (useFixedGaussian && results[1]=="intensityColumn")
                intensityColumn=results[2];
        }
        fh_pdb.close();
    }

    if (!useBlobs && !usePoorGaussian && !useFixedGaussian)
    {
        // Compute the downsampling factor
        M=(int)ROUND(Ts/highTs);

        // Atom profiles for the electron scattering method
        atomProfiles.setup(M,highTs,false);
    }
}

readParams()

void ProgPdbConverter::readParams ( )

virtual

Read from a command line. An exception might be thrown by any of the internal conversions, this would mean that there is an error in the command line and you might show a usage message.

Reimplemented from XmippProgram.

Definition at line 207 of file volume_from_pdb.cpp.

{
    fn_pdb = getParam("-i");
    fn_out = checkParam("-o") ? getParam("-o") : fn_pdb.withoutExtension();
    Ts = getDoubleParam("--sampling");
    highTs = getDoubleParam("--high_sampling_rate");
    output_dim_x = getIntParam("--size", 0);
    output_dim_y = getIntParam("--size", 1);
    output_dim_z = getIntParam("--size", 2);
    if (checkParam("--orig"))
    {
        orig_x = getIntParam("--orig", 0);
        orig_y = getIntParam("--orig", 1);
        orig_z = getIntParam("--orig", 2);
        origGiven=true;
    }
    else
    {
        origGiven=false;
        orig_x=orig_y=orig_z=0;
    }
    useBlobs = checkParam("--blobs");
    usePoorGaussian = checkParam("--poor_Gaussian");
    useFixedGaussian = checkParam("--fixed_Gaussian");
    if (useFixedGaussian)
        sigmaGaussian = getDoubleParam("--fixed_Gaussian");
    doCenter = checkParam("--centerPDB");
    fn_outPDB = checkParam("--oPDB") ? (fn_out + "_centered.pdb") : FileName();
    noHet = checkParam("--noHet");
    intensityColumn = getParam("--intensityColumn");
}

run()

void ProgPdbConverter::run ( )

virtual

Run.

Reimplemented from XmippProgram.

Definition at line 545 of file volume_from_pdb.cpp.

{
    produceSideInfo();
    show();
    computeProteinGeometry();
    if (useBlobs)
    {
        createProteinAtHighSamplingRate();
        createProteinAtLowSamplingRate();
        blobProperties();
    }
    else if (usePoorGaussian || useFixedGaussian)
    {
        highTs=Ts;
        createProteinAtHighSamplingRate();
        Vlow=Vhigh;
        Vhigh.clear();
    }
    else
    {
        createProteinUsingScatteringProfiles();
    }
    if (Vlow().sum()<0)
        REPORT_ERROR(ERR_NUMERICAL,"The output volume has a negative average. This could be caused by a too large voxel size.");
    if (fn_out!="")
        Vlow.write(fn_out + ".vol");
}

show()

void ProgPdbConverter::show

(

)

Show parameters.

Definition at line 240 of file volume_from_pdb.cpp.

{
    if (verbose==0)
        return;
    std::cout << "PDB file:           " << fn_pdb           << std::endl
    << "Sampling rate:      " << Ts               << std::endl
    << "High sampling rate: " << highTs           << std::endl
    << "Size:               " << output_dim_x << " " << output_dim_y << " " << output_dim_z << std::endl
    << "Origin:             " << orig_x << " " << orig_y << " " << orig_z << std::endl
    << "Center PDB:         " << doCenter         << std::endl
    << "Do not Hetatm:      " << noHet         << std::endl
    << "Use blobs:          " << useBlobs         << std::endl
    << "Use poor Gaussian:  " << usePoorGaussian  << std::endl
    << "Use fixed Gaussian: " << useFixedGaussian << std::endl
    ;
    if (useFixedGaussian)
        std::cout << "Intensity Col:      " << intensityColumn  << std::endl
        << "Sigma:              " << sigmaGaussian  << std::endl;
}

Member Data Documentation

atomProfiles

AtomInterpolator ProgPdbConverter::atomProfiles

Definition at line 114 of file volume_from_pdb.h.

blob

struct blobtype ProgPdbConverter::blob

Blob

Definition at line 53 of file volume_from_pdb.h.

centerOfMass

Matrix1D<double> ProgPdbConverter::centerOfMass

Definition at line 117 of file volume_from_pdb.h.

doCenter

bool ProgPdbConverter::doCenter

Center the PDB

Definition at line 71 of file volume_from_pdb.h.

fn_out

FileName ProgPdbConverter::fn_out

Output fileroot

Definition at line 47 of file volume_from_pdb.h.

fn_outPDB

FileName ProgPdbConverter::fn_outPDB

Output file for centered PDB

Definition at line 50 of file volume_from_pdb.h.

fn_pdb

FileName ProgPdbConverter::fn_pdb

PDB file

Definition at line 44 of file volume_from_pdb.h.

highTs

double ProgPdbConverter::highTs

Definition at line 107 of file volume_from_pdb.h.

intensityColumn

std::string ProgPdbConverter::intensityColumn

Column for the intensity (if any). Only valid for fixed_gaussians.

Definition at line 80 of file volume_from_pdb.h.

limit

Matrix1D<double> ProgPdbConverter::limit

Definition at line 117 of file volume_from_pdb.h.

M

int ProgPdbConverter::M

Definition at line 104 of file volume_from_pdb.h.

noHet

bool ProgPdbConverter::noHet

not HETATM

Definition at line 74 of file volume_from_pdb.h.

orig_x

int ProgPdbConverter::orig_x

Definition at line 56 of file volume_from_pdb.h.

orig_y

int ProgPdbConverter::orig_y

Definition at line 56 of file volume_from_pdb.h.

orig_z

int ProgPdbConverter::orig_z

Definition at line 56 of file volume_from_pdb.h.

origGiven

bool ProgPdbConverter::origGiven

Orig is set

Definition at line 59 of file volume_from_pdb.h.

output_dim_x

int ProgPdbConverter::output_dim_x

Final size and origin in pixels

Definition at line 56 of file volume_from_pdb.h.

output_dim_y

int ProgPdbConverter::output_dim_y

Definition at line 56 of file volume_from_pdb.h.

output_dim_z

int ProgPdbConverter::output_dim_z

Definition at line 56 of file volume_from_pdb.h.

periodicTable

Matrix2D<double> ProgPdbConverter::periodicTable

Definition at line 111 of file volume_from_pdb.h.

sigmaGaussian

double ProgPdbConverter::sigmaGaussian

Fixed Gaussian standard deviation

Definition at line 77 of file volume_from_pdb.h.

Ts

double ProgPdbConverter::Ts

Sampling rate

Definition at line 41 of file volume_from_pdb.h.

useBlobs

bool ProgPdbConverter::useBlobs

Use blobs instead of scattering factors

Definition at line 62 of file volume_from_pdb.h.

useFixedGaussian

bool ProgPdbConverter::useFixedGaussian

Use fixed Gaussian instead of scattering factors

Definition at line 68 of file volume_from_pdb.h.

usePoorGaussian

bool ProgPdbConverter::usePoorGaussian

Use poor Gaussian instead of scattering factors

Definition at line 65 of file volume_from_pdb.h.

Vhigh

Image<double> ProgPdbConverter::Vhigh

Definition at line 121 of file volume_from_pdb.h.

Vlow

Image<double> ProgPdbConverter::Vlow

Definition at line 124 of file volume_from_pdb.h.

---

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

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