art_crystal (ART for crystals)

Collaboration diagram for art_crystal (ART for crystals):

Classes
class	CrystalARTRecons

Functions
void	computeIntegerLattice (const Matrix1D< double > &a, const Matrix1D< double > &b, double a_mag, double b_mag, double ang_a2b_deg, Matrix1D< double > &aint, Matrix1D< double > &bint, Matrix2D< double > &V, int space_group)
void	expandToFillSpace (const BasicARTParameters &prm, const CrystalARTRecons &eprm, GridVolume &vol)

Detailed Description

Function Documentation

computeIntegerLattice()

void computeIntegerLattice	(	const Matrix1D< double > &	a,
		const Matrix1D< double > &	b,
		double	a_mag,
		double	b_mag,
		double	ang_a2b_deg,
		Matrix1D< double > &	aint,
		Matrix1D< double > &	bint,
		Matrix2D< double > &	V,
		int	space_group
	)

Compute integer lattice vectors and passing matrix. Given two real lattice vectors, this function returns the corresponding integer vectors and the matrix V which passes from a to aint. All vectors are supposed to be 2x1, so V is 2x2. Before computing

aint = Vinv*a; a=V*aint;
bint = Vinv*b; b=V*bint;

Definition at line 394 of file art_crystal.cpp.

{

    // Integer lattice
    // If we force it to be orthogonal the symmetrization is easier
    //a_mag=original a_mag/sampling/grid_relatice_size
    aint.resize(2);
    bint.resize(2);
    XX(aint) = ROUND(a_mag_grid);
    YY(aint) = 0.;
    XX(bint) = 0.0;
    YY(bint) = ROUND(b_mag_grid);

    //different crystalline grids impose different restrictions
    //on the grid, we will check them here but only if the user
    //has provided a symmetry file

    if (space_group != sym_undefined)
    {

        switch (space_group)
        {

        case sym_P1:
            break;// no check needed
        case sym_P2_122://XX(aint) and YY(aint) should be even
            if (XX(aint) != 2*(int)(XX(aint) / 2) ||
                YY(bint) != 2*(int)(YY(bint) / 2))
            {
                std::cout << "\nLattice connstrains for P2_122 are not satisficed"
                << "\nRound[mag_a/(sampling*grid_size)] must be even"
                << "\nPlease modify the parmeters and try again" << std::endl;
                exit(0);
            }
            break;
        case sym_P22_12://XX(aint) and YY(aint) should be even
            if (XX(aint) != 2*(int)(XX(aint) / 2) ||
                YY(bint) != 2*(int)(YY(bint) / 2))
            {
                std::cout << "\nLattice connstrains for P22_12 are not satisficed"
                << "\nRound[mag_a/(sampling*grid_size)] must be even"
                << "\nPlease modify the parmeters and try again" << std::endl;
                exit(0);
            }
            break;
        case sym_P42_12://XX(aint) and YY(aint) should be even
            if (XX(aint) != 2*(int)(XX(aint) / 2) ||
                YY(bint) != 2*(int)(YY(bint) / 2))
            {
                std::cout << "\nLattice connstrains for P4212 are not satisficed"
                << "\nRound[mag_a/(sampling*grid_size)] must be even"
                << "\nPlease modify the parmeters and try again" << std::endl;
                exit(0);
            }
            break;
        case sym_P4:
        case sym_P6:
            break;// no check needed
        default:
            std::cerr << "\n Congratulations: you have found a bug in the\n"
            << "routine compute_integer_lattice or\n"
            << "you are using a non implemented symmetry group\n"
            <<  std::endl;
            exit(0);
            break;
        }//switch(space_group)  end

    }//if (prm.fn_sym!="")


    // Converting matrix
    // a=D*aint
    // b=D*bint
    Matrix2D<double> L(2, 2), LI(2, 2);

    L .setCol(0, a);
    L .setCol(1, b);
    LI.setCol(0, aint);
    LI.setCol(1, bint);
    D = L * LI.inv();
}

expandToFillSpace()

void expandToFillSpace	(	const BasicARTParameters &	prm,
		const CrystalARTRecons &	eprm,
		GridVolume &	vol
	)

