ProgARTPseudo Class Reference

#include <reconstruct_art_pseudo.h>

Inheritance diagram for ProgARTPseudo:

Collaboration diagram for ProgARTPseudo:

Public Member Functions
void	defineParams ()
void	readParams ()
void	show () const
void	produceSideInfo ()
void	run ()
void	writePseudo ()
double	ART_single_step (const MultidimArray< double > &Iexp, double rot, double tilt, double psi, double shiftX, double shiftY, const std::vector< double > &lambda)
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	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
FileName	fnDoc
	Selfile with the input images. More...
FileName	fnPseudo
	Pseudoatom filename. More...
FileName	fnNMA
	Selfile with the input NMAs. More...
FileName	fnRoot
	Output filename. More...
double	lambdaART
	Lambda. More...
int	Nit
	Number of iterations. More...
double	sigma
	Sigma of atoms. More...
double	sampling
	Sampling rate. More...
MetaDataVec	DF
std::vector< Matrix1D< double > >	atomPosition
std::vector< double >	atomWeight
Matrix1D< double >	gaussianProjectionTable
Matrix1D< double >	gaussianProjectionTable2
std::vector< Matrix2D< double > >	NMA
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

Parameters for reconstructing with pseudoatoms.

Definition at line 41 of file reconstruct_art_pseudo.h.

Member Function Documentation

ART_single_step()

double ProgARTPseudo::ART_single_step	(	const MultidimArray< double > &	Iexp,
		double	rot,
		double	tilt,
		double	psi,
		double	shiftX,
		double	shiftY,
		const std::vector< double > &	lambda
	)

ART single step

Definition at line 367 of file reconstruct_art_pseudo.cpp.

{
    MultidimArray<double> Itheo, Icorr, Idiff;
    Itheo.initZeros(Iexp);
    Icorr.initZeros(Iexp);
    Matrix2D<double> Euler;
    Euler_angles2matrix(rot, tilt, psi, Euler);
    project_Pseudo(atomPosition, atomWeight, sigma, Itheo, Icorr,
                   Euler, shiftX, shiftY, lambda, NMA, FORWARD,
                   gaussianProjectionTable, gaussianProjectionTable2);
    Idiff.initZeros(Iexp);

    double mean_error=0;
    FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(Iexp)
    {
        // Compute difference image and error
        DIRECT_A2D_ELEM(Idiff, i, j) = DIRECT_A2D_ELEM(Iexp, i, j) - DIRECT_A2D_ELEM(Itheo, i, j);
        mean_error += DIRECT_A2D_ELEM(Idiff, i, j) * DIRECT_A2D_ELEM(Idiff, i, j);

        // Compute the correction image
        DIRECT_A2D_ELEM(Icorr, i, j) = XMIPP_MAX(DIRECT_A2D_ELEM(Icorr, i, j), 1);
        DIRECT_A2D_ELEM(Icorr, i, j) =
            lambdaART * DIRECT_A2D_ELEM(Idiff, i, j) / DIRECT_A2D_ELEM(Icorr, i, j);
    }
    mean_error /= YXSIZE(Iexp);

    project_Pseudo(atomPosition, atomWeight, sigma, Itheo, Icorr,
                   Euler, shiftX, shiftY, lambda, NMA, BACKWARD,
                   gaussianProjectionTable, gaussianProjectionTable2);
    return mean_error;
}

defineParams()

void ProgARTPseudo::defineParams ( )

virtual

Define parameters

Reimplemented from XmippProgram.

Definition at line 191 of file reconstruct_art_pseudo.cpp.

{
    addUsageLine("Generate 3D reconstructions from projections using ART on pseudoatoms.");
    addUsageLine("+This program reconstructs based on irregular grids given by pseudo atomic structures. ");
    addUsageLine("+In case of regular grids, please refer to other programs as reconstruct_art ");
    addUsageLine("+or reconstruct_fourier. Optionally, a deformation file generated by Nodal Mode ");
    addUsageLine("+Alignment (NMA) can be passed with --nma parameter.");

    addSeeAlsoLine("volume_to_pseudoatoms, nma_alignment");

    addParamsLine("   -i <md_file>          : Metadata file with input projections");
    addParamsLine("   --oroot <rootname>    : Output rootname");
    addParamsLine("   alias -o;");
    addParamsLine("   --pseudo <pseudofile> : Pseudo atomic structure (PDB format)");
    addParamsLine("     alias -p;");
    addParamsLine("  [--sigma <s=-1>]       : Pseudoatom sigma. By default, from pseudo file");
    addParamsLine("  [--sampling_rate <Ts=1>]  : Pixel size (Angstrom)");
    addParamsLine("  alias -s;");
    addParamsLine("  [-l <lambda=0.1>]      : Relaxation factor");
    addParamsLine("  [-n <N=1>]             : Number of iterations");
    addParamsLine("  [--nma <selfile=\"\">] : Selfile with NMA");

    addExampleLine("Reconstruct with NMA file and relaxation factor of 0.2:", false);
    addExampleLine("xmipp_reconstruct_art_pseudo -i projections.xmd -o art_rec --nma nmafile.xmd -l 0.2");
}

