ProSHADE_internal_overlay Namespace Reference

This namespace contains all the functions required for map overlays. More...

Functions
void	getOptimalRotation (ProSHADE_settings *settings, ProSHADE_internal_data::ProSHADE_data *staticStructure, ProSHADE_internal_data::ProSHADE_data *movingStructure, proshade_double *eulA, proshade_double *eulB, proshade_double *eulG)
	This function finds the optimal rotation between two structures as described by the settings object. More...
void	getOptimalTranslation (ProSHADE_settings *settings, ProSHADE_internal_data::ProSHADE_data *staticStructure, ProSHADE_internal_data::ProSHADE_data *movingStructure, proshade_double *trsX, proshade_double *trsY, proshade_double *trsZ, proshade_double eulA, proshade_double eulB, proshade_double eulG)
	This function finds the optimal translation between two structures as described by the settings object given a rotation between the two objects. More...
void	computeTranslationsFromPeak (ProSHADE_internal_data::ProSHADE_data *staticStructure, ProSHADE_internal_data::ProSHADE_data *movingStructure, proshade_double *trsX, proshade_double *trsY, proshade_double *trsZ)
	This function computes the translation in Angstroms that corresponds to the translation function peak. More...
void	computeBeforeAfterZeroCounts (proshade_unsign *addXPre, proshade_unsign *addYPre, proshade_unsign *addZPre, proshade_unsign *addXPost, proshade_unsign *addYPost, proshade_unsign *addZPost, proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim, proshade_unsign xDimIndices, proshade_unsign yDimIndices, proshade_unsign zDimIndices)
	This function finds the number of zeroes to be added after and before the structure along each dimension. More...
void	paddMapWithZeroes (proshade_double *oldMap, proshade_double *&newMap, proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim, proshade_unsign xDimIndices, proshade_unsign yDimIndices, proshade_unsign zDimIndices, proshade_unsign addXPre, proshade_unsign addYPre, proshade_unsign addZPre)
	This function adds zeroes before and after the central map and copies the central map values into a new map. More...
void	allocateTranslationFunctionMemory (fftw_complex *&tmpIn1, fftw_complex *&tmpOut1, fftw_complex *&tmpIn2, fftw_complex *&tmpOut2, fftw_complex *&resIn, fftw_complex *&resOut, fftw_plan &forwardFourierObj1, fftw_plan &forwardFourierObj2, fftw_plan &inverseFourierCombo, proshade_unsign xD, proshade_unsign yD, proshade_unsign zD)
	This function allocates the memory for the Fourier transforms required for translation function computation. More...
void	freeTranslationFunctionMemory (fftw_complex *&tmpIn1, fftw_complex *&tmpOut1, fftw_complex *&tmpIn2, fftw_complex *&tmpOut2, fftw_complex *&resOut, fftw_plan &forwardFourierObj1, fftw_plan &forwardFourierObj2, fftw_plan &inverseFourierCombo)
	This function releases the memory for the Fourier transforms required for translation function computation. More...
void	computeAngularThreshold (std::vector< proshade_double > *lonCO, std::vector< proshade_double > *latCO, proshade_unsign angRes)
	This function computes the angular thresholds for longitude and lattitude angles. More...
void	initialiseInverseSHComputation (proshade_unsign shBand, double *&sigR, double *&sigI, double *&rcoeffs, double *&icoeffs, double *&weights, double *&workspace, fftw_plan &idctPlan, fftw_plan &ifftPlan)
	This function initialises internal variables for inverse Spherical Harmonics computation. More...

Detailed Description

This namespace contains all the functions required for map overlays.

The map overlay task does have some specific functions that are betters groupped together for higher clarity of the code and also simple modifications later. This is where these live.

Function Documentation

allocateTranslationFunctionMemory()

void ProSHADE_internal_overlay::allocateTranslationFunctionMemory	(	fftw_complex *&	tmpIn1,
		fftw_complex *&	tmpOut1,
		fftw_complex *&	tmpIn2,
		fftw_complex *&	tmpOut2,
		fftw_complex *&	resIn,
		fftw_complex *&	resOut,
		fftw_plan &	forwardFourierObj1,
		fftw_plan &	forwardFourierObj2,
		fftw_plan &	inverseFourierCombo,
		proshade_unsign	xD,
		proshade_unsign	yD,
		proshade_unsign	zD
	)