Expand basis values to fill space. Copy basis values as a crystal in order to fill the whole space determined by the output volume.

Definition at line 486 of file art_crystal.cpp.

{
    std::cout << "Replicating unit cell ...\n";
#ifdef DEBUG

    Image<double> save;
    vol(0)().getSlice(0, save());
    save.write("inter_before_filling.xmp");
#endif

    // Resize volume ........................................................
    Matrix1D<double> corner1(2), corner2(2);
    VECTOR_R2(corner1,
              FIRST_XMIPP_INDEX(prm.Xoutput_volume_size),
              FIRST_XMIPP_INDEX(prm.Youtput_volume_size));
    VECTOR_R2(corner2,
              LAST_XMIPP_INDEX(prm.Xoutput_volume_size),
              LAST_XMIPP_INDEX(prm.Youtput_volume_size));

    Matrix1D<double> zero(2);
    VECTOR_R2(zero, 0, 0);
    int a0, aF, b0, bF;
    // How many lattice units fit inside the output volume
    find_crystal_limits(corner1, corner2, zero, zero,
                        eprm.a, eprm.b, a0, aF, b0, bF);
#ifdef DEBUG
    std::cerr << "DEBUG_JM: eprm.a: " << eprm.a << std::endl;
    std::cerr << "DEBUG_JM: eprm.b: " << eprm.b << std::endl;
    std::cout << "Output Volume size (ZxYxX)=" << prm.Zoutput_volume_size
    << " " << prm.Youtput_volume_size << " "
    << prm.Xoutput_volume_size << std::endl;
    std::cout << "corners:\n" << corner1.transpose() << std::endl
    << corner2.transpose() << std::endl;
    std::cout << "a0=" << a0 << "..." << aF << std::endl
    << "b0=" << b0 << "..." << bF << std::endl;
#endif

    // Expand the volume to the required space
    corner1 = (double)(a0 - 1) * eprm.a + (double)(b0 - 1) * eprm.b; // CO: I'm not very satisfied with
    corner2 = (double)(aF + 1) * eprm.a + (double)(bF + 1) * eprm.b; //     the +1 and -1 but it works
    corner1.resize(3);
    ZZ(corner1) = FIRST_XMIPP_INDEX(prm.Zoutput_volume_size);
    corner2.resize(3);
    ZZ(corner2) = LAST_XMIPP_INDEX(prm.Zoutput_volume_size);
    vol.resize(corner1, corner2);

    // Copy values ..........................................................
    Matrix1D<double> r(3);
    for (size_t n = 0; n < vol.VolumesNo(); n++)
    {
        Image<double> &V = vol(n);
        FOR_ALL_ELEMENTS_IN_ARRAY2D(eprm.unit_cell_mask)
        {
            if (A2D_ELEM(eprm.unit_cell_mask, i, j))
            {
#ifdef DEBUG2
                std::cout << "(y,x)=(" << i << "," << j << ") is inside\n";
#endif

                for (int ii = b0; ii <= bF; ii++)
                    for (int jj = a0; jj <= aF; jj++)
                    {
                        if (jj == 0 && ii == 0)
                            continue;
                        XX(r) = j + ii * XX(eprm.bint) + jj * XX(eprm.aint);
                        YY(r) = i + ii * YY(eprm.bint) + jj * YY(eprm.aint);
                        ZZ(r) = STARTINGZ(VOLMATRIX(V));
                        if (!VOLMATRIX(V).outside(r))
                        {
#ifdef DEBUG2
                            std::cout << "   Is copied to (" << (int)YY(r) << ","
                            << (int)XX(r) << ")\n";
#endif
                            // copy values if inside volume
                            for (int k = STARTINGZ(VOLMATRIX(V));
                                 k <= FINISHINGZ(VOLMATRIX(V)); k++)
                                VOLVOXEL(V, k, (int)YY(r), (int)XX(r)) =
                                    VOLVOXEL(V, k, i, j);
                        }
                    }
            }
        }
    }
#ifdef DEBUG
    vol(0)().getSlice(0, save());
    save.write("inter_after_filling.xmp");
#endif
}