produceSideInfo()

void ProgARTPseudo::produceSideInfo

(

)

Produce side info

Definition at line 229 of file reconstruct_art_pseudo.cpp.

{
    DF.read(fnDoc);
    std::ifstream fhPseudo;
    fhPseudo.open(fnPseudo.c_str());
    if (!fhPseudo)
        REPORT_ERROR(ERR_IO_NOTEXIST,fnPseudo);
    while (!fhPseudo.eof())
    {
        std::string line;
        getline(fhPseudo, line);
        if (line.length() == 0)
            continue;
        if (line.substr(7,13)=="fixedGaussian" && sigma<0)
        {
            std::vector < std::string> results;
            splitString(line," ",results);
            sigma=textToFloat(results[2]);
            sigma/=sampling;
        }
        else if (line.substr(0,4)=="ATOM")
        {
            Matrix1D<double> v(3);
            v(0)=textToFloat(line.substr(30,8));
            v(1)=textToFloat(line.substr(38,8));
            v(2)=textToFloat(line.substr(46,8));
            v/=sampling;
            atomPosition.push_back(v);
            atomWeight.push_back(0);
        }
    }
    fhPseudo.close();

    double sigma4=4*sigma;
    gaussianProjectionTable.resize(CEIL(sigma4*sqrt(2)*1000));
    FOR_ALL_ELEMENTS_IN_MATRIX1D(gaussianProjectionTable)
    gaussianProjectionTable(i)=gaussian1D(i/1000.0,sigma);
    gaussianProjectionTable*=gaussian1D(0,sigma);
    gaussianProjectionTable2=gaussianProjectionTable;
    gaussianProjectionTable2*=gaussianProjectionTable;

    // NMA
    if (!fnNMA.empty())
    {
        MetaDataVec DFNMA(fnNMA);
        DFNMA.removeDisabled();
        for (size_t objId : DFNMA.ids())
        {
            Matrix2D<double> mode;
            mode.initZeros(atomPosition.size(),3);
            FileName fnMode;
            DFNMA.getValue( MDL_NMA_MODEFILE, fnMode,objId);
            mode.read(fnMode);
            NMA.push_back(mode);
        }
    }
}

readParams()

void ProgARTPseudo::readParams ( )

virtual

Read parameters from command line.

Reimplemented from XmippProgram.

Definition at line 217 of file reconstruct_art_pseudo.cpp.

{
    fnDoc = getParam("-i");
    fnPseudo = getParam("--pseudo");
    fnRoot = getParam("--oroot");
    lambdaART = getDoubleParam("-l");
    Nit = getIntParam("-n");
    sigma = getDoubleParam("--sigma");
    fnNMA = getParam("--nma");
    sampling = getDoubleParam("--sampling_rate");
}

run()

void ProgARTPseudo::run ( )

virtual

Run

Reimplemented from XmippProgram.

Definition at line 287 of file reconstruct_art_pseudo.cpp.

{
    show();
    produceSideInfo();
    Image<double> Iexp;
    for (int it=0; it<Nit; it++)
    {
        double itError=0;
        for (size_t objId : DF.ids())
        {
            FileName fnExp;
            DF.getValue( MDL_IMAGE, fnExp,objId);
            double rot;
            DF.getValue( MDL_ANGLE_ROT, rot,objId);
            double tilt;
            DF.getValue( MDL_ANGLE_TILT, tilt,objId);
            double psi;
            DF.getValue( MDL_ANGLE_PSI, psi,objId);
            double shiftX;
            DF.getValue( MDL_SHIFT_X, shiftX,objId);
            double shiftY;
            DF.getValue( MDL_SHIFT_Y, shiftY,objId);
            std::vector<double> lambda;
            if (NMA.size()>0)
                DF.getValue( MDL_NMA, lambda,objId);

            Iexp.read(fnExp);
            Iexp().setXmippOrigin();
            itError+=ART_single_step(Iexp(),rot,tilt,psi,-shiftX,-shiftY,lambda);
        }
        if (DF.size()>0)
            itError/=DF.size();
        std::cerr << "Error at iteration " << it << " = " << itError << std::endl;
    }
    writePseudo();
}

show()

void ProgARTPseudo::show ( ) const

virtual

Show parameters

Reimplemented from XmippProgram.

Definition at line 171 of file reconstruct_art_pseudo.cpp.

{
    if (verbose > 0)
    {
        std::cout << " =======================================================" << std::endl;
        std::cout << " ART reconstruction method using pseudo atomic structure" << std::endl;
        std::cout << " =======================================================" << std::endl;
        std::cout << "Input images:    " << fnDoc     << std::endl;
        std::cout << "Pseudoatoms:     " << fnPseudo  << std::endl;
        std::cout << "Sigma:           " << sigma     << std::endl;
        std::cout << "Sampling rate:   " << sampling  << std::endl;
        if (!fnNMA.empty())
            std::cout << "NMA:             " << fnNMA     << std::endl;
        std::cout << "Output rootname: " << fnRoot    << std::endl;
        std::cout << "Lambda ART:      " << lambdaART << std::endl;
        std::cout << "N. Iterations:   " << Nit       << std::endl;
        std::cout << "\n -----------------------------------------------------" << std::endl;
    }
}