This function allocates the memory for the Fourier transforms required for translation function computation.

Parameters

[in]	tmpIn1	Array to hold the static structure Fourier inputs.
[in]	tmpOut1	Array to hold the static structure Fourier outputs.
[in]	tmpIn2	Array to hold the moving structure Fourier inputs.
[in]	tmpOut2	Array to hold the moving structure Fourier outputs.
[in]	resIn	Array to hold the final translation function values.
[in]	resOut	Array to hold the combined Fourier coefficients of both structures.
[in]	forwardFourierObj1	FFTW plan for the forward Fourier of the static structure.
[in]	forwardFourierObj2	FFTW plan for the forward Fourier of the moving structure.
[in]	inverseFourierCombo	FFTW plan for the backward Fourier of the combined Fourier factors of both structures.
[in]	xD	The dimension of the X axis of the structures (assumes both structures have the same sizes and sampling).
[in]	yD	The dimension of the Y axis of the structures (assumes both structures have the same sizes and sampling).
[in]	zD	The dimension of the Z axis of the structures (assumes both structures have the same sizes and sampling).

Definition at line 367 of file ProSHADE_overlay.cpp.

{
    //================================================ Allocate memory
    tmpIn1                                            = reinterpret_cast< fftw_complex* > ( fftw_malloc ( sizeof ( fftw_complex ) * xD * yD * zD ) );
    tmpOut1                                           = reinterpret_cast< fftw_complex* > ( fftw_malloc ( sizeof ( fftw_complex ) * xD * yD * zD ) );
    tmpIn2                                            = reinterpret_cast< fftw_complex* > ( fftw_malloc ( sizeof ( fftw_complex ) * xD * yD * zD ) );
    tmpOut2                                           = reinterpret_cast< fftw_complex* > ( fftw_malloc ( sizeof ( fftw_complex ) * xD * yD * zD ) );
    resIn                                             = reinterpret_cast< fftw_complex* > ( fftw_malloc ( sizeof ( fftw_complex ) * xD * yD * zD ) );
    resOut                                            = reinterpret_cast< fftw_complex* > ( fftw_malloc ( sizeof ( fftw_complex ) * xD * yD * zD ) );
    
    //================================================ Check memory allocation
    ProSHADE_internal_misc::checkMemoryAllocation     ( tmpIn1 , __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( tmpOut1, __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( tmpIn2,  __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( tmpOut2, __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( resIn,   __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( resOut,  __FILE__, __LINE__, __func__ );
    
    //================================================ Get Fourier transforms of the maps
    forwardFourierObj1                                = fftw_plan_dft_3d ( static_cast< int > ( xD ), static_cast< int > ( yD ), static_cast< int > ( zD ), tmpIn1, tmpOut1, FFTW_FORWARD , FFTW_ESTIMATE );
    forwardFourierObj2                                = fftw_plan_dft_3d ( static_cast< int > ( xD ), static_cast< int > ( yD ), static_cast< int > ( zD ), tmpIn2, tmpOut2, FFTW_FORWARD , FFTW_ESTIMATE );
    inverseFourierCombo                               = fftw_plan_dft_3d ( static_cast< int > ( xD ), static_cast< int > ( yD ), static_cast< int > ( zD ), resOut, resIn  , FFTW_BACKWARD, FFTW_ESTIMATE );
    
    //================================================ Done
    return ;
    
}

computeAngularThreshold()

void ProSHADE_internal_overlay::computeAngularThreshold	(	std::vector< proshade_double > *	lonCO,
		std::vector< proshade_double > *	latCO,
		proshade_unsign	angRes
	)

This function computes the angular thresholds for longitude and lattitude angles.

Parameters

[in]	lonCO	Pointer to vector where longitude thresholds are to be stored at.
[in]	latCO	Pointer to vector where lattitude thresholds are to be stored at.
[in]	angRes	The angular resolution of the computation.

Definition at line 1287 of file ProSHADE_overlay.cpp.

{
    //================================================ Longitude angular thresholds
    for ( proshade_unsign iter = 0; iter <= angRes; iter++ )
    {
        ProSHADE_internal_misc::addToDoubleVector ( lonCO, static_cast<proshade_double> ( iter ) * ( ( static_cast<proshade_double> ( M_PI ) * 2.0 ) / static_cast<proshade_double> ( angRes ) ) - ( static_cast<double> ( M_PI ) ) );
    }
    
    //================================================ Lattitude angular thresholds
    for ( proshade_unsign iter = 0; iter <= angRes; iter++ )
    {
        ProSHADE_internal_misc::addToDoubleVector ( latCO, static_cast<proshade_double> ( iter ) * ( static_cast<proshade_double> ( M_PI ) / static_cast<proshade_double> ( angRes ) ) - ( static_cast<proshade_double> ( M_PI ) / 2.0 ) );
    }
    
    //================================================ Done
    return ;
     
}

computeBeforeAfterZeroCounts()

void ProSHADE_internal_overlay::computeBeforeAfterZeroCounts	(	proshade_unsign *	addXPre,
		proshade_unsign *	addYPre,
		proshade_unsign *	addZPre,
		proshade_unsign *	addXPost,
		proshade_unsign *	addYPost,
		proshade_unsign *	addZPost,
		proshade_unsign	xDim,
		proshade_unsign	yDim,
		proshade_unsign	zDim,
		proshade_unsign	xDimIndices,
		proshade_unsign	yDimIndices,
		proshade_unsign	zDimIndices
	)

This function finds the number of zeroes to be added after and before the structure along each dimension.

Parameters

[in]	addXPre	Variable pointer where the number of zeroes to be added before the map along X axis is saved.
[in]	addYPre	Variable pointer where the number of zeroes to be added before the map along Y axis is saved.
[in]	addZPre	Variable pointer where the number of zeroes to be added before the map along Z axis is saved.
[in]	addXPost	Variable pointer where the number of zeroes to be added after the map along X axis is saved.
[in]	addYPost	Variable pointer where the number of zeroes to be added after the map along Y axis is saved.
[in]	addZPost	Variable pointer where the number of zeroes to be added after the map along Z axis is saved.
[in]	xDim	The X dimension size in indices of the new map.
[in]	yDim	The Y dimension size in indices of the new map.
[in]	zDim	The Z dimension size in indices of the new map.
[in]	xDimIndices	The X dimension size in indices of the old map.
[in]	yDimIndices	The Y dimension size in indices of the old map.
[in]	zDimIndices	The Z dimension size in indices of the old map.

Definition at line 492 of file ProSHADE_overlay.cpp.

{
    //================================================ Compute
   *addXPre                                           = ( xDim - xDimIndices ) / 2;
   *addYPre                                           = ( yDim - yDimIndices ) / 2;
   *addZPre                                           = ( zDim - zDimIndices ) / 2;
   *addXPost                                          = *addXPre; if ( ( xDim - xDimIndices ) % 2 == 1 ) { *addXPost += 1; }
   *addYPost                                          = *addYPre; if ( ( yDim - yDimIndices ) % 2 == 1 ) { *addYPost += 1; }
   *addZPost                                          = *addZPre; if ( ( zDim - zDimIndices ) % 2 == 1 ) { *addZPost += 1; }
    
    //================================================ Done
    return ;
    
}

computeTranslationsFromPeak()

void ProSHADE_internal_overlay::computeTranslationsFromPeak	(	ProSHADE_internal_data::ProSHADE_data *	staticStructure,
		ProSHADE_internal_data::ProSHADE_data *	movingStructure,
		proshade_double *	trsX,
		proshade_double *	trsY,
		proshade_double *	trsZ
	)

This function computes the translation in Angstroms that corresponds to the translation function peak.

Parameters

[in]	staticStructure	A pointer to the data class object of the static structure.
[in]	movingStructure	A pointer to the data class object of the moving structure.
[in]	trsX	The variable to which the best X-axis position value will be saved to.
[in]	trsY	The variable to which the best Y-axis position value will be saved to.
[in]	trsZ	The variable to which the best Z-axis position value will be saved to.

Definition at line 220 of file ProSHADE_overlay.cpp.

{
    //================================================ Compute map movement
    proshade_single xSamplRate                        = ( static_cast< proshade_single > ( staticStructure->getXDimSize() ) / static_cast< proshade_single > ( staticStructure->getXDim() ) );
    proshade_single ySamplRate                        = ( static_cast< proshade_single > ( staticStructure->getYDimSize() ) / static_cast< proshade_single > ( staticStructure->getYDim() ) );
    proshade_single zSamplRate                        = ( static_cast< proshade_single > ( staticStructure->getZDimSize() ) / static_cast< proshade_single > ( staticStructure->getZDim() ) );
    
    proshade_single xCor                              = static_cast< proshade_single > ( static_cast< proshade_single > ( staticStructure->xFrom - movingStructure->xFrom ) * xSamplRate );
    proshade_single yCor                              = static_cast< proshade_single > ( static_cast< proshade_single > ( staticStructure->yFrom - movingStructure->yFrom ) * ySamplRate );
    proshade_single zCor                              = static_cast< proshade_single > ( static_cast< proshade_single > ( staticStructure->zFrom - movingStructure->zFrom ) * zSamplRate );
    
    proshade_single xMov                              = static_cast< proshade_single > ( 0.0 - static_cast< proshade_double > ( xCor ) - ( *trsX * static_cast< proshade_double > ( xSamplRate ) ) );
    proshade_single yMov                              = static_cast< proshade_single > ( 0.0 - static_cast< proshade_double > ( yCor ) - ( *trsY * static_cast< proshade_double > ( ySamplRate ) ) );
    proshade_single zMov                              = static_cast< proshade_single > ( 0.0 - static_cast< proshade_double > ( zCor ) - ( *trsZ * static_cast< proshade_double > ( zSamplRate ) ) );
    
    //================================================ Save translation vector back
   *trsX                                              = static_cast< proshade_double > ( -xMov );
   *trsY                                              = static_cast< proshade_double > ( -yMov );
   *trsZ                                              = static_cast< proshade_double > ( -zMov );
    
    //================================================ Done
    return ;
    
}

freeTranslationFunctionMemory()

void ProSHADE_internal_overlay::freeTranslationFunctionMemory	(	fftw_complex *&	tmpIn1,
		fftw_complex *&	tmpOut1,
		fftw_complex *&	tmpIn2,
		fftw_complex *&	tmpOut2,
		fftw_complex *&	resOut,
		fftw_plan &	forwardFourierObj1,
		fftw_plan &	forwardFourierObj2,
		fftw_plan &	inverseFourierCombo
	)

This function releases the memory for the Fourier transforms required for translation function computation.

Parameters

[in]	tmpIn1	Array to hold the static structure Fourier inputs.
[in]	tmpOut1	Array to hold the static structure Fourier outputs.
[in]	tmpIn2	Array to hold the moving structure Fourier inputs.
[in]	tmpOut2	Array to hold the moving structure Fourier outputs.
[in]	resOut	Array to hold the combined Fourier coefficients of both structures.
[in]	forwardFourierObj1	FFTW plan for the forward Fourier of the static structure.
[in]	forwardFourierObj2	FFTW plan for the forward Fourier of the moving structure.
[in]	inverseFourierCombo	FFTW plan for the backward Fourier of the combined Fourier factors of both structures.

Definition at line 406 of file ProSHADE_overlay.cpp.

{
    //================================================ Release memory
    fftw_destroy_plan                                 ( forwardFourierObj1 );
    fftw_destroy_plan                                 ( forwardFourierObj2 );
    fftw_destroy_plan                                 ( inverseFourierCombo );
    fftw_free                                         ( tmpIn1 );
    fftw_free                                         ( tmpIn2 );
    fftw_free                                         ( tmpOut1 );
    fftw_free                                         ( tmpOut2 );
    fftw_free                                         ( resOut );
    
    //======================================== Done
    return ;
    
}

getOptimalRotation()

void ProSHADE_internal_overlay::getOptimalRotation	(	ProSHADE_settings *	settings,
		ProSHADE_internal_data::ProSHADE_data *	staticStructure,
		ProSHADE_internal_data::ProSHADE_data *	movingStructure,
		proshade_double *	eulA,
		proshade_double *	eulB,
		proshade_double *	eulG
	)

This function finds the optimal rotation between two structures as described by the settings object.

This function takes the settings and two structure classes. It then reads in and processes both structures so that the globally optimal rotation overlay Euler angles are detected. However, this is only the case for rotation along the centre of the map of the second structure; therefore, either use Patterson data (usePhase = false), or be aware that better rotation may exist for different centre of rotation.

Parameters

[in]	settings	A pointer to settings class containing all the information required for map symmetry detection.
[in]	obj1	A pointer to the data class object of the other ( static ) structure.
[in]	obj2	A pointer to the data class object of the first ( moving ) structure.
[in]	eulA	The variable to which the best Euler alpha angle value will be saved to.
[in]	eulB	The variable to which the best Euler beta angle value will be saved to.
[in]	eulG	The variable to which the best Euler gamma angle value will be saved to.

Definition at line 74 of file ProSHADE_overlay.cpp.

{
    //================================================ Read in the structures
    staticStructure->readInStructure                  ( settings->inputFiles.at(0), 0, settings );
    movingStructure->readInStructure                  ( settings->inputFiles.at(1), 1, settings );
    
    //================================================ Internal data processing  (COM, norm, mask, extra space)
    staticStructure->processInternalMap               ( settings );
    movingStructure->processInternalMap               ( settings );
    
    //================================================ Map to sphere
    staticStructure->mapToSpheres                     ( settings );
    movingStructure->mapToSpheres                     ( settings );
    
    //================================================ Get spherical harmonics
    staticStructure->computeSphericalHarmonics        ( settings );
    movingStructure->computeSphericalHarmonics        ( settings );
    
    //================================================ Get the rotation function of the pair
    movingStructure->getOverlayRotationFunction       ( settings, staticStructure );
    
    //================================================ Get inverse SO(3) map top peak Euler angle values
    ProSHADE_internal_peakSearch::getBestPeakEulerAngsNaive ( movingStructure->getInvSO3Coeffs (),
                                                              movingStructure->getEMatDim ( ) * 2,
                                                              eulA,  eulB,  eulG, settings );
    
    //================================================ Done
    return ;
    
}

getOptimalTranslation()

void ProSHADE_internal_overlay::getOptimalTranslation	(	ProSHADE_settings *	settings,
		ProSHADE_internal_data::ProSHADE_data *	staticStructure,
		ProSHADE_internal_data::ProSHADE_data *	movingStructure,
		proshade_double *	trsX,
		proshade_double *	trsY,
		proshade_double *	trsZ,
		proshade_double	eulA,
		proshade_double	eulB,
		proshade_double	eulG
	)

This function finds the optimal translation between two structures as described by the settings object given a rotation between the two objects.

This function starts by loading and processing the structures according to the settings object (keeping phase is assumed, but callers responsibility). It then applies the required rotation to the second (moing) strucutre and then it follows with zero padding to make sure the structures have the same dimensions (again, it assumes map re-sampling was done, but setting to is callers responsibility). It then computes the translation function, finds the highest peak and returns the positions as well as height of this peak.

Parameters

[in]	settings	A pointer to settings class containing all the information required for map overlay computation.
[in]	staticStructure	A pointer to the data class object of the other ( static ) structure.
[in]	movingStructure	A pointer to the data class object of the first ( moving ) structure.
[in]	trsX	The variable to which the best X-axis position value will be saved to.
[in]	trsY	The variable to which the best Y-axis position value will be saved to.
[in]	trsZ	The variable to which the best Z-axis position value will be saved to.
[in]	eulA	The Euler alpha angle value, by which the moving structure is to be rotated by.
[in]	eulB	The Euler beta angle value, by which the moving structure is to be rotated by.
[in]	eulG	The Euler gamma angle value, by which the moving structure is to be rotated by.

Definition at line 123 of file ProSHADE_overlay.cpp.

{
    //================================================ Read in the structures
    staticStructure->readInStructure                  ( settings->inputFiles.at(0), 0, settings );
    movingStructure->readInStructure                  ( settings->inputFiles.at(1), 1, settings );
    
    //================================================ Determine spherical harmonics variables from the first structure (otherwise, they would be determined from the second structure)
    settings->determineAllSHValues                    ( staticStructure->xDimIndices, staticStructure->yDimIndices,
                                                       staticStructure->xDimSize,     staticStructure->yDimSize,    staticStructure->zDimSize );
    
    //================================================ Internal data processing  (COM, norm, mask, extra space)
    staticStructure->processInternalMap               ( settings );
    movingStructure->processInternalMap               ( settings );
    
    //================================================ Rotate map
    std::vector< proshade_double > rotCen             = movingStructure->rotateMapRealSpaceInPlace ( eulA, eulB, eulG );
    
    //================================================ Zero padding for smaller structure
    staticStructure->zeroPaddToDims                   ( std::max ( staticStructure->getXDim(), movingStructure->getXDim() ),
                                                        std::max ( staticStructure->getYDim(), movingStructure->getYDim() ),
                                                        std::max ( staticStructure->getZDim(), movingStructure->getZDim() ) );
    movingStructure->zeroPaddToDims                   ( std::max ( staticStructure->getXDim(), movingStructure->getXDim() ),
                                                        std::max ( staticStructure->getYDim(), movingStructure->getYDim() ),
                                                        std::max ( staticStructure->getZDim(), movingStructure->getZDim() ) );
    
    //================================================ Report progress
    ProSHADE_internal_messages::printProgressMessage  ( settings->verbose, 1, "Starting translation function computation." );
    
    //================================================ Compute the translation function map
    movingStructure->computeTranslationMap            ( staticStructure );
    
    //================================================ Find highest peak in translation function
    proshade_double mapPeak                           = 0.0;
    proshade_unsign xDimS                             = staticStructure->getXDim();
    proshade_unsign yDimS                             = staticStructure->getYDim();
    proshade_unsign zDimS                             = staticStructure->getZDim();
    ProSHADE_internal_maths::findHighestValueInMap  ( movingStructure->getTranslationFnPointer(), xDimS, yDimS, zDimS, trsX, trsY, trsZ, &mapPeak );
    
    //================================================ Dont translate over half
    if ( *trsX > ( static_cast< proshade_double > ( xDimS ) / 2.0 ) ) { *trsX = *trsX - static_cast< proshade_double > ( xDimS ); }
    if ( *trsY > ( static_cast< proshade_double > ( yDimS ) / 2.0 ) ) { *trsY = *trsY - static_cast< proshade_double > ( yDimS ); }
    if ( *trsZ > ( static_cast< proshade_double > ( zDimS ) / 2.0 ) ) { *trsZ = *trsZ - static_cast< proshade_double > ( zDimS ); }
    
    //================================================ Convert the map positions onto translation in Angstroms and save the results
    computeTranslationsFromPeak                       ( staticStructure, movingStructure, trsX, trsY, trsZ );
    
    movingStructure->originalPdbTransX                = *trsX;
    movingStructure->originalPdbTransY                = *trsY;
    movingStructure->originalPdbTransZ                = *trsZ;
    
    proshade_single xMov                              = static_cast< proshade_single > ( -(*trsX) );
    proshade_single yMov                              = static_cast< proshade_single > ( -(*trsY) );
    proshade_single zMov                              = static_cast< proshade_single > ( -(*trsZ) );
    
    //================================================ Report progress
    std::stringstream hlpSS;
    hlpSS << "Optimal map translation distances are " << *trsX << " ; " << *trsY << " ; " << *trsZ << " Angstroms with peak height " << mapPeak / ( static_cast< proshade_double > ( xDimS ) * static_cast< proshade_double > ( yDimS ) * static_cast< proshade_double > ( zDimS ) );
 
    //================================================ Save original from variables for PDB output
    movingStructure->mapMovFromsChangeX               = static_cast< proshade_double > ( movingStructure->xFrom );
    movingStructure->mapMovFromsChangeY               = static_cast< proshade_double > ( movingStructure->yFrom );
    movingStructure->mapMovFromsChangeZ               = static_cast< proshade_double > ( movingStructure->zFrom );
    
    //================================================ Move the map
    ProSHADE_internal_mapManip::moveMapByIndices      ( &xMov, &yMov, &zMov, movingStructure->getXDimSize(), movingStructure->getYDimSize(), movingStructure->getZDimSize(),
                                                        movingStructure->getXFromPtr(), movingStructure->getXToPtr(),
                                                        movingStructure->getYFromPtr(), movingStructure->getYToPtr(),
                                                        movingStructure->getZFromPtr(), movingStructure->getZToPtr(),
                                                        movingStructure->getXAxisOrigin(), movingStructure->getYAxisOrigin(), movingStructure->getZAxisOrigin() );
 
    ProSHADE_internal_mapManip::moveMapByFourier      ( movingStructure->getInternalMap(), xMov, yMov, zMov,
                                                        movingStructure->getXDimSize(), movingStructure->getYDimSize(), movingStructure->getZDimSize(),
                                                        static_cast< proshade_signed > ( movingStructure->getXDim() ), static_cast< proshade_signed > ( movingStructure->getYDim() ),
                                                        static_cast< proshade_signed > ( movingStructure->getZDim() ) );
    
    //================================================ Report progress
    ProSHADE_internal_messages::printProgressMessage  ( settings->verbose, 3, hlpSS.str(), settings->messageShift );
    ProSHADE_internal_messages::printProgressMessage  ( settings->verbose, 2, "Translation function computation complete.", settings->messageShift );
    
    //================================================ Keep only the change in from and to variables
    movingStructure->mapMovFromsChangeX               = static_cast< proshade_double > ( movingStructure->xFrom ) - movingStructure->mapMovFromsChangeX;
    movingStructure->mapMovFromsChangeY               = static_cast< proshade_double > ( movingStructure->yFrom ) - movingStructure->mapMovFromsChangeY;
    movingStructure->mapMovFromsChangeZ               = static_cast< proshade_double > ( movingStructure->zFrom ) - movingStructure->mapMovFromsChangeZ;
    
    //================================================ Done
    return ;
    
}

initialiseInverseSHComputation()

void ProSHADE_internal_overlay::initialiseInverseSHComputation	(	proshade_unsign	shBand,
		double *&	sigR,
		double *&	sigI,
		double *&	rcoeffs,
		double *&	icoeffs,
		double *&	weights,
		double *&	workspace,
		fftw_plan &	idctPlan,
		fftw_plan &	ifftPlan
	)

This function initialises internal variables for inverse Spherical Harmonics computation.

Parameters

[in]	shBand	The bandwidth for this particular shell.
[in]	sigR	Pointer to be initialised for the real signal values.
[in]	sigI	Pointer to be initialised for the imaginary signal values.
[in]	rcoeffs	Pointer to be initialised for the real coefficient values.
[in]	icoeffs	Pointer to be initialised for the imaginary coefficient values.
[in]	weights	Pointer to be initialised for the transform weight values.
[in]	workspace	Pointer to be initialised for the computation screatch space.
[in]	idctPlan	Pointer reference to the cosine/sine transform plan to be created.
[in]	ifftPlan	Pointer reference to the discrete 3D Fourier transform plan to be created.

Definition at line 1171 of file ProSHADE_overlay.cpp.

{
    //================================================ Initialise internal variables
    proshade_unsign oneDim                            = shBand * 2;
    
    //================================================ Allocate memory
    sigR                                              = new double [(oneDim * oneDim * 4)];
    sigI                                              = sigR + (oneDim * oneDim * 2);
    rcoeffs                                           = new double [(oneDim * oneDim * 2)];
    icoeffs                                           = rcoeffs + (oneDim * oneDim);
    weights                                           = new double [4 * shBand];
    workspace                                         = new double [( 20 * shBand * shBand ) + ( 24 * shBand )];
    
    //================================================ Check memory allocation
    ProSHADE_internal_misc::checkMemoryAllocation     ( sigR,      __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( rcoeffs,   __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( weights,   __FILE__, __LINE__, __func__ );
    ProSHADE_internal_misc::checkMemoryAllocation     ( workspace, __FILE__, __LINE__, __func__ );
    
    //================================================ Create the cosine/sine transform plan
    idctPlan                                          = fftw_plan_r2r_1d ( static_cast< int > ( oneDim ), weights, workspace, FFTW_REDFT01, FFTW_ESTIMATE );
    
    //================================================ Set up the discrete Fourier transform
    int rank, howmany_rank;
    fftw_iodim dims[1], howmany_dims[1];
    
    rank                                              = 1;
    dims[0].n                                         = 2 * static_cast< int > ( shBand );
    dims[0].is                                        = 2 * static_cast< int > ( shBand );
    dims[0].os                                        = 1;
    howmany_rank                                      = 1;
    howmany_dims[0].n                                 = 2 * static_cast< int > ( shBand );
    howmany_dims[0].is                                = 1;
    howmany_dims[0].os                                = 2 * static_cast< int > ( shBand );
    
    //================================================ Create the discrete Fourier transform
    ifftPlan                                          = fftw_plan_guru_split_dft ( rank, dims, howmany_rank, howmany_dims, sigR, sigI, rcoeffs, icoeffs, FFTW_ESTIMATE );
    
    //================================================ Done
    return ;
    
}

paddMapWithZeroes()

void ProSHADE_internal_overlay::paddMapWithZeroes	(	proshade_double *	oldMap,
		proshade_double *&	newMap,
		proshade_unsign	xDim,
		proshade_unsign	yDim,
		proshade_unsign	zDim,
		proshade_unsign	xDimIndices,
		proshade_unsign	yDimIndices,
		proshade_unsign	zDimIndices,
		proshade_unsign	addXPre,
		proshade_unsign	addYPre,
		proshade_unsign	addZPre
	)

This function adds zeroes before and after the central map and copies the central map values into a new map.

Parameters

[in]	oldMap	The original, unpadded map.
[in]	newMap	The array to which the new map will be saved into.
[in]	xDim	The X dimension size of the new map.
[in]	yDim	The Y dimension size of the new map.
[in]	zDim	The Z dimension size of the new map.
[in]	xDimIndices	The X dimension size in indices of the old map.
[in]	yDimIndices	The Y dimension size in indices of the old map.
[in]	zDimIndices	The Z dimension size in indices of the old map.
[in]	addXPre	How many zeroes are to be added before the central map along the X axis?
[in]	addYPre	How many zeroes are to be added before the central map along the Y axis?
[in]	addZPre	How many zeroes are to be added before the central map along the Z axis?

Definition at line 521 of file ProSHADE_overlay.cpp.

{
    //================================================ Initialise local variables
    proshade_unsign newMapIndex                       = 0;
    proshade_unsign oldMapIndex                       = 0;
    
    //================================================ Copy and padd as appropriate
    for ( proshade_unsign xIt = 0; xIt < xDim; xIt++ )
    {
        for ( proshade_unsign yIt = 0; yIt < yDim; yIt++ )
        {
            for ( proshade_unsign zIt = 0; zIt < zDim; zIt++ )
            {
                //==================================== Find map location
                newMapIndex                           = zIt + zDim * ( yIt + yDim * xIt );
                
                //==================================== If less than needed, add zero
                if ( xIt < addXPre ) { newMap[newMapIndex] = 0.0; continue; }
                if ( yIt < addYPre ) { newMap[newMapIndex] = 0.0; continue; }
                if ( zIt < addZPre ) { newMap[newMapIndex] = 0.0; continue; }
                
                //==================================== If more than needed, add zero
                if ( xIt >= ( addXPre + xDimIndices ) ) { newMap[newMapIndex] = 0.0; continue; }
                if ( yIt >= ( addYPre + yDimIndices ) ) { newMap[newMapIndex] = 0.0; continue; }
                if ( zIt >= ( addZPre + zDimIndices ) ) { newMap[newMapIndex] = 0.0; continue; }
                
                //==================================== If not padding, copy original values
                oldMapIndex                           = (zIt-addZPre) + zDimIndices * ( (yIt-addYPre) + yDimIndices * (xIt-addXPre) );
                newMap[newMapIndex]                   = oldMap[oldMapIndex];
            }
        }
    }
    
    //======================================== Done
    return ;
    
}