writePseudo()

void ProgARTPseudo::writePseudo

(

)

Write Pseudo

Definition at line 324 of file reconstruct_art_pseudo.cpp.

{
    // Convert from pseudoatoms to volume
    Image<double> V;
    size_t objId = DF.firstRowId();
    FileName fnExp;
    DF.getValue( MDL_IMAGE, fnExp, objId);
    Image<double> I;
    I.read(fnExp,HEADER);
    V().resize(XSIZE(I()),XSIZE(I()),XSIZE(I()));
    V().setXmippOrigin();

    int nmax=atomPosition.size();
    double sigma4=4*sigma;
    for (int n=0; n<nmax; n++)
    {
        int XX_corner1 = CEIL(XMIPP_MAX(STARTINGX(V()), XX(atomPosition[n]) - sigma4));
        int YY_corner1 = CEIL(XMIPP_MAX(STARTINGY(V()), YY(atomPosition[n]) - sigma4));
        int ZZ_corner1 = CEIL(XMIPP_MAX(STARTINGY(V()), ZZ(atomPosition[n]) - sigma4));
        int XX_corner2 = FLOOR(XMIPP_MIN(FINISHINGX(V()), XX(atomPosition[n]) + sigma4));
        int YY_corner2 = FLOOR(XMIPP_MIN(FINISHINGY(V()), YY(atomPosition[n]) + sigma4));
        int ZZ_corner2 = FLOOR(XMIPP_MIN(FINISHINGY(V()), ZZ(atomPosition[n]) + sigma4));
        if (XX_corner1 <= XX_corner2 && YY_corner1 <= YY_corner2 &&
            ZZ_corner1 <= ZZ_corner2)
        {
            for (int z = ZZ_corner1; z <= ZZ_corner2; z++)
                for (int y = YY_corner1; y <= YY_corner2; y++)
                    for (int x = XX_corner1; x <= XX_corner2; x++)
                        V(z,y,x)+=atomWeight[n]*
                            gaussian1D(z-ZZ(atomPosition[n]),sigma)*
                            gaussian1D(y-YY(atomPosition[n]),sigma)*
                            gaussian1D(x-XX(atomPosition[n]),sigma);
        }
    }
    V.write(fnRoot+".vol");

    // Histogram of the intensities
    MultidimArray<double> intensities(atomWeight);
    Histogram1D hist;
    compute_hist(intensities, hist, 100);
    hist.write(fnRoot+"_intensities.hist");
}

Member Data Documentation

atomPosition

std::vector< Matrix1D<double> > ProgARTPseudo::atomPosition

Definition at line 95 of file reconstruct_art_pseudo.h.

atomWeight

std::vector< double > ProgARTPseudo::atomWeight

Definition at line 98 of file reconstruct_art_pseudo.h.

DF

MetaDataVec ProgARTPseudo::DF

Definition at line 92 of file reconstruct_art_pseudo.h.

fnDoc

FileName ProgARTPseudo::fnDoc

Selfile with the input images.

Definition at line 45 of file reconstruct_art_pseudo.h.

fnNMA

FileName ProgARTPseudo::fnNMA

Selfile with the input NMAs.

Definition at line 51 of file reconstruct_art_pseudo.h.

fnPseudo

FileName ProgARTPseudo::fnPseudo

Pseudoatom filename.

Definition at line 48 of file reconstruct_art_pseudo.h.

fnRoot

FileName ProgARTPseudo::fnRoot

Output filename.

Definition at line 54 of file reconstruct_art_pseudo.h.

gaussianProjectionTable

Matrix1D<double> ProgARTPseudo::gaussianProjectionTable

Definition at line 101 of file reconstruct_art_pseudo.h.

gaussianProjectionTable2

Matrix1D<double> ProgARTPseudo::gaussianProjectionTable2

Definition at line 104 of file reconstruct_art_pseudo.h.

lambdaART

double ProgARTPseudo::lambdaART

Lambda.

Definition at line 57 of file reconstruct_art_pseudo.h.

Nit

int ProgARTPseudo::Nit

Number of iterations.

Definition at line 60 of file reconstruct_art_pseudo.h.

NMA

std::vector< Matrix2D<double> > ProgARTPseudo::NMA

Definition at line 107 of file reconstruct_art_pseudo.h.

sampling

double ProgARTPseudo::sampling

Sampling rate.

Definition at line 66 of file reconstruct_art_pseudo.h.

sigma

double ProgARTPseudo::sigma

Sigma of atoms.

Definition at line 63 of file reconstruct_art_pseudo.h.

---

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

• xmipp/legacy/libraries/reconstruction/reconstruct_art_pseudo.h
• xmipp/legacy/libraries/reconstruction/reconstruct_art_pseudo.cpp