ProSHADE  0.7.6.2 (DEC 2021)
Protein Shape Detection
ProSHADE_internal_data::ProSHADE_data Class Reference

This class contains all inputed and derived data for a single structure. More...

#include <ProSHADE_data.hpp>

Public Member Functions

 ProSHADE_data ()
 Constructor for getting empty ProSHADE_data class. More...
 
 ProSHADE_data (std::string strName, double *mapVals, int len, proshade_single xDmSz, proshade_single yDmSz, proshade_single zDmSz, proshade_unsign xDmInd, proshade_unsign yDmInd, proshade_unsign zDmInd, proshade_signed xFr, proshade_signed yFr, proshade_signed zFr, proshade_signed xT, proshade_signed yT, proshade_signed zT, proshade_unsign inputO)
 Constructor for creating ProSHADE_data structure with data. More...
 
 ~ProSHADE_data (void)
 Destructor for the ProSHADE_data class. More...
 
void readInStructure (std::string fName, proshade_unsign inputO, ProSHADE_settings *settings, proshade_double *maskArr=nullptr, proshade_unsign maskXDim=0, proshade_unsign maskYDim=0, proshade_unsign maskZDim=0, proshade_double *weightsArr=nullptr, proshade_unsign weigXDim=0, proshade_unsign weigYDim=0, proshade_unsign weigZDim=0)
 This function initialises the basic ProSHADE_data variables and reads in a single structure. More...
 
void readInStructure (gemmi::Structure gemmiStruct, proshade_unsign inputO, ProSHADE_settings *settings)
 This function initialises the basic ProSHADE_data variables and reads in a single structure from Gemmi co-ordinate object. More...
 
void writeMap (std::string fName, std::string title="Created by ProSHADE and written by GEMMI", int mode=2)
 Function for writing out the internal structure representation in MRC MAP format. More...
 
void writePdb (std::string fName, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true)
 This function writes out the co-ordinates file with ProSHADE type rotation and translation applied. More...
 
void writeGemmi (std::string fName, gemmi::Structure gemmiStruct, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true)
 This function writes out the gemmi::Structure object with ProSHADE type rotation and translation applied. More...
 
void writeMask (std::string fName, proshade_double *mask)
 Function for writing out a mask in MRC MAP format. More...
 
void invertMirrorMap (ProSHADE_settings *settings)
 Function for inverting the map to its mirror image. More...
 
void normaliseMap (ProSHADE_settings *settings)
 Function for normalising the map values to mean 0 and sd 1.. More...
 
void maskMap (ProSHADE_settings *settings)
 Function for computing the map mask using blurring and X IQRs from median. More...
 
void getReBoxBoundaries (ProSHADE_settings *settings, proshade_signed *&ret)
 This function finds the boundaries enclosing positive map values and adds some extra space. More...
 
void createNewMapFromBounds (ProSHADE_settings *settings, ProSHADE_data *&newStr, proshade_signed *newBounds)
 This function creates a new structure from the calling structure and new bounds values. More...
 
void reSampleMap (ProSHADE_settings *settings)
 This function changes the internal map sampling to conform to particular resolution value. More...
 
void centreMapOnCOM (ProSHADE_settings *settings)
 This function shits the map so that its COM is in the centre of the map. More...
 
void addExtraSpace (ProSHADE_settings *settings)
 This function increases the size of the map so that it can add empty space around it. More...
 
void removePhaseInormation (ProSHADE_settings *settings)
 This function removes phase from the map, effectively converting it to Patterson map. More...
 
void shiftToBoxCentre (ProSHADE_settings *settings)
 Function for shifting map so that its centre of box is at required position. More...
 
void shiftToRotationCentre (ProSHADE_settings *settings)
 Function for shifting map so that its rotation centre is at the centre of the box. More...
 
void processInternalMap (ProSHADE_settings *settings)
 This function simply clusters several other functions which should be called together. More...
 
void getSpherePositions (ProSHADE_settings *settings)
 This function determines the sphere positions (radii) for sphere mapping. More...
 
void mapToSpheres (ProSHADE_settings *settings)
 This function converts the internal map onto a set of concentric spheres. More...
 
void computeSphericalHarmonics (ProSHADE_settings *settings)
 This function computes the spherical harmonics decomposition for the whole structure. More...
 
bool shellBandExists (proshade_unsign shell, proshade_unsign bandVal)
 This function checks if particular shell has a particular band. More...
 
void computeRRPMatrices (ProSHADE_settings *settings)
 This function pre-computes the RRP matrices for a data object. More...
 
void allocateEMatrices (proshade_unsign band)
 This function allocates the required memory for the E matrices. More...
 
void allocateSO3CoeffsSpace (proshade_unsign band)
 This function allocates the memory for the SO(3) coefficients and the inverse for that calling object. More...
 
void allocateWignerMatricesSpace ()
 This function allocates the memory for the Wigner matrices for the calling object.
 
void computeRotationFunction (ProSHADE_settings *settings)
 This function computes the self-rotation function for this structure. More...
 
void convertRotationFunction (ProSHADE_settings *settings)
 This function converts the self-rotation function of this structure to angle-axis representation. More...
 
void getRealEMatrixValuesForLM (proshade_signed band, proshade_signed order1, double *eMatsLMReal, int len)
 This function fills the input array with the real E matrix values for particular band and order1 (l as opposed to l'). More...
 
void getImagEMatrixValuesForLM (proshade_signed band, proshade_signed order1, double *eMatsLMImag, int len)
 This function fills the input array with the imaginary E matrix values for particular band and order1 (l as opposed to l'). More...
 
void getRealSO3Coeffs (double *so3CoefsReal, int len)
 This function fills the input array with the real SO(3) coefficient values. More...
 
void getImagSO3Coeffs (double *so3CoefsImag, int len)
 This function fills the input array with the imaginary SO(3) coefficient values. More...
 
void getRealRotFunction (double *rotFunReal, int len)
 This function fills the input array with the real rotation function values. More...
 
void getImagRotFunction (double *rotFunImag, int len)
 This function fills the input array with the imaginary rotation function values. More...
 
void getRealTranslationFunction (double *trsFunReal, int len)
 This function fills the input array with the real translation function values. More...
 
void getImagTranslationFunction (double *trsFunImag, int len)
 This function fills the input array with the imaginary translation function values. More...
 
void getRotMatrixFromRotFunInds (proshade_signed aI, proshade_signed bI, proshade_signed gI, double *rotMat, int len)
 This function takes rotation function indices, converts them to Euler angles and these to rotation matrix, which it then returns. More...
 
int so3CoeffsArrayIndex (proshade_signed order1, proshade_signed order2, proshade_signed band)
 This function gets the SO(3) coefficients array index for a particular so(3) band, order1 and order2 position. More...
 
std::vector< proshade_double * > getDihedralSymmetriesList (ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
 This function obtains a list of all D symmetries from already computed C symmetries list. More...
 
std::vector< proshade_double * > getTetrahedralSymmetriesList (ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
 This function obtains a list of all T symmetry axes from the already computed C symmetries list. More...
 
std::vector< proshade_double * > getOctahedralSymmetriesList (ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
 This function obtains a list of all O symmetry axes from the already computed C symmetries list. More...
 
std::vector< proshade_double * > getIcosahedralSymmetriesList (ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
 This function obtains a list of all I symmetry axes from the already computed C symmetries list. More...
 
std::vector< std::vector< proshade_double * > > getPredictedIcosahedralSymmetriesList (ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
 This function predicts a list of all I symmetry axes from the already computed C symmetries list. More...
 
std::vector< proshade_double * > getPredictedOctahedralSymmetriesList (ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
 This function predicts a list of all O symmetry axes from the already computed C symmetries list. More...
 
std::vector< proshade_double * > getPredictedTetrahedralSymmetriesList (ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
 This function predicts a list of all T symmetry axes from the already computed C symmetries list. More...
 
void detectSymmetryFromAngleAxisSpace (ProSHADE_settings *settings, std::vector< proshade_double * > *axes, std::vector< std::vector< proshade_double > > *allCs)
 This function runs the symmetry detection algorithms on this structure using the angle-axis space and saving the results in the settings object. More...
 
std::vector< proshade_double * > getCyclicSymmetriesListFromAngleAxis (ProSHADE_settings *settings)
 This function obtains a list of all C symmetries from the angle-axis space mapped rotation function values. More...
 
std::vector< proshade_double * > findRequestedCSymmetryFromAngleAxis (ProSHADE_settings *settings, proshade_unsign fold, proshade_double *peakThres)
 This function searches the angle-axis representation of the rotation function for a cyclic point group with given fold. More...
 
void saveDetectedSymmetries (ProSHADE_settings *settings, std::vector< proshade_double * > *CSyms, std::vector< std::vector< proshade_double > > *allCs)
 This function takes the results of point group searches and saves then into the output variables. More...
 
std::string getRecommendedSymmetryType (ProSHADE_settings *settings)
 This function simply returns the detected recommended symmetry type. More...
 
proshade_unsign getRecommendedSymmetryFold (ProSHADE_settings *settings)
 This function simply returns the detected recommended symmetry fold. More...
 
proshade_unsign getNoRecommendedSymmetryAxes (ProSHADE_settings *settings)
 This function returns the number of detected recommended symmetry axes. More...
 
std::vector< std::string > getSymmetryAxis (ProSHADE_settings *settings, proshade_unsign axisNo)
 This function returns a single symmetry axis as a vector of strings from the recommended symmetry axes list. More...
 
void prepareFSCFourierMemory (fftw_complex *&mapData, fftw_complex *&origCoeffs, fftw_complex *&fCoeffs, proshade_signed *&binIndexing, proshade_signed *noBins, proshade_double **&bindata, proshade_signed *&binCounts, fftw_plan *planForwardFourier, proshade_double *&fscByBin)
 This function allocates the memory and makes all preparations required for FSC computation. More...
 
proshade_double computeFSC (ProSHADE_settings *settings, std::vector< proshade_double * > *CSym, size_t symIndex, fftw_complex *mapData, fftw_complex *fCoeffs, fftw_complex *origCoeffs, fftw_plan *planForwardFourier, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **&bindata, proshade_signed *&binCounts, proshade_double *&fscByBin)
 This function computes FSC for any given axis in the supplied CSym symmetry axes vector. More...
 
proshade_double computeFSC (ProSHADE_settings *settings, proshade_double *sym, fftw_complex *mapData, fftw_complex *fCoeffs, fftw_complex *origCoeffs, fftw_plan *planForwardFourier, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **&bindata, proshade_signed *&binCounts, proshade_double *&fscByBin)
 This function computes FSC for any given axis in the supplied CSym symmetry axes vector. More...
 
void saveRecommendedSymmetry (ProSHADE_settings *settings, std::vector< proshade_double * > *CSym, std::vector< proshade_double * > *DSym, std::vector< proshade_double * > *TSym, std::vector< proshade_double * > *OSym, std::vector< proshade_double * > *ISym, std::vector< proshade_double * > *axes, fftw_complex *mapData, fftw_complex *origCoeffs, fftw_complex *fCoeffs, fftw_plan *planForwardFourier, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **bindata, proshade_signed *binCounts, proshade_double *&fscByBin)
 This function takes all the detected symmetry results and decides on which are to be recommended for this structure. More...
 
void saveRequestedSymmetryC (ProSHADE_settings *settings, std::vector< proshade_double * > *CSym, std::vector< proshade_double * > *axes)
 This function takes the C symmetries and searched for the requested symmetry. More...
 
void saveRequestedSymmetryD (ProSHADE_settings *settings, std::vector< proshade_double * > *DSym, std::vector< proshade_double * > *axes, fftw_complex *mapData, fftw_complex *origCoeffs, fftw_complex *fCoeffs, fftw_plan *planForwardFourier, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **bindata, proshade_signed *binCounts, proshade_double *&fscByBin)
 This function takes the D symmetries and searched for the requested symmetry. More...
 
std::vector< std::vector< proshade_double > > getAllGroupElements (ProSHADE_settings *settings, std::vector< proshade_unsign > axesList, std::string groupType="", proshade_double matrixTolerance=0.05)
 This function returns the group elements as rotation matrices of any defined point group. More...
 
std::vector< std::vector< proshade_double > > getAllGroupElements (std::vector< std::vector< proshade_double > > *allCs, std::vector< proshade_unsign > axesList, std::string groupType="", proshade_double matrixTolerance=0.05)
 This function returns the group elements as rotation matrices of any defined point group. More...
 
void reportSymmetryResults (ProSHADE_settings *settings)
 This function takes prints the report for symmetry detection. More...
 
void getOverlayRotationFunction (ProSHADE_settings *settings, ProSHADE_internal_data::ProSHADE_data *obj2)
 This function computes the overlay rotation function (i.e. the correlation function in SO(3) space). More...
 
std::vector< proshade_double > getBestRotationMapPeaksEulerAngles (ProSHADE_settings *settings)
 This function returns a vector of three floats, the three Euler angles of the best peak in the rotation map. More...
 
std::vector< proshade_double > getBestTranslationMapPeaksAngstrom (ProSHADE_internal_data::ProSHADE_data *staticStructure)
 This function gets the optimal translation vector and returns it as a standard library vector. It also applies the translation to the internal map. More...
 
void zeroPaddToDims (proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim)
 This function changes the size of a structure to fit the supplied new limits. More...
 
void rotateMapReciprocalSpace (ProSHADE_settings *settings, proshade_double eulerAlpha, proshade_double eulerBeta, proshade_double eulerGamma)
 This function rotates a map based on the given Euler angles. More...
 
std::vector< proshade_double > rotateMapRealSpace (proshade_double axX, proshade_double axY, proshade_double axZ, proshade_double axAng, proshade_double *&map)
 This function rotates a map based on the given angle-axis rotation. More...
 
std::vector< proshade_double > rotateMapRealSpaceInPlace (proshade_double eulA, proshade_double eulB, proshade_double eulG)
 This function rotates a map based on the given Euler angles in place. More...
 
void translateMap (proshade_double trsX, proshade_double trsY, proshade_double trsZ)
 This function simply translates the map by a given number of Angstroms along the three axes. More...
 
void allocateRotatedSHMemory (void)
 This function allocates the memory required for storing the rotated Spherical Harmonics coefficients.
 
void computeRotatedSH (void)
 This function multiplies the objects spherical harmonics with the Wigner D matrices, obtaining rotated spherical harmonics coefficients.
 
void invertSHCoefficients (void)
 This function computes the shell mapped data from inverting the Spherical Harmonics coefficients. More...
 
void interpolateMapFromSpheres (proshade_double *&densityMapRotated)
 This function interpolates the density map from the sphere mapped data. More...
 
void computeTranslationMap (ProSHADE_internal_data::ProSHADE_data *obj1)
 This function does the computation of the translation map and saves results internally. More...
 
void findMapCOM (void)
 This function finds the centre of mass of the internal map representation. More...
 
void writeOutOverlayFiles (ProSHADE_settings *settings, proshade_double eulA, proshade_double eulB, proshade_double eulG, std::vector< proshade_double > *rotCentre, std::vector< proshade_double > *ultimateTranslation)
 This function writes out the rotated map, co-ordinates and transformation JSON file. More...
 
void reportOverlayResults (ProSHADE_settings *settings, std::vector< proshade_double > *rotationCentre, std::vector< proshade_double > *eulerAngles, std::vector< proshade_double > *finalTranslation)
 This function reports the results of the overlay mode. More...
 
void deepCopyMap (proshade_double *&saveTo, proshade_signed verbose)
 This function copies the internal map into the supplied pointer, which it also allocates. More...
 
proshade_double getMapValue (proshade_unsign pos)
 This function returns the internal map representation value of a particular array position. More...
 
proshade_unsign getMaxSpheres (void)
 This function returns the number of spheres which contain the whole object. More...
 
proshade_unsign getMaxBand (void)
 This function returns the maximum band value for the object. More...
 
proshade_double * getRealSphHarmValue (proshade_unsign band, proshade_unsign order, proshade_unsign shell)
 This function allows access to the private internal real spherical harmonics values. More...
 
proshade_double * getImagSphHarmValue (proshade_unsign band, proshade_unsign order, proshade_unsign shell)
 This function allows access to the private internal imaginary spherical harmonics values. More...
 
proshade_double getRRPValue (proshade_unsign band, proshade_unsign sh1, proshade_unsign sh2)
 This function allows access to the priva internal RRP matrices. More...
 
proshade_double getAnySphereRadius (proshade_unsign shell)
 This function allows access to the radius of any particular sphere. More...
 
proshade_double getIntegrationWeight (void)
 This function allows access to the integration weight for the object. More...
 
proshade_unsign getShellBandwidth (proshade_unsign shell)
 This function allows access to the bandwidth of a particular shell. More...
 
proshade_single getSpherePosValue (proshade_unsign shell)
 This function allows access to sphere positions. More...
 
proshade_complex ** getEMatrixByBand (proshade_unsign band)
 This function allows access to E matrix for a particular band. More...
 
void getEMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_double *valueReal, proshade_double *valueImag)
 This function allows access to E matrix by knowing the band, order1 and order2 indices. More...
 
proshade_complex * getInvSO3Coeffs (void)
 This function allows access to the inverse SO(3) coefficients array. More...
 
proshade_complex * getSO3Coeffs (void)
 This function allows access to the SO(3) coefficients array. More...
 
proshade_unsign getComparisonBand (void)
 This function allows access to the maximum band for the comparison. More...
 
void getWignerMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_double *valueReal, proshade_double *valueImag)
 This function allows access to the Wigner D matrix by knowing the band, order1 and order2 indices. More...
 
proshade_single getXDimSize (void)
 This function allows access to the map size in angstroms along the X axis. More...
 
proshade_single getYDimSize (void)
 This function allows access to the map size in angstroms along the Y axis. More...
 
proshade_single getZDimSize (void)
 This function allows access to the map size in angstroms along the Z axis. More...
 
proshade_unsign getXDim (void)
 This function allows access to the map size in indices along the X axis. More...
 
proshade_unsign getYDim (void)
 This function allows access to the map size in indices along the Y axis. More...
 
proshade_unsign getZDim (void)
 This function allows access to the map size in indices along the Z axis. More...
 
proshade_signed * getXFromPtr (void)
 This function allows access to the map start along the X axis. More...
 
proshade_signed * getYFromPtr (void)
 This function allows access to the map start along the Y axis. More...
 
proshade_signed * getZFromPtr (void)
 This function allows access to the map start along the Z axis. More...
 
proshade_signed * getXToPtr (void)
 This function allows access to the map last position along the X axis. More...
 
proshade_signed * getYToPtr (void)
 This function allows access to the map last position along the Y axis. More...
 
proshade_signed * getZToPtr (void)
 This function allows access to the map last position along the Z axis. More...
 
proshade_signed * getXAxisOrigin (void)
 This function allows access to the map X axis origin value. More...
 
proshade_signed * getYAxisOrigin (void)
 This function allows access to the map Y axis origin value. More...
 
proshade_signed * getZAxisOrigin (void)
 This function allows access to the map Z axis origin value. More...
 
proshade_double *& getInternalMap (void)
 This function allows access to the first map array value address. More...
 
proshade_complex * getTranslationFnPointer (void)
 This function allows access to the translation function through a pointer. More...
 
std::vector< proshade_double > getMapCOMProcessChange (void)
 This function allows access to the translation caused by structure processing. More...
 
void setIntegrationWeight (proshade_double intW)
 This function allows setting the integration weight for the object. More...
 
void setIntegrationWeightCumul (proshade_double intW)
 This function allows setting the cumulative integration weight for the object. More...
 
void setEMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_complex val)
 This function allows setting the E matrix value. More...
 
void normaliseEMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_double normF)
 This function allows normalising the E matrix value. More...
 
void setSO3CoeffValue (proshade_unsign position, proshade_complex val)
 This function allows setting the SOFT coefficient values using array position and value. More...
 
void setWignerMatrixValue (proshade_complex val, proshade_unsign band, proshade_unsign order1, proshade_unsign order2)
 This function allows setting the Wigner D matrix value by its band, order1 and order2 co-ordinate. More...
 

Public Attributes

std::string fileName
 This is the original file from which the data were obtained.
 
ProSHADE_internal_io::InputType fileType
 This is the type of the input file.
 
proshade_double * internalMap
 The internal map data representation, which may be amended as the run progresses.
 
proshade_single xDimSize
 This is the size of the map cell x dimension in Angstroms.
 
proshade_single yDimSize
 This is the size of the map cell y dimension in Angstroms.
 
proshade_single zDimSize
 This is the size of the map cell z dimension in Angstroms.
 
proshade_single aAngle
 This is the angle a of the map cell in degrees.
 
proshade_single bAngle
 This is the angle b of the map cell in degrees.
 
proshade_single cAngle
 This is the angle c of the map cell in degrees.
 
proshade_unsign xDimIndices
 This is the size of the map cell x dimension in indices.
 
proshade_unsign yDimIndices
 This is the size of the map cell y dimension in indices.
 
proshade_unsign zDimIndices
 This is the size of the map cell z dimension in indices.
 
proshade_unsign xGridIndices
 As far as I know, this is identical to the xDimIndices.
 
proshade_unsign yGridIndices
 As far as I know, this is identical to the yDimIndices.
 
proshade_unsign zGridIndices
 As far as I know, this is identical to the zDimIndices.
 
proshade_unsign xAxisOrder
 This is the order of the x axis.
 
proshade_unsign yAxisOrder
 This is the order of the y axis.
 
proshade_unsign zAxisOrder
 This is the order of the z axis.
 
proshade_signed xAxisOrigin
 This is the origin position along the x axis.
 
proshade_signed yAxisOrigin
 This is the origin position along the y axis.
 
proshade_signed zAxisOrigin
 This is the origin position along the z axis.
 
proshade_double xCom
 The COM of the map after processing along the X-axis.
 
proshade_double yCom
 The COM of the map after processing along the Y-axis.
 
proshade_double zCom
 The COM of the map after processing along the Z-axis.
 
proshade_single xDimSizeOriginal
 This is the size of the map cell x dimension in Angstroms.
 
proshade_single yDimSizeOriginal
 This is the size of the map cell y dimension in Angstroms.
 
proshade_single zDimSizeOriginal
 This is the size of the map cell z dimension in Angstroms.
 
proshade_unsign xDimIndicesOriginal
 This is the size of the map cell x dimension in indices.
 
proshade_unsign yDimIndicesOriginal
 This is the size of the map cell y dimension in indices.
 
proshade_unsign zDimIndicesOriginal
 This is the size of the map cell z dimension in indices.
 
proshade_signed xAxisOriginOriginal
 This is the origin position along the x axis.
 
proshade_signed yAxisOriginOriginal
 This is the origin position along the y axis.
 
proshade_signed zAxisOriginOriginal
 This is the origin position along the z axis.
 
proshade_double originalMapXCom
 The COM of the first map to be loaded/computed without any furhter changes being reflacted along the X axis.
 
proshade_double originalMapYCom
 The COM of the first map to be loaded/computed without any furhter changes being reflacted along the Y axis.
 
proshade_double originalMapZCom
 The COM of the first map to be loaded/computed without any furhter changes being reflacted along the Z axis.
 
proshade_double mapMovFromsChangeX
 When the map is translated, the xFrom and xTo values are changed. This variable holds how much they have changed.
 
proshade_double mapMovFromsChangeY
 When the map is translated, the yFrom and yTo values are changed. This variable holds how much they have changed.
 
proshade_double mapMovFromsChangeZ
 When the map is translated, the zFrom and zTo values are changed. This variable holds how much they have changed.
 
proshade_double mapCOMProcessChangeX
 The change in X axis between the creation of the structure (originalMapXCom) and just before rotation.
 
proshade_double mapCOMProcessChangeY
 The change in Y axis between the creation of the structure (originalMapYCom) and just before rotation.
 
proshade_double mapCOMProcessChangeZ
 The change in Z axis between the creation of the structure (originalMapZCom) and just before rotation.
 
proshade_double originalPdbRotCenX
 The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map) along the x-axis.
 
proshade_double originalPdbRotCenY
 The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map) along the y-axis.
 
proshade_double originalPdbRotCenZ
 The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map) along the z-axis.
 
proshade_double originalPdbTransX
 The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE internal map) along the x-axis.
 
proshade_double originalPdbTransY
 The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE internal map) along the y-axis.
 
proshade_double originalPdbTransZ
 The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE internal map) along the z-axis.
 
proshade_signed xFrom
 This is the starting index along the x axis.
 
proshade_signed yFrom
 This is the starting index along the y axis.
 
proshade_signed zFrom
 This is the starting index along the z axis.
 
proshade_signed xTo
 This is the final index along the x axis.
 
proshade_signed yTo
 This is the final index along the y axis.
 
proshade_signed zTo
 This is the final index along the z axis.
 
std::vector< proshade_single > spherePos
 Vector of sphere radii from the centre of the map.
 
proshade_unsign noSpheres
 The number of spheres with map projected onto them.
 
ProSHADE_internal_spheres::ProSHADE_sphere ** spheres
 The set of concentric spheres to which the intermal density map has been projected.
 
proshade_complex ** sphericalHarmonics
 A set of spherical harmonics values arrays for each sphere.
 
proshade_complex ** rotSphericalHarmonics
 A set of rotated spherical harmonics values arrays for each sphere, used only if map rotation is required.
 
proshade_unsign maxShellBand
 The maximum band for any shell of the object.
 
proshade_double *** rrpMatrices
 The energy levels descriptor shell correlation tables.
 
proshade_complex *** eMatrices
 The trace sigma and full rotation function c*conj(c) integral tables.
 
proshade_double integrationWeight
 The Pearson's c.c. type weighting for the integration.
 
proshade_complex * so3Coeffs
 The coefficients obtained by SO(3) Fourier Transform (SOFT), in this case derived from the E matrices.
 
proshade_complex * so3CoeffsInverse
 The inverse coefficients obtained by inverse SO(3) Fourier Transform (SOFT) - i.e. rotation function.
 
proshade_complex *** wignerMatrices
 These matrices are computed for a particular rotation to be done in spherical harmonics.
 
proshade_unsign maxCompBand
 The largest comparison band - this variable tells how large arrays will be allocated for the comparison.
 
proshade_complex * translationMap
 This is where the translation map will be held, if at all used.
 
std::vector< ProSHADE_internal_spheres::ProSHADE_rotFun_sphere * > sphereMappedRotFun
 
bool isEmpty
 This variable stated whether the class contains any information.
 
proshade_unsign inputOrder
 This value is the input order - it is useful to know for writing out files, so that they would not overwrite the same name multiple times.
 

Protected Member Functions

void figureIndexStartStop (void)
 Function for determining iterator start and stop positions. More...
 
void setPDBMapValues (void)
 Function for determining iterator start and stop positions. More...
 
void readInMAP (ProSHADE_settings *settings, proshade_double *maskArr=nullptr, proshade_unsign maskXDim=0, proshade_unsign maskYDim=0, proshade_unsign maskZDim=0, proshade_double *weightsArr=nullptr, proshade_unsign weigXDim=0, proshade_unsign weigYDim=0, proshade_unsign weigZDim=0)
 Function for reading map data using gemmi library. More...
 
void readInPDB (ProSHADE_settings *settings)
 Function for reading pdb data. More...
 
void readInGemmi (gemmi::Structure gemmiStruct, ProSHADE_settings *settings)
 Function for reading co-ordinate data from Gemmi object. More...
 
void allocateRRPMemory ()
 This function allocates the required memory for the RRP matrices. More...
 

Detailed Description

This class contains all inputed and derived data for a single structure.

This class codes the object that contains all the information about the input data and the derived information as well. It does not, however, provide the computation code as that lives elsewhere, except for the forward declarations.

Definition at line 48 of file ProSHADE_data.hpp.

Constructor & Destructor Documentation

◆ ProSHADE_data() [1/2]

ProSHADE_internal_data::ProSHADE_data::ProSHADE_data ( )

Constructor for getting empty ProSHADE_data class.

This constructor creates an empty data structure which can later be filled with data and used to process these data further.

Parameters
[in]settingsProSHADE_settings object specifying what should be done.
[out]XEmpty data object with deault values.

Definition at line 93 of file ProSHADE_data.cpp.

94 {
95  //================================================ Initialise variables
96  // ... Variables regarding input file
97  this->fileName = "";
98  this->fileType = ProSHADE_internal_io::UNKNOWN;
99 
100  // ... Variables regarding map
101  this->internalMap = nullptr;
102 
103  // ... Variables regarding map information
104  this->xDimSize = 0.0;
105  this->yDimSize = 0.0;
106  this->zDimSize = 0.0;
107  this->aAngle = 0.0;
108  this->bAngle = 0.0;
109  this->cAngle = 0.0;
110  this->xDimIndices = 0;
111  this->yDimIndices = 0;
112  this->zDimIndices = 0;
113  this->xGridIndices = 0;
114  this->yGridIndices = 0;
115  this->zGridIndices = 0;
116  this->xAxisOrder = 1;
117  this->yAxisOrder = 2;
118  this->zAxisOrder = 3;
119  this->xAxisOrigin = 0;
120  this->yAxisOrigin = 0;
121  this->zAxisOrigin = 0;
122  this->xCom = 0.0;
123  this->yCom = 0.0;
124  this->zCom = 0.0;
125 
126  // ... Variables regarding original input values (i.e. these do not change with ProSHADE manipulations)
127  this->xDimSizeOriginal = 0.0;
128  this->yDimSizeOriginal = 0.0;
129  this->zDimSizeOriginal = 0.0;
130  this->xDimIndicesOriginal = 0;
131  this->yDimIndicesOriginal = 0;
132  this->zDimIndicesOriginal = 0;
133  this->xAxisOriginOriginal = 0;
134  this->yAxisOriginOriginal = 0;
135  this->zAxisOriginOriginal = 0;
136  this->originalMapXCom = 0.0;
137  this->originalMapYCom = 0.0;
138  this->originalMapZCom = 0.0;
139  this->mapMovFromsChangeX = 0.0;
140  this->mapMovFromsChangeY = 0.0;
141  this->mapMovFromsChangeZ = 0.0;
142  this->mapCOMProcessChangeX = 0.0;
143  this->mapCOMProcessChangeY = 0.0;
144  this->mapCOMProcessChangeZ = 0.0;
145 
146  // ... Variables regarding rotation and translation of original input files
147  this->originalPdbRotCenX = 0.0;
148  this->originalPdbRotCenY = 0.0;
149  this->originalPdbRotCenZ = 0.0;
150  this->originalPdbTransX = 0.0;
151  this->originalPdbTransY = 0.0;
152  this->originalPdbTransZ = 0.0;
153 
154  // ... Variables regarding iterator positions
155  this->xFrom = 0;
156  this->yFrom = 0;
157  this->zFrom = 0;
158  this->xTo = 0;
159  this->yTo = 0;
160  this->zTo = 0;
161 
162  // ... Variables regarding SH mapping spheres
163  this->spherePos = std::vector<proshade_single> ( );
164  this->noSpheres = 0;
165  this->spheres = nullptr;
166  this->sphericalHarmonics = nullptr;
167  this->rotSphericalHarmonics = nullptr;
168  this->maxShellBand = 0;
169 
170  // ... Variables regarding shape distance computations
171  this->rrpMatrices = nullptr;
172  this->eMatrices = nullptr;
173  this->so3Coeffs = nullptr;
174  this->so3CoeffsInverse = nullptr;
175  this->wignerMatrices = nullptr;
176  this->integrationWeight = 0.0;
177  this->maxCompBand = 0;
178  this->translationMap = nullptr;
179 
180 
181  // ... Control variables
182  this->isEmpty = true;
183 
184  //================================================ Done
185 
186 }

◆ ProSHADE_data() [2/2]

ProSHADE_internal_data::ProSHADE_data::ProSHADE_data ( std::string  strName,
double *  mapVals,
int  len,
proshade_single  xDmSz,
proshade_single  yDmSz,
proshade_single  zDmSz,
proshade_unsign  xDmInd,
proshade_unsign  yDmInd,
proshade_unsign  zDmInd,
proshade_signed  xFr,
proshade_signed  yFr,
proshade_signed  zFr,
proshade_signed  xT,
proshade_signed  yT,
proshade_signed  zT,
proshade_unsign  inputO 
)

Constructor for creating ProSHADE_data structure with data.

This constructor creates a data structure with all the map information, so that maps obtained from other software could be loeaded and used. This function makes a lot of assumptions (all angles are 90 degrees, axis grids are equal to indices, axis order is XYZ and axis origin is the first index in all dimensions). If any of these are not true, the user is required to change the appropriate internal values after this function has returned the object.

Parameters
[in]settingsProSHADE_settings object specifying what should be done.
[in]strNameThe name of the structure for reference.
[in]mapValsA pointer to array where all the map data are.
[in]lenThe length of this map values array.
[in]xDmSzThe size of the x-axis dimension in Angstroms.
[in]yDmSzThe size of the y-axis dimension in Angstroms.
[in]zDmSzThe size of the z-axis dimension in Angstroms.
[in]xDmIndThe size of the x-axis dimension in indices.
[in]yDmIndThe size of the y-axis dimension in indices.
[in]zDmIndThe size of the z-axis dimension in indices.
[in]xFrThe first index statting position along the x-axis.
[in]yFrThe first index statting position along the y-axis.
[in]zFrThe first index statting position along the z-axis.
[in]xTThe last index end position along the x-axis.
[in]yTThe last index end position along the y-axis.
[in]zTThe last index end position along the z-axis.
[in]inputOThe input order for this structure.
[out]XEmpty data object with filled in values and map.

Definition at line 214 of file ProSHADE_data.cpp.

215 {
216  //================================================ Initialise variables
217  // ... Variables regarding input file
218  this->fileName = strName;
219  this->fileType = ProSHADE_internal_io::MAP;
220 
221  // ... Variables regarding map
222  this->internalMap = nullptr;
223 
224  // ... Variables regarding map information
225  this->xDimSize = xDmSz;
226  this->yDimSize = yDmSz;
227  this->zDimSize = zDmSz;
228  this->aAngle = 90.0;
229  this->bAngle = 90.0;
230  this->cAngle = 90.0;
231  this->xDimIndices = xDmInd;
232  this->yDimIndices = yDmInd;
233  this->zDimIndices = zDmInd;
234  this->xGridIndices = xDmInd;
235  this->yGridIndices = yDmInd;
236  this->zGridIndices = zDmInd;
237  this->xAxisOrder = 1;
238  this->yAxisOrder = 2;
239  this->zAxisOrder = 3;
240  this->xAxisOrigin = xFr;
241  this->yAxisOrigin = yFr;
242  this->zAxisOrigin = zFr;
243  this->xCom = 0.0;
244  this->yCom = 0.0;
245  this->zCom = 0.0;
246 
247  // ... Variables regarding original input values (i.e. these do not change with ProSHADE manipulations)
248  this->xDimSizeOriginal = 0.0;
249  this->yDimSizeOriginal = 0.0;
250  this->zDimSizeOriginal = 0.0;
251  this->xDimIndicesOriginal = 0;
252  this->yDimIndicesOriginal = 0;
253  this->zDimIndicesOriginal = 0;
254  this->xAxisOriginOriginal = 0;
255  this->yAxisOriginOriginal = 0;
256  this->zAxisOriginOriginal = 0;
257  this->originalMapXCom = 0.0;
258  this->originalMapYCom = 0.0;
259  this->originalMapZCom = 0.0;
260  this->mapMovFromsChangeX = 0.0;
261  this->mapMovFromsChangeY = 0.0;
262  this->mapMovFromsChangeZ = 0.0;
263  this->mapCOMProcessChangeX = 0.0;
264  this->mapCOMProcessChangeY = 0.0;
265  this->mapCOMProcessChangeZ = 0.0;
266 
267  // ... Variables regarding rotation and translation of original input files
268  this->originalPdbRotCenX = 0.0;
269  this->originalPdbRotCenY = 0.0;
270  this->originalPdbRotCenZ = 0.0;
271  this->originalPdbTransX = 0.0;
272  this->originalPdbTransY = 0.0;
273  this->originalPdbTransZ = 0.0;
274 
275  // ... Variables regarding iterator positions
276  this->xFrom = xFr;
277  this->yFrom = yFr;
278  this->zFrom = zFr;
279  this->xTo = xT;
280  this->yTo = yT;
281  this->zTo = zT;
282 
283  // ... Variables regarding SH mapping spheres
284  this->spherePos = std::vector<proshade_single> ( );
285  this->noSpheres = 0;
286  this->spheres = nullptr;
287  this->sphericalHarmonics = nullptr;
288  this->rotSphericalHarmonics = nullptr;
289  this->maxShellBand = 0;
290 
291  // ... Variables regarding shape distance computations
292  this->rrpMatrices = nullptr;
293  this->eMatrices = nullptr;
294  this->so3Coeffs = nullptr;
295  this->so3CoeffsInverse = nullptr;
296  this->wignerMatrices = nullptr;
297  this->integrationWeight = 0.0;
298  this->maxCompBand = 0;
299  this->translationMap = nullptr;
300 
301  // ... Control variables
302  this->isEmpty = false;
303  this->inputOrder = inputO;
304 
305  //================================================ Sanity checks
306  if ( static_cast<proshade_unsign> ( len ) != ( xDmInd * yDmInd * zDmInd ) )
307  {
308  throw ProSHADE_exception ( "Structure class input map has wrong dimensions.", "EP00044", __FILE__, __LINE__, __func__, "The supplied map array size has different dimensions to\n : the required map dimensions." );
309  }
310 
311  if ( ( static_cast<proshade_signed> ( xT - xFr ) != static_cast<proshade_signed> ( xDmInd - 1 ) ) ||
312  ( static_cast<proshade_signed> ( yT - yFr ) != static_cast<proshade_signed> ( yDmInd - 1 ) ) ||
313  ( static_cast<proshade_signed> ( zT - zFr ) != static_cast<proshade_signed> ( zDmInd - 1 ) ) )
314  {
315  throw ProSHADE_exception ( "Structure class input dimensions not in line with map\n : to/from indices.", "EP00045", __FILE__, __LINE__, __func__, "The supplied map information does not add up. The\n : dimensions are not in line with the indexing start/stop\n : position distances and therefore proper map indexing\n : cannot be done. Please check the input values." );
316  }
317 
318  //================================================ Allocate the map memory
319  this->internalMap = new proshade_double [this->xDimIndices * this->yDimIndices * this->zDimIndices];
320  ProSHADE_internal_misc::checkMemoryAllocation ( this->internalMap, __FILE__, __LINE__, __func__ );
321 
322  //================================================ Copy the values into the map
323  proshade_unsign arrPos = 0;
324  for ( proshade_unsign xIt = 0; xIt < this->xDimIndices; xIt++ )
325  {
326  for ( proshade_unsign yIt = 0; yIt < this->yDimIndices; yIt++ )
327  {
328  for ( proshade_unsign zIt = 0; zIt < this->zDimIndices; zIt++ )
329  {
330  arrPos = zIt + this->zDimIndices * ( yIt + this->yDimIndices * xIt );
331  this->internalMap[arrPos] = static_cast<proshade_double> ( mapVals[arrPos] );
332  }
333  }
334  }
335 
336  //================================================ Release memory (it was allocated by the PyBind11 lambda function and needs to be released)
337  delete[] mapVals;
338 
339  //================================================ Done
340 
341 }

◆ ~ProSHADE_data()

ProSHADE_internal_data::ProSHADE_data::~ProSHADE_data ( void  )

Destructor for the ProSHADE_data class.

This destructor is responsible for releasing all memory used by the data storing object

Parameters
[out]XN/A.

Definition at line 349 of file ProSHADE_data.cpp.

350 {
351  //================================================ Release the internal map
352  if ( this->internalMap != nullptr )
353  {
354  delete[] this->internalMap;
355  }
356 
357  //================================================ Release the sphere mapping
358  if ( this->spheres != nullptr )
359  {
360  for ( proshade_unsign iter = 0; iter < this->noSpheres; iter++ )
361  {
362  if ( this->spheres[iter] != nullptr )
363  {
364  delete this->spheres[iter];
365  this->spheres[iter] = nullptr;
366  }
367  }
368  delete[] this->spheres;
369  }
370 
371  //================================================ Release the spherical harmonics
372  if ( this->sphericalHarmonics != nullptr )
373  {
374  for ( proshade_unsign iter = 0; iter < this->noSpheres; iter++ )
375  {
376  if ( this->sphericalHarmonics[iter] != nullptr )
377  {
378  delete[] this->sphericalHarmonics[iter];
379  this->sphericalHarmonics[iter] = nullptr;
380  }
381  }
382  delete[] this->sphericalHarmonics;
383  }
384 
385  //================================================ Release the rotated spherical harmonics
386  if ( this->rotSphericalHarmonics != nullptr )
387  {
388  for ( proshade_unsign iter = 0; iter < this->noSpheres; iter++ )
389  {
390  if ( this->rotSphericalHarmonics[iter] != nullptr )
391  {
392  delete[] this->rotSphericalHarmonics[iter];
393  this->rotSphericalHarmonics[iter] = nullptr;
394  }
395  }
396  delete[] this->rotSphericalHarmonics;
397  }
398 
399  //================================================ Release the RRP matrices (pre-computation for the energy levels descriptor)
400  if ( this->rrpMatrices != nullptr )
401  {
402  for ( proshade_unsign bwIt = 0; bwIt < this->maxShellBand; bwIt++ )
403  {
404  if ( this->rrpMatrices[bwIt] != nullptr )
405  {
406  for ( proshade_unsign shIt = 0; shIt < this->noSpheres; shIt++ )
407  {
408  if ( this->rrpMatrices[bwIt][shIt] != nullptr )
409  {
410  delete[] this->rrpMatrices[bwIt][shIt];
411  }
412  }
413 
414  delete[] this->rrpMatrices[bwIt];
415  }
416  }
417 
418  delete[] this->rrpMatrices;
419  }
420 
421  //================================================ Release the E matrices
422  if ( this->eMatrices != nullptr )
423  {
424  for ( proshade_unsign bandIter = 0; bandIter < this->maxCompBand; bandIter++ )
425  {
426  if ( this->eMatrices[bandIter] != nullptr )
427  {
428  for ( proshade_unsign band2Iter = 0; band2Iter < static_cast<proshade_unsign> ( ( bandIter * 2 ) + 1 ); band2Iter++ )
429  {
430  if ( this->eMatrices[bandIter][band2Iter] != nullptr )
431  {
432  delete[] this->eMatrices[bandIter][band2Iter];
433  }
434  }
435 
436  delete[] this->eMatrices[bandIter];
437  }
438  }
439 
440  delete[] this->eMatrices;
441  }
442 
443  //================================================ Release SOFT and inverse SOFT coefficients
444  if ( this->so3Coeffs != nullptr )
445  {
446  delete[] this->so3Coeffs;
447  }
448  if ( this->so3CoeffsInverse != nullptr )
449  {
450  delete[] this->so3CoeffsInverse;
451  }
452 
453  //================================================ Release Wigner matrices
454  if ( this->wignerMatrices != nullptr )
455  {
456  for ( proshade_unsign bandIter = 1; bandIter < this->maxCompBand; bandIter++ )
457  {
458  if ( this->wignerMatrices[bandIter] != nullptr )
459  {
460  for ( proshade_unsign order1Iter = 0; order1Iter < ( (bandIter * 2) + 1 ); order1Iter++ )
461  {
462  if ( this->wignerMatrices[bandIter][order1Iter] != nullptr )
463  {
464  delete[] this->wignerMatrices[bandIter][order1Iter];
465  }
466  }
467  delete[] this->wignerMatrices[bandIter];
468  }
469  }
470  delete[] wignerMatrices;
471  }
472 
473  //================================================ Release translation map
474  if ( this->translationMap != nullptr )
475  {
476  delete[] this->translationMap;
477  }
478 
479  //================================================ Release the angle-axis space rotation function
480  if ( this->sphereMappedRotFun.size() > 0 )
481  {
482  for ( proshade_unsign spIt = 0; spIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); spIt++ )
483  {
484  delete this->sphereMappedRotFun.at(spIt);
485  }
486  }
487 
488  //================================================ Done
489 
490 }

Member Function Documentation

◆ addExtraSpace()

void ProSHADE_internal_data::ProSHADE_data::addExtraSpace ( ProSHADE_settings settings)

This function increases the size of the map so that it can add empty space around it.

This function adds a given number of angstroms (as given in the settings object) to the internal structure map. This requires all the internal variables to be adjusted for the extra space at the begginning and at the end, while also copying the map into a larger one with appropriate extra space.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 1585 of file ProSHADE_data.cpp.

1586 {
1587  //================================================ Report function start
1588  std::stringstream hlpSS;
1589  hlpSS << "Adding extra " << settings->addExtraSpace << " angstroms.";
1590  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, hlpSS.str(), settings->messageShift );
1591 
1592  //================================================ Figure how much indices need to change
1593  proshade_unsign xAddIndices = static_cast< proshade_unsign > ( ProSHADE_internal_mapManip::myRound ( settings->addExtraSpace / ( this->xDimSize / static_cast<proshade_single> ( this->xDimIndices ) ) ) );
1594  proshade_unsign yAddIndices = static_cast< proshade_unsign > ( ProSHADE_internal_mapManip::myRound ( settings->addExtraSpace / ( this->yDimSize / static_cast<proshade_single> ( this->yDimIndices ) ) ) );
1595  proshade_unsign zAddIndices = static_cast< proshade_unsign > ( ProSHADE_internal_mapManip::myRound ( settings->addExtraSpace / ( this->zDimSize / static_cast<proshade_single> ( this->zDimIndices ) ) ) );
1596 
1597  //================================================ Update internal data variables
1598  this->xDimSize += 2 * static_cast<proshade_single> ( xAddIndices ) * this->xDimSize / static_cast<proshade_single> ( this->xDimIndices );
1599  this->yDimSize += 2 * static_cast<proshade_single> ( yAddIndices ) * this->yDimSize / static_cast<proshade_single> ( this->yDimIndices );
1600  this->zDimSize += 2 * static_cast<proshade_single> ( zAddIndices ) * this->zDimSize / static_cast<proshade_single> ( this->zDimIndices );
1601 
1602  this->xDimIndices += 2 * xAddIndices;
1603  this->yDimIndices += 2 * yAddIndices;
1604  this->zDimIndices += 2 * zAddIndices;
1605 
1606  this->xGridIndices = this->xDimIndices;
1607  this->yGridIndices = this->yDimIndices;
1608  this->zGridIndices = this->zDimIndices;
1609 
1610  this->xAxisOrigin -= xAddIndices;
1611  this->yAxisOrigin -= yAddIndices;
1612  this->zAxisOrigin -= zAddIndices;
1613 
1614  this->xFrom -= xAddIndices;
1615  this->yFrom -= yAddIndices;
1616  this->zFrom -= zAddIndices;
1617 
1618  this->xTo += xAddIndices;
1619  this->yTo += yAddIndices;
1620  this->zTo += zAddIndices;
1621 
1622  //================================================ Allocate new map
1623  proshade_double* newMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1624  ProSHADE_internal_misc::checkMemoryAllocation ( newMap, __FILE__, __LINE__, __func__ );
1625 
1626  //================================================ Set new map to zeroes
1627  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1628  {
1629  newMap[iter] = 0.0;
1630  }
1631 
1632  //================================================ Update the map
1633  proshade_unsign newMapIndex, oldMapIndex;
1634  for ( proshade_unsign xIt = 0; xIt < (this->xDimIndices - xAddIndices); xIt++ )
1635  {
1636  //============================================ Check if point is applicable
1637  if ( xIt < xAddIndices ) { continue; }
1638 
1639  for ( proshade_unsign yIt = 0; yIt < (this->yDimIndices - yAddIndices); yIt++ )
1640  {
1641  //======================================== Check if point is applicable
1642  if ( yIt < yAddIndices ) { continue; }
1643 
1644  for ( proshade_unsign zIt = 0; zIt < (this->zDimIndices - zAddIndices); zIt++ )
1645  {
1646  //==================================== Check if point is applicable
1647  if ( zIt < zAddIndices ) { continue; }
1648 
1649  //==================================== Var init
1650  newMapIndex = zIt + this->zDimIndices * ( yIt + this->yDimIndices * xIt );
1651  oldMapIndex = (zIt - zAddIndices) + (this->zDimIndices - ( 2 * zAddIndices ) ) * ( (yIt - yAddIndices) + (this->yDimIndices - ( 2 * yAddIndices ) ) * (xIt - xAddIndices) );
1652 
1653  newMap[newMapIndex] = this->internalMap[oldMapIndex];
1654  }
1655  }
1656  }
1657 
1658  //================================================ Copy new to old
1659  delete[] this->internalMap;
1660 
1661  this->internalMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1662  ProSHADE_internal_misc::checkMemoryAllocation ( this->internalMap, __FILE__, __LINE__, __func__ );
1663 
1664  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1665  {
1666  this->internalMap[iter] = newMap[iter];
1667  }
1668 
1669  //================================================ Release memory
1670  delete[] newMap;
1671 
1672  //================================================ Report function completion
1673  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Extra space added.", settings->messageShift );
1674 
1675  //================================================ Done
1676  return ;
1677 
1678 }

◆ allocateEMatrices()

void ProSHADE_internal_data::ProSHADE_data::allocateEMatrices ( proshade_unsign  band)

This function allocates the required memory for the E matrices.

This function belongs to the ProSHADE_data class and its role is to allocate the require memory for the E matrices required by both, the Trace Sigma and Full Rotational descriptors, as well as symmetry and rotation tasks.

Parameters
[in]bandThe minimal band of the comparison for which E matrices are computed.

Definition at line 275 of file ProSHADE_distances.cpp.

276 {
277  //================================================ Save the maximum band to the object
278  this->maxCompBand = band;
279 
280  //================================================ Allocate the required memory
281  this->eMatrices = new proshade_complex** [this->maxCompBand];
282  ProSHADE_internal_misc::checkMemoryAllocation ( this->eMatrices, __FILE__, __LINE__, __func__ );
283 
284  for ( proshade_unsign bandIter = 0; bandIter < this->maxCompBand; bandIter++ )
285  {
286  //============================================ Allocate the data structure
287  this->eMatrices[bandIter] = new proshade_complex* [static_cast<proshade_unsign> ( ( bandIter * 2 ) + 1 )];
288  ProSHADE_internal_misc::checkMemoryAllocation ( this->eMatrices[bandIter], __FILE__, __LINE__, __func__ );
289 
290  for ( proshade_unsign band2Iter = 0; band2Iter < static_cast<proshade_unsign> ( ( bandIter * 2 ) + 1 ); band2Iter++ )
291  {
292  this->eMatrices[bandIter][band2Iter] = new proshade_complex [static_cast<proshade_unsign> ( ( bandIter * 2 ) + 1 )];
293  ProSHADE_internal_misc::checkMemoryAllocation ( this->eMatrices[bandIter][band2Iter], __FILE__, __LINE__, __func__ );
294  }
295  }
296 
297  //================================================ Done
298  return ;
299 
300 }

◆ allocateRRPMemory()

void ProSHADE_internal_data::ProSHADE_data::allocateRRPMemory ( )
protected

This function allocates the required memory for the RRP matrices.

This function belongs to the ProSHADE_data class and its role is to allocate the require memory for the RRP matrices, given the already determined bandwidths and shell count.

Definition at line 31 of file ProSHADE_distances.cpp.

32 {
33  //================================================ Allocate the required memory
34  this->rrpMatrices = new proshade_double** [this->maxShellBand];
35  ProSHADE_internal_misc::checkMemoryAllocation ( this->rrpMatrices, __FILE__, __LINE__, __func__ );
36 
37  for ( proshade_unsign bwIt = 0; bwIt < this->maxShellBand; bwIt++ )
38  {
39  //============================================ For rach sphere
40  this->rrpMatrices[bwIt] = new proshade_double* [this->noSpheres];
41  ProSHADE_internal_misc::checkMemoryAllocation ( this->rrpMatrices[bwIt], __FILE__, __LINE__, __func__ );
42 
43  for ( proshade_unsign shIt = 0; shIt < this->noSpheres; shIt++ )
44  {
45  this->rrpMatrices[bwIt][shIt] = new double [this->noSpheres];
46  ProSHADE_internal_misc::checkMemoryAllocation ( this->rrpMatrices[bwIt][shIt], __FILE__, __LINE__, __func__ );
47  }
48  }
49 }

◆ allocateSO3CoeffsSpace()

void ProSHADE_internal_data::ProSHADE_data::allocateSO3CoeffsSpace ( proshade_unsign  band)

This function allocates the memory for the SO(3) coefficients and the inverse for that calling object.

Parameters
[in]bandThe bandwidth to which the computation will be done.

Definition at line 675 of file ProSHADE_distances.cpp.

676 {
677  //================================================ Allocate the memory
678  this->so3Coeffs = new fftw_complex [static_cast<proshade_unsign>( ( 4 * pow( static_cast<proshade_double> ( band ), 3.0 ) - static_cast<proshade_double> ( band ) ) / 3.0 )];
679  this->so3CoeffsInverse = new fftw_complex [static_cast<proshade_unsign>( pow( static_cast<proshade_double> ( band ) * 2.0, 3.0 ) )];
680 
681  //================================================ Check memory allocation
682  ProSHADE_internal_misc::checkMemoryAllocation ( this->so3Coeffs, __FILE__, __LINE__, __func__ );
683  ProSHADE_internal_misc::checkMemoryAllocation ( this->so3CoeffsInverse, __FILE__, __LINE__, __func__ );
684 
685  //================================================ Done
686  return ;
687 
688 }

◆ centreMapOnCOM()

void ProSHADE_internal_data::ProSHADE_data::centreMapOnCOM ( ProSHADE_settings settings)

This function shits the map so that its COM is in the centre of the map.

This function finds the Centre Of Mass (COM) for the internal map and proceeds to use Fourier to shift the COM to the centre of the map. There is an assumption that the COM and centre of map are close, as if they were far apart, the shift could move some part of the map through the boundaries and cause the map to become messy.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 1520 of file ProSHADE_data.cpp.

1521 {
1522  //================================================ Report function start
1523  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Centering map onto its COM.", settings->messageShift );
1524 
1525  //================================================ Initialise local variables
1526  proshade_double xCOM = 0.0;
1527  proshade_double yCOM = 0.0;
1528  proshade_double zCOM = 0.0;
1529 
1530  //================================================ Find the COM location
1531  ProSHADE_internal_mapManip::findMAPCOMValues ( this->internalMap, &xCOM, &yCOM, &zCOM,
1532  this->xDimSize, this->yDimSize, this->xDimSize, this->xFrom,
1533  this->xTo, this->yFrom, this->yTo, this->zFrom, this->zTo );
1534 
1535  //================================================ Find the sampling rates
1536  proshade_single xSampRate = static_cast< proshade_single > ( this->xDimSize ) / static_cast< proshade_single > ( this->xTo - this->xFrom );
1537  proshade_single ySampRate = static_cast< proshade_single > ( this->yDimSize ) / static_cast< proshade_single > ( this->yTo - this->yFrom );
1538  proshade_single zSampRate = static_cast< proshade_single > ( this->zDimSize ) / static_cast< proshade_single > ( this->zTo - this->zFrom );
1539 
1540  //================================================ Convert to position in indices starting from 0
1541  xCOM /= static_cast< proshade_double > ( xSampRate );
1542  yCOM /= static_cast< proshade_double > ( ySampRate );
1543  zCOM /= static_cast< proshade_double > ( zSampRate );
1544 
1545  xCOM -= static_cast< proshade_double > ( this->xFrom );
1546  yCOM -= static_cast< proshade_double > ( this->yFrom );
1547  zCOM -= static_cast< proshade_double > ( this->zFrom );
1548 
1549  //================================================ Find distance from COM to map centre in Angstroms
1550  proshade_double xDist = ( ( static_cast<proshade_double> ( this->xDimIndices ) / 2.0 ) - xCOM ) * static_cast<proshade_double> ( this->xDimSize ) / static_cast<proshade_double> ( this->xDimIndices );
1551  proshade_double yDist = ( ( static_cast<proshade_double> ( this->yDimIndices ) / 2.0 ) - yCOM ) * static_cast<proshade_double> ( this->yDimSize ) / static_cast<proshade_double> ( this->yDimIndices );
1552  proshade_double zDist = ( ( static_cast<proshade_double> ( this->zDimIndices ) / 2.0 ) - zCOM ) * static_cast<proshade_double> ( this->zDimSize ) / static_cast<proshade_double> ( this->zDimIndices );
1553 
1554  //================================================ Move the map within the box
1556  static_cast< proshade_single > ( xDist ),
1557  static_cast< proshade_single > ( yDist ),
1558  static_cast< proshade_single > ( zDist ),
1559  this->xDimSize, this->yDimSize, this->zDimSize,
1560  static_cast< proshade_signed > ( this->xDimIndices ),
1561  static_cast< proshade_signed > ( this->yDimIndices ),
1562  static_cast< proshade_signed > ( this->zDimIndices ) );
1563 
1564  //================================================ Note the change due to centering
1565  this->mapCOMProcessChangeX -= xDist;
1566  this->mapCOMProcessChangeY -= yDist;
1567  this->mapCOMProcessChangeZ -= zDist;
1568 
1569  //================================================ Report function completion
1570  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Map centered.", settings->messageShift );
1571 
1572  //================================================ Done
1573  return ;
1574 
1575 }

◆ computeFSC() [1/2]

proshade_double ProSHADE_internal_data::ProSHADE_data::computeFSC ( ProSHADE_settings settings,
proshade_double *  sym,
fftw_complex *  mapData,
fftw_complex *  fCoeffs,
fftw_complex *  origCoeffs,
fftw_plan *  planForwardFourier,
proshade_signed  noBins,
proshade_signed *  binIndexing,
proshade_double **&  bindata,
proshade_signed *&  binCounts,
proshade_double *&  fscByBin 
)

This function computes FSC for any given axis in the supplied CSym symmetry axes vector.

This function drives the FSC computation for symmetry detection. It iterates over all rotations specified by the symmetry axis (except for the I rotation) and for each of these, computes the map rotation accordingly. Next, it computes the Fourier transform of such rotated map and procceds to bin the coefficients according to the supplied key. From these bins, the sums required for finding the FSC between the rotated map and the original map can be obtained. Finally, averaging the FSC'c for all rotations the final FSC for the whole symmetry axis is obtained and returned.

Warning
This function does not really work on its own, it makes plethora of assumptions, the main ones being: Fourier transform of original (non-rotated) map is already computed and supplied, the FFTW plan for the Fourier transform of the rotated map is prepared and supplied, the workspace is allocated and supplied, the binning mask and number of bins is already determined ans supplied and so on. It would not be hard to remove these, but then repeated calls of this function would become much slower as all of these steps would have to be done for each call separately.
Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]symA single double array containing a single Cyclic symmetry entry in the ProSHADE format.
[in]mapDataFFTW complex array which will be the input for the Fourier transform done by the planForwardFourier plan.
[in]fCoeffsFFTW complex array where the Fourier transform coefficients will be saved into by the planForwardFourier plan.
[in]origCoeffsFFTW complex array holding already compute Fourier transform of the non-rotated map.
[in]planForwardFourierA prepared FFTW3 plan for transforming the mapData onto fCoeffs.
[in]noBinsThe number of bins as already pre-computed.
[in]binIndexingA map of pre-computed bin assignments for each reflection in the format as outputted by FFTW.
[in]bindataPre-allocated array of dimensions noBins x 12 serving as workspace for the bin summation and FSC computation. This array is modified by the function in case the caller would be interested in these results.
[in]binCountsPre-allocated array of dimension noBins serving to store the bin sizes for FSC computation. This array is modified by the function in case the caller would be interested in these results.
[in]fscByBinThis array will hold FSC values for each bin. This is useful in further computations, but could be internal for FSC only computation.
[out]fscThe FSC value found for the first (smallest) rotated map along the symmetry axis and the original map.

Definition at line 2472 of file ProSHADE_data.cpp.

2473 {
2474  //================================================ Ignore if already computed
2475  if ( sym[6] > -2.0 ) { return ( sym[6] ); }
2476 
2477  //================================================ Report progress
2478  std::stringstream ss2;
2479  ss2 << "Computing FSC for symmetry C" << sym[0] << " ( " << sym[1] << " ; " << sym[2] << " ; " << sym[3] << " ) with peak height " << sym[5];
2480  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss2.str(), settings->messageShift );
2481 
2482  //================================================ Initialise local variables
2483  proshade_double *rotMap;
2484 
2485  //================================================ For each rotation along the axis
2486  proshade_double averageFSC = 0.0;
2487  for ( proshade_double rotIter = 1.0; rotIter < sym[0]; rotIter += 1.0 )
2488  {
2489  //============================================ Get rotated map by the smallest fold angle along the symmetry axis
2490  this->rotateMapRealSpace ( sym[1], sym[2], sym[3], ( ( 2.0 * M_PI ) / sym[0] ) * rotIter, rotMap );
2491 
2492  //============================================ Get Fourier for the rotated map
2493  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { mapData[iter][0] = rotMap[iter]; mapData[iter][1] = 0.0; }
2494  fftw_execute ( *planForwardFourier );
2495 
2496  //============================================ Clean FSC computation memory
2497  for ( size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { for ( size_t valIt = 0; valIt < 12; valIt++ ) { bindata[binIt][valIt] = 0.0; } }
2498  for ( size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { binCounts[binIt] = 0; }
2499 
2500  //============================================ Compute FSC
2501  averageFSC += ProSHADE_internal_maths::computeFSC ( origCoeffs, fCoeffs, this->xDimIndices, this->yDimIndices, this->zDimIndices, noBins, binIndexing, bindata, binCounts, fscByBin );
2502 
2503  //============================================ Release memory
2504  delete[] rotMap;
2505  }
2506 
2507  //================================================ Convert sum to average
2508  averageFSC /= ( sym[0] - 1.0 );
2509 
2510  //================================================ Save result to the axis
2511  sym[6] = averageFSC;
2512 
2513  //================================================ Report progress
2514  std::stringstream ss3;
2515  ss3 << "FSC value is " << averageFSC << " .";
2516  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 5, ss3.str(), settings->messageShift );
2517 
2518  //================================================ Done
2519  return ( averageFSC );
2520 
2521 }

◆ computeFSC() [2/2]

proshade_double ProSHADE_internal_data::ProSHADE_data::computeFSC ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSym,
size_t  symIndex,
fftw_complex *  mapData,
fftw_complex *  fCoeffs,
fftw_complex *  origCoeffs,
fftw_plan *  planForwardFourier,
proshade_signed  noBins,
proshade_signed *  binIndexing,
proshade_double **&  bindata,
proshade_signed *&  binCounts,
proshade_double *&  fscByBin 
)

This function computes FSC for any given axis in the supplied CSym symmetry axes vector.

This function drives the FSC computation for symmetry detection. It iterates over all rotations specified by the symmetry axis (except for the I rotation) and for each of these, computes the map rotation accordingly. Next, it computes the Fourier transform of such rotated map and procceds to bin the coefficients according to the supplied key. From these bins, the sums required for finding the FSC between the rotated map and the original map can be obtained. Finally, averaging the FSC'c for all rotations the final FSC for the whole symmetry axis is obtained and returned.

Warning
This function does not really work on its own, it makes plethora of assumptions, the main ones being: Fourier transform of original (non-rotated) map is already computed and supplied, the FFTW plan for the Fourier transform of the rotated map is prepared and supplied, the workspace is allocated and supplied, the binning mask and number of bins is already determined ans supplied and so on. It would not be hard to remove these, but then repeated calls of this function would become much slower as all of these steps would have to be done for each call separately.
Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]CSymA vector of pointers to double arrays, each array being a single Cyclic symmetry entry.
[in]symIndexThe index of the symmetry axis in the CSym vector for which FSC should be computed.
[in]mapDataFFTW complex array which will be the input for the Fourier transform done by the planForwardFourier plan.
[in]fCoeffsFFTW complex array where the Fourier transform coefficients will be saved into by the planForwardFourier plan.
[in]origCoeffsFFTW complex array holding already compute Fourier transform of the non-rotated map.
[in]planForwardFourierA prepared FFTW3 plan for transforming the mapData onto fCoeffs.
[in]noBinsThe number of bins as already pre-computed.
[in]binIndexingA map of pre-computed bin assignments for each reflection in the format as outputted by FFTW.
[in]bindataPre-allocated array of dimensions noBins x 12 serving as workspace for the bin summation and FSC computation. This array is modified by the function in case the caller would be interested in these results.
[in]binCountsPre-allocated array of dimension noBins serving to store the bin sizes for FSC computation. This array is modified by the function in case the caller would be interested in these results.
[in]fscByBinThis array will hold FSC values for each bin. This is useful in further computations, but could be internal for FSC only computation.
[out]fscThe FSC value found for the first (smallest) rotated map along the symmetry axis and the original map.

Definition at line 2391 of file ProSHADE_data.cpp.

2392 {
2393  //================================================ Sanity check
2394  if ( symIndex >= CSym->size() )
2395  {
2396  std::cerr << "The supplied symmetry axes vector does not contain element number " << symIndex << ". Returning FSC 0.0." << std::endl;
2397  return ( -2.0 );
2398  }
2399 
2400  //================================================ Ignore if already computed
2401  if ( CSym->at(symIndex)[6] > -2.0 ) { return ( CSym->at(symIndex)[6] ); }
2402 
2403  //================================================ Report progress
2404  std::stringstream ss2;
2405  ss2 << "Computing FSC for symmetry C" << CSym->at(symIndex)[0] << " ( " << CSym->at(symIndex)[1] << " ; " << CSym->at(symIndex)[2] << " ; " << CSym->at(symIndex)[3] << " ) with peak height " << CSym->at(symIndex)[5];
2406  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss2.str(), settings->messageShift );
2407 
2408  //================================================ Initialise local variables
2409  proshade_double *rotMap;
2410 
2411  //================================================ For each rotation along the axis
2412  proshade_double averageFSC = 0.0;
2413  for ( proshade_double rotIter = 1.0; rotIter < CSym->at(symIndex)[0]; rotIter += 1.0 )
2414  {
2415  //============================================ Get rotated map by the smallest fold angle along the symmetry axis
2416  this->rotateMapRealSpace ( CSym->at(symIndex)[1], CSym->at(symIndex)[2], CSym->at(symIndex)[3], ( ( 2.0 * M_PI ) / CSym->at(symIndex)[0] ) * rotIter, rotMap );
2417 
2418  //============================================ Get Fourier for the rotated map
2419  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { mapData[iter][0] = rotMap[iter]; mapData[iter][1] = 0.0; }
2420  fftw_execute ( *planForwardFourier );
2421 
2422  //============================================ Compute FSC
2423  averageFSC += ProSHADE_internal_maths::computeFSC ( origCoeffs, fCoeffs, this->xDimIndices, this->yDimIndices, this->zDimIndices, noBins, binIndexing, bindata, binCounts, fscByBin );
2424 
2425  //============================================ Release memory
2426  delete[] rotMap;
2427  }
2428 
2429  //================================================ Convert sum to average
2430  averageFSC /= ( CSym->at(symIndex)[0] - 1.0 );
2431 
2432  //================================================ Save result to the axis
2433  CSym->at(symIndex)[6] = averageFSC;
2434 
2435  //================================================ Report progress
2436  std::stringstream ss3;
2437  ss3 << "FSC value is " << averageFSC << " .";
2438  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 5, ss3.str(), settings->messageShift );
2439 
2440  //================================================ Done
2441  return ( averageFSC );
2442 
2443 }

◆ computeRotationFunction()

void ProSHADE_internal_data::ProSHADE_data::computeRotationFunction ( ProSHADE_settings settings)

This function computes the self-rotation function for this structure.

This function assumes that the spherical harmonics have been computed for a data object. It can be then called on this object and it will proceed to compute the E matrices for this object against itself. From these "self E matrices", the function will generate the SO(3) transform coefficients and finally it will invert transform these coefficients back, thus getting the self-rotation function.

Parameters
[in]settingsA pointer to settings class containing all the information required for map self-rotation function computation.

Definition at line 41 of file ProSHADE_symmetry.cpp.

42 {
43  //================================================ Report progress
44  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting self-rotation function computation.", settings->messageShift );
45 
46  //================================================ Compute un-weighted E matrices and their weights
47  ProSHADE_internal_distances::computeEMatrices ( this, this, settings );
48 
49  //================================================ Normalise E matrices by the magnitudes
50  ProSHADE_internal_distances::normaliseEMatrices ( this, this, settings );
51 
52  //================================================ Generate SO(3) coefficients
54 
55  //================================================ Compute the inverse SO(3) Fourier Transform (SOFT) on the newly computed coefficients
57 
58  //================================================ Report completion
59  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Self-rotation function obtained.", settings->messageShift );
60 
61  //================================================ Done
62  return ;
63 
64 }

◆ computeRRPMatrices()

void ProSHADE_internal_data::ProSHADE_data::computeRRPMatrices ( ProSHADE_settings settings)

This function pre-computes the RRP matrices for a data object.

This function belongs to the ProSHADE_data class and its role is to set the objects internal variables properly and provide all the required calculations, so that the object will in the end have all the RRP matrices computed and be ready for the energy levels calculation.

Parameters
[in]settingsA pointer to settings class containing all the information required for the task.

Definition at line 59 of file ProSHADE_distances.cpp.

60 {
61  //================================================ Report progress
62  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Computing RRP matrices for structure " + this->fileName, settings->messageShift );
63 
64  //================================================ Allocate the memory
65  this->allocateRRPMemory ( );
66 
67  //================================================ Start computation: For each band (l)
68  proshade_double descValR = 0.0;
69  proshade_unsign arrPos1, arrPos2;
70  for ( proshade_unsign band = 0; band < this->maxShellBand; band++ )
71  {
72  //============================================ For each unique shell couple
73  for ( proshade_unsign shell1 = 0; shell1 < this->noSpheres; shell1++ )
74  {
75  //======================================== Does the band exist for this shell1?
76  if ( !ProSHADE_internal_distances::isBandWithinShell ( band, shell1, this->spheres ) )
77  {
78  for ( proshade_unsign shell2 = 0; shell2 < this->noSpheres; shell2++ )
79  {
80  this->rrpMatrices[band][shell1][shell2] = 0.0;
81  this->rrpMatrices[band][shell2][shell1] = 0.0;
82  }
83  continue;
84  }
85 
86  for ( proshade_unsign shell2 = 0; shell2 < this->noSpheres; shell2++ )
87  {
88  //==================================== Compute each values only once
89  if ( shell1 > shell2 ) { continue; }
90 
91  //==================================== Check if band exists for this shell2?
92  if ( !ProSHADE_internal_distances::isBandWithinShell ( band, shell2, this->spheres ) )
93  {
94  this->rrpMatrices[band][shell1][shell2] = 0.0;
95  this->rrpMatrices[band][shell2][shell1] = 0.0;
96  continue;
97  }
98 
99  //==================================== Initialise
100  descValR = 0.0;
101 
102  //==================================== Sum over order (m)
103  for ( proshade_unsign order = 0; order < static_cast< proshade_unsign > ( ( 2 * band ) + 1 ); order++ )
104  {
105  arrPos1 = static_cast< proshade_unsign > ( seanindex ( static_cast< int > ( order ) - static_cast<int > ( band ),
106  static_cast< int > ( band ), static_cast< int > ( this->spheres[shell1]->getLocalBandwidth() ) ) );
107  arrPos2 = static_cast< proshade_unsign > ( seanindex ( static_cast< int > ( order ) - static_cast< int > ( band ),
108  static_cast< int > ( band ), static_cast< int > ( this->spheres[shell2]->getLocalBandwidth() ) ) );
110  &this->sphericalHarmonics[shell1][arrPos1][1],
111  &this->sphericalHarmonics[shell2][arrPos2][0],
112  &this->sphericalHarmonics[shell2][arrPos2][1] );
113  }
114 
115  //==================================== Save the matrices
116  this->rrpMatrices[band][shell1][shell2] = descValR;
117  this->rrpMatrices[band][shell2][shell1] = descValR;
118  }
119  }
120  }
121 
122  //================================================ Report progress
123  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "RRP matrices successfully computed.", settings->messageShift );
124 
125  //================================================ Done
126  return ;
127 
128 }

◆ computeSphericalHarmonics()

void ProSHADE_internal_data::ProSHADE_data::computeSphericalHarmonics ( ProSHADE_settings settings)

This function computes the spherical harmonics decomposition for the whole structure.

This function is called to compute the spherical harmonics decomposition of the mapped data on every available sphere. This is done sphere-wise and there is some sub-optimal memory management stemming from different shells having different resolutions.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 1847 of file ProSHADE_data.cpp.

1848 {
1849  //================================================ Report progress
1850  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting spherical harmonics decomposition.", settings->messageShift );
1851 
1852  //================================================ Initialise memory
1853  this->sphericalHarmonics = new proshade_complex* [this->noSpheres];
1854  ProSHADE_internal_misc::checkMemoryAllocation ( this->sphericalHarmonics, __FILE__, __LINE__, __func__ );
1855  for ( proshade_unsign iter = 0; iter < this->noSpheres; iter++ )
1856  {
1857  this->sphericalHarmonics[iter] = new proshade_complex [(this->spheres[iter]->getLocalBandwidth() * 2) * (this->spheres[iter]->getLocalBandwidth() * 2)];
1858  ProSHADE_internal_misc::checkMemoryAllocation ( this->sphericalHarmonics[iter], __FILE__, __LINE__, __func__ );
1859  }
1860 
1861  //================================================ Compute the spherical harmonics
1862  for ( proshade_unsign iter = 0; iter < this->noSpheres; iter++ )
1863  {
1864  //============================================ Report progress
1865  std::stringstream ss;
1866  ss << "Now decomposing sphere " << iter << ". " << "( Band is: " << this->spheres[iter]->getLocalBandwidth() << ").";
1867  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss.str(), settings->messageShift );
1868 
1869  //============================================ Compute
1870  ProSHADE_internal_sphericalHarmonics::computeSphericalHarmonics ( this->spheres[iter]->getLocalBandwidth(), this->spheres[iter]->getMappedData(), this->sphericalHarmonics[iter] );
1871  }
1872 
1873  //================================================ Report completion
1874  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Spherical harmonics decomposition complete.", settings->messageShift );
1875 
1876  //======================================== Done
1877  return ;
1878 
1879 }

◆ computeTranslationMap()

void ProSHADE_internal_data::ProSHADE_data::computeTranslationMap ( ProSHADE_internal_data::ProSHADE_data staticStructure)

This function does the computation of the translation map and saves results internally.

This function takes the static structure, the optimal translation to which should be found and then it proceeds to compute the Fourier transform of both this and the static structures. It then combines the coefficients for translation function and computes the inverse Fourier transform, thus obtaining the translation function. This function is then saved, while all other internal data are deleted.

Parameters
[in]staticStructureA pointer to the data class object of the other ( static ) structure.

Definition at line 324 of file ProSHADE_overlay.cpp.

325 {
326  //================================================ Do this using Fourier!
327  fftw_complex *tmpIn1 = nullptr, *tmpOut1 = nullptr, *tmpIn2 = nullptr, *tmpOut2 = nullptr, *resOut = nullptr;
328  fftw_plan forwardFourierObj1, forwardFourierObj2, inverseFourierCombo;
329  proshade_unsign dimMult = staticStructure->getXDim() * staticStructure->getYDim() * staticStructure->getZDim();
330  ProSHADE_internal_overlay::allocateTranslationFunctionMemory ( tmpIn1, tmpOut1, tmpIn2, tmpOut2, this->translationMap, resOut, forwardFourierObj1, forwardFourierObj2, inverseFourierCombo, staticStructure->getXDim(), staticStructure->getYDim(), staticStructure->getZDim() );
331 
332  //================================================ Fill in input data
333  for ( proshade_unsign iter = 0; iter < dimMult; iter++ ) { tmpIn1[iter][0] = staticStructure->getMapValue ( iter ); tmpIn1[iter][1] = 0.0; }
334  for ( proshade_unsign iter = 0; iter < dimMult; iter++ ) { tmpIn2[iter][0] = this->getMapValue ( iter ); tmpIn2[iter][1] = 0.0; }
335 
336  //================================================ Calculate Fourier
337  fftw_execute ( forwardFourierObj1 );
338  fftw_execute ( forwardFourierObj2 );
339 
340  //================================================ Combine Fourier coeffs and invert
341  ProSHADE_internal_maths::combineFourierForTranslation ( tmpOut1, tmpOut2, resOut, staticStructure->getXDim(), staticStructure->getYDim(), staticStructure->getZDim() );
342  fftw_execute ( inverseFourierCombo );
343 
344  //================================================ Free memory
345  ProSHADE_internal_overlay::freeTranslationFunctionMemory ( tmpIn1, tmpOut1, tmpIn2, tmpOut2, resOut, forwardFourierObj1, forwardFourierObj2, inverseFourierCombo );
346 
347  //================================================ Done
348  return ;
349 
350 }

◆ convertRotationFunction()

void ProSHADE_internal_data::ProSHADE_data::convertRotationFunction ( ProSHADE_settings settings)

This function converts the self-rotation function of this structure to angle-axis representation.

This function creates a set of concentric spheres in a spherical co-ordinates space, where the radius is the angle-axis representation angle and the lattitude and longitude angles are the angle-axis representation axis vector. I.e. each of the spheres contains all angle-axis representation axes for a single given angle.

Then, it proceeds to interpolate the rotation function for each point in this space, thus effectivelly re-sampling the rotation function onto the required space.

Parameters
[in]settingsA pointer to settings class containing all the information required for map self-rotation function computation.

Definition at line 121 of file ProSHADE_symmetry.cpp.

122 {
123  //================================================ Report progress
124  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting self-rotation function conversion to angle-axis representation.", settings->messageShift );
125 
126  //================================================ Initialise variables
127  proshade_double shellSpacing = ( 2.0 * M_PI ) / static_cast<proshade_double> ( this->maxShellBand ) * 2.0;
128  std::vector< proshade_double > allPeakHeights;
129 
130  //================================================ Initialise the spheres
131  for ( proshade_unsign spIt = 1; spIt < ( this->maxShellBand * 2 ); spIt++ )
132  {
133  this->sphereMappedRotFun.emplace_back ( new ProSHADE_internal_spheres::ProSHADE_rotFun_sphere( static_cast<proshade_double> ( spIt ) * shellSpacing,
134  shellSpacing,
135  this->maxShellBand * 2,
136  static_cast<proshade_double> ( spIt ) * shellSpacing,
137  spIt - 1 ) );
138  }
139 
140  //================================================ Interpolate the rotation function onto the spheres
141  for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( sphereMappedRotFun.size() ); shIt++ )
142  {
143  //============================================ Report progress
144  std::stringstream hlpSS;
145  hlpSS << "Interpolating sphere " << shIt << " ( radius: " << this->sphereMappedRotFun.at(shIt)->getRadius() << " ).";
146  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str(), settings->messageShift );
147 
148  //============================================ Interpolate onto spheres
149  this->sphereMappedRotFun.at(shIt)->interpolateSphereValues ( this->getInvSO3Coeffs ( ) );
150  }
151 
152  //================================================ Report completion
153  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Self-rotation function converted to spherical angle-axis space.", settings->messageShift );
154  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Started peak detection on the angle-axis spheres.", settings->messageShift );
155 
156  //================================================ Find all peaks in the sphere grids
157  for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); shIt++ )
158  {
159  this->sphereMappedRotFun.at(shIt)->findAllPeaks ( static_cast< proshade_signed > ( settings->peakNeighbours ), &allPeakHeights );
160  }
161 
162  //================================================ Report progress
163  std::stringstream hlpSS;
164  hlpSS << "Detected " << allPeakHeights.size() << " peaks with any height.";
165  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str(), settings->messageShift );
166 
167  //================================================ Compute threshold for small peaks
168  proshade_double peakThres = std::max ( settings->minSymPeak, determinePeakThreshold ( allPeakHeights, settings->noIQRsFromMedianNaivePeak ) );
169 
170  //================================================ Report progress
171  std::stringstream hlpSS2;
172  hlpSS2 << "From these peaks, decided the threshold will be " << peakThres << " peak height.";
173  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, hlpSS2.str(), settings->messageShift );
174 
175  //================================================ Remove too small peaks
176  for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); shIt++ )
177  {
178  this->sphereMappedRotFun.at(shIt)->removeSmallPeaks ( peakThres );
179  }
180 
181  //================================================ Report progress
182  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "Peaks detected for all spheres.", settings->messageShift );
183 
184  //================================================ Done
185  return ;
186 
187 }

◆ createNewMapFromBounds()

void ProSHADE_internal_data::ProSHADE_data::createNewMapFromBounds ( ProSHADE_settings settings,
ProSHADE_data *&  newStr,
proshade_signed *  newBounds 
)

This function creates a new structure from the calling structure and new bounds values.

This function takes a pointer to uninitialised structure and fills it with the calling structure values adjusted for the new bounds. If the bounds are the same, the two structures should be identical except the file (the new structure does not have an input file associated) and the type (no type for the new structure). It can deal with both larger and smaller bounds than the original values.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.
[in]newStrA pointer reference to a new structure class which has all the same values except for the new bounds and adequately changed map.
[in]newBoundsA pointer to proshade_signed array of 6 storing the results - (0 = minX; 1 = maxX; 2 = minY; 3 = maxY; 4 - minZ; 5 = maxZ).

Definition at line 1374 of file ProSHADE_data.cpp.

1375 {
1376  //================================================ Report function start
1377  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Creating new structure according to the new bounds.", settings->messageShift );
1378 
1379  //================================================ Fill in basic info
1380  newStr->fileName = "N/A";
1381  newStr->fileType = ProSHADE_internal_io::MAP;
1382 
1383  //================================================ Fill in new structure values
1384  newStr->xDimIndices = static_cast< proshade_unsign > ( newBounds[1] ) - static_cast< proshade_unsign > ( newBounds[0] ) + 1;
1385  newStr->yDimIndices = static_cast< proshade_unsign > ( newBounds[3] ) - static_cast< proshade_unsign > ( newBounds[2] ) + 1;
1386  newStr->zDimIndices = static_cast< proshade_unsign > ( newBounds[5] ) - static_cast< proshade_unsign > ( newBounds[4] ) + 1;
1387 
1388  newStr->aAngle = this->aAngle;
1389  newStr->bAngle = this->aAngle;
1390  newStr->cAngle = this->aAngle;
1391 
1392  newStr->xDimSize = static_cast<proshade_single> ( newStr->xDimIndices ) * ( this->xDimSize / static_cast<proshade_single> ( this->xDimIndices ) );
1393  newStr->yDimSize = static_cast<proshade_single> ( newStr->yDimIndices ) * ( this->yDimSize / static_cast<proshade_single> ( this->yDimIndices ) );
1394  newStr->zDimSize = static_cast<proshade_single> ( newStr->zDimIndices ) * ( this->zDimSize / static_cast<proshade_single> ( this->zDimIndices ) );
1395 
1396  newStr->xGridIndices = newStr->xDimIndices;
1397  newStr->yGridIndices = newStr->yDimIndices;
1398  newStr->zGridIndices = newStr->zDimIndices;
1399 
1400  newStr->xAxisOrder = this->xAxisOrder;
1401  newStr->yAxisOrder = this->yAxisOrder;
1402  newStr->zAxisOrder = this->zAxisOrder;
1403 
1404  newStr->xAxisOrigin = this->xAxisOrigin + newBounds[0];
1405  newStr->yAxisOrigin = this->yAxisOrigin + newBounds[2];
1406  newStr->zAxisOrigin = this->zAxisOrigin + newBounds[4];
1407 
1408  newStr->xFrom = this->xFrom + newBounds[0];
1409  newStr->yFrom = this->yFrom + newBounds[2];
1410  newStr->zFrom = this->zFrom + newBounds[4];
1411 
1412  newStr->xTo = this->xTo - ( static_cast< proshade_signed > ( this->xDimIndices - 1 ) - newBounds[1] );
1413  newStr->yTo = this->yTo - ( static_cast< proshade_signed > ( this->yDimIndices - 1 ) - newBounds[3] );
1414  newStr->zTo = this->zTo - ( static_cast< proshade_signed > ( this->zDimIndices - 1 ) - newBounds[5] );
1415 
1416  //================================================ Allocate new structure map
1417  newStr->internalMap = new proshade_double[newStr->xDimIndices * newStr->yDimIndices * newStr->zDimIndices];
1418  ProSHADE_internal_misc::checkMemoryAllocation ( newStr->internalMap, __FILE__, __LINE__, __func__ );
1419 
1420  //================================================ Copy the map
1421  ProSHADE_internal_mapManip::copyMapByBounds ( newStr->xFrom, newStr->xTo, newStr->yFrom, newStr->yTo, newStr->zFrom, newStr->zTo,
1422  this->xFrom, this->yFrom, this->zFrom, newStr->yDimIndices, newStr->zDimIndices,
1423  this->xDimIndices, this->yDimIndices, this->zDimIndices, newStr->internalMap, this->internalMap );
1424 
1425  //================================================ Report function completion
1426  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "New structure created.", settings->messageShift );
1427 
1428  //================================================ Done
1429  return ;
1430 
1431 }

◆ deepCopyMap()

void ProSHADE_internal_data::ProSHADE_data::deepCopyMap ( proshade_double *&  saveTo,
proshade_signed  verbose 
)

This function copies the internal map into the supplied pointer, which it also allocates.

This function is provided so that the user can provide a pointer and have it allocated and filled with the map values.

Parameters
[in]saveToA pointer where the internal map should be deep copied into.
[in]verboseHow loud the run should be?

Definition at line 3447 of file ProSHADE_data.cpp.

3448 {
3449  //================================================ Sanity check
3450  if ( saveTo != nullptr )
3451  {
3452  ProSHADE_internal_messages::printWarningMessage ( verbose, "!!! ProSHADE WARNING !!! The deep copy pointer is not set to NULL. Cannot proceed and returning unmodified pointer.", "WB00040" );
3453  return ;
3454  }
3455 
3456  //================================================ Allocate the memory
3457  saveTo = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
3458 
3459  //================================================ Check memory allocation
3460  ProSHADE_internal_misc::checkMemoryAllocation ( saveTo, __FILE__, __LINE__, __func__ );
3461 
3462  //================================================ Copy internal map to the new pointer
3463  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
3464  {
3465  saveTo[iter] = this->internalMap[iter];
3466  }
3467 
3468  //================================================ Done
3469  return ;
3470 
3471 }

◆ detectSymmetryFromAngleAxisSpace()

void ProSHADE_internal_data::ProSHADE_data::detectSymmetryFromAngleAxisSpace ( ProSHADE_settings settings,
std::vector< proshade_double * > *  axes,
std::vector< std::vector< proshade_double > > *  allCs 
)

This function runs the symmetry detection algorithms on this structure using the angle-axis space and saving the results in the settings object.

This function firstly decides whether specific C symmetry was requested or not. This decision is important as knowing the required fold allows for a rather simplified algorithm to be applied. Thus, if specific fold is known, simplified algorithm will be used. Otherwise, this function will do a general search by firstly finding all cyclic point groups and then applying the dihedral, tetrahedral, octahedral and icosahedral searches.

Once complete, the function will save both, the vector of ProSHADE formatted array pointers as well as vector of vectors of doubles with the same information containing all detected cyclic point groups into the supplied vector pointers.

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]axesA vector to which all the axes of the recommended symmetry (if any) will be saved.
[in]allCsA vector to which all the detected cyclic symmetries will be saved into.

Definition at line 1907 of file ProSHADE_data.cpp.

1908 {
1909  //================================================ Modify axis tolerance and matrix tolerance by sampling, if required by user
1910  if ( settings->axisErrToleranceDefault )
1911  {
1912  settings->axisErrTolerance = std::min ( std::max ( 0.01, ( ( 2.0 * M_PI ) / static_cast< proshade_double > ( this->maxShellBand ) ) / 2.0 ), 0.05 );
1913  }
1914 
1915  //================================================ Prepare FSC computation memory and variables
1916  fftw_complex *mapData, *origCoeffs, *fCoeffs;
1917  fftw_plan planForwardFourier;
1918  proshade_double **bindata, *fscByBin;
1919  proshade_signed *binIndexing, *binCounts, noBins;
1920  this->prepareFSCFourierMemory ( mapData, origCoeffs, fCoeffs, binIndexing, &noBins, bindata, binCounts, &planForwardFourier, fscByBin );
1921 
1922  //================================================ If C was requested, we will do it immediately - this allows for a significant speed-up.
1923  if ( settings->requestedSymmetryType == "C" )
1924  {
1925  //============================================ Report progress
1926  std::stringstream hlpSS;
1927  hlpSS << "Starting detection of cyclic point group C" << settings->requestedSymmetryFold;
1928  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, hlpSS.str(), settings->messageShift );
1929 
1930  //============================================ Do simplified search only in the applicable data
1931  proshade_double symThres = 0.0;
1932  std::vector< proshade_double* > CSyms = this->findRequestedCSymmetryFromAngleAxis ( settings, settings->requestedSymmetryFold, &symThres );
1933 
1934  //============================================ Deal with the rotation function 0 1 0 PI issue
1935  bool possible010PIIssue = false;
1936  for ( size_t iter = 0; iter < CSyms.size(); iter++ ) { if ( ProSHADE_internal_maths::isAxisUnique ( &CSyms, 0.0, 1.0, 0.0, 2.0, 0.1 ) ) { possible010PIIssue = true; } }
1937  if ( possible010PIIssue )
1938  {
1939  proshade_double* addAxis = new proshade_double[7];
1940  addAxis[0] = 2.0; addAxis[1] = 0.0; addAxis[2] = 1.0; addAxis[3] = 0.0; addAxis[4] = M_PI; addAxis[5] = -999.9; addAxis[6] = -std::numeric_limits < proshade_double >::infinity();
1942  delete[] addAxis;
1943  }
1944 
1945  //============================================ Compute FSC for all possible axes
1946  for ( size_t cIt = 0; cIt < CSyms.size(); cIt++ ) { const FloatingPoint< proshade_double > lhs ( CSyms.at(cIt)[5] ), rhs ( -999.9 ); if ( ( CSyms.at(cIt)[5] > settings->peakThresholdMin ) || ( lhs.AlmostEquals ( rhs ) ) ) { this->computeFSC ( settings, &CSyms, cIt, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin ); } }
1947 
1948  //============================================ Sort by FSC
1949  std::sort ( CSyms.begin(), CSyms.end(), sortProSHADESymmetryByFSC );
1950 
1951  //============================================ Save the best axis as the recommended one
1952  if ( settings->detectedSymmetry.size() == 0 ) { if ( CSyms.size() > 0 ) { settings->setDetectedSymmetry ( CSyms.at(0) ); } }
1953  if ( CSyms.size() > 0 )
1954  {
1955  bool passedTests = false;
1956  for ( size_t cIt = 0; cIt < CSyms.size(); cIt++ )
1957  {
1958  if ( CSyms.at(0)[6] > settings->fscThreshold )
1959  {
1960  settings->setRecommendedSymmetry ( "C" );
1961  settings->setRecommendedFold ( settings->requestedSymmetryFold );
1962 
1964  this->saveDetectedSymmetries ( settings, &CSyms, allCs );
1965 
1966  passedTests = true;
1967  break;
1968  }
1969  }
1970 
1971  if ( !passedTests )
1972  {
1973  settings->setRecommendedSymmetry ( "" );
1974  settings->setRecommendedFold ( 0 );
1975  }
1976  }
1977  else
1978  {
1979  settings->setRecommendedSymmetry ( "" );
1980  settings->setRecommendedFold ( 0 );
1981  }
1982 
1983  //============================================ Release memory after FSC computation
1984  delete[] mapData;
1985  delete[] origCoeffs;
1986  delete[] fCoeffs;
1987  fftw_destroy_plan ( planForwardFourier );
1988  delete[] binIndexing;
1989  for (size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { delete[] bindata[binIt]; }
1990  delete[] bindata;
1991  delete[] binCounts;
1992  delete[] fscByBin;
1993 
1994  //============================================ Done
1995  return ;
1996  }
1997 
1998  //================================================ Report progress
1999  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting C symmetry detection.", settings->messageShift );
2000 
2001  //================================================ Detect cyclic symmetries
2002  std::vector< proshade_double* > CSyms = getCyclicSymmetriesListFromAngleAxis ( settings );
2003 
2004  //================================================ Report progress
2005  std::stringstream ss;
2006  ss << "Detected " << CSyms.size() << " C symmetries.";
2007  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, ss.str(), settings->messageShift );
2008 
2009  //================================================ Sanity check - was the rotation function mapped properly?
2010  if ( this->sphereMappedRotFun.size() < 1 )
2011  {
2012  throw ProSHADE_exception ( "Rotation function was not converted into angle-axis space.", "ES00062", __FILE__, __LINE__, __func__, "It seems that the convertRotationFunction() function was\n : not yet called. Therefore, there are no data to detect the\n : symmetry from; please call the convertRotationFunction()\n : function before the detectSymmetryFromAngleAxisSpace()\n : function." );
2013  }
2014 
2015  //================================================ If only C syms were requested (e.g. rotation centre detection), terminate here!
2016  if ( settings->requestedSymmetryType == "onlyC" )
2017  {
2018  //============================================ Prepare threshold
2019  proshade_double bestHistPeakStart = ProSHADE_internal_maths::findTopGroupSmooth ( &CSyms, 5, 0.01, 0.03, 9 );
2020  if ( bestHistPeakStart > settings->peakThresholdMin ) { bestHistPeakStart = settings->peakThresholdMin; }
2021 
2022  //============================================ Find FSCs for C syms
2023  for ( size_t cIt = 0; cIt < CSyms.size(); cIt++ )
2024  {
2025  //======================================== Check the peak height
2026  if ( CSyms.at(cIt)[5] < bestHistPeakStart ) { continue; }
2027 
2028  //======================================== Stop at some point - it is unlikely the true axis would be this far.
2029  if ( cIt > 15 ) { break; }
2030 
2031  //======================================== Compute FSC
2032  this->computeFSC ( settings, &CSyms, cIt, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2033  }
2034 
2035  //============================================ Save the detected Cs
2036  this->saveDetectedSymmetries ( settings, &CSyms, allCs );
2037 
2038  //============================================ Done
2039  return;
2040  }
2041 
2042  //================================================ Sanity check - was any symmetry requested?
2043  if ( ( settings->requestedSymmetryType != "" ) && ( settings->requestedSymmetryType != "C" ) && ( settings->requestedSymmetryType != "D" ) && ( settings->requestedSymmetryType != "T" ) && ( settings->requestedSymmetryType != "O" ) && ( settings->requestedSymmetryType != "I" ) )
2044  {
2045  throw ProSHADE_exception ( "Requested symmetry supplied, but not recognised.", "ES00032", __FILE__, __LINE__, __func__, "There are only the following value allowed for the\n : symmetry type request: \"C\", \"D\", \"T\", \"O\" and \"I\". Any\n : other value will result in this error." );
2046  }
2047 
2048  //================================================ Are we doing general search?
2049  if ( settings->requestedSymmetryType == "" )
2050  {
2051  //============================================ Run the symmetry detection functions for C, D, T, O and I symmetries
2052  std::vector< proshade_double* > DSyms = this->getDihedralSymmetriesList ( settings, &CSyms );
2053  std::vector< proshade_double* > ISyms;
2054  std::vector < std::vector< proshade_double* > > ISymsHlp = this->getPredictedIcosahedralSymmetriesList ( settings, &CSyms );
2055  std::vector< proshade_double* > OSyms = this->getPredictedOctahedralSymmetriesList ( settings, &CSyms );
2056  std::vector< proshade_double* > TSyms = this->getPredictedTetrahedralSymmetriesList ( settings, &CSyms );
2057 
2058  //============================================ Find which of the I groups is the correct one
2059  proshade_double fscMax = 0.0;
2060  size_t fscMaxInd = 0;
2061 
2062  for ( size_t icoIt = 0; icoIt < ISymsHlp.size(); icoIt++ )
2063  {
2064  //======================================== Is this a complete icosahedron?
2065  if ( ISymsHlp.at(icoIt).size() != 31 ) { continue; }
2066 
2067  //======================================== Initialise decision vars
2068  proshade_double fscVal = 0.0;
2069  proshade_double fscValAvg = 0.0;
2070 
2071  //======================================== For each axis
2072  for ( size_t aIt = 0; aIt < ISymsHlp.at(icoIt).size(); aIt++ )
2073  {
2074  //==================================== Match to CSyms
2075  proshade_signed matchedPos = ProSHADE_internal_symmetry::addAxisUnlessSame ( static_cast< proshade_unsign > ( ISymsHlp.at(icoIt).at(aIt)[0] ), ISymsHlp.at(icoIt).at(aIt)[1], ISymsHlp.at(icoIt).at(aIt)[2], ISymsHlp.at(icoIt).at(aIt)[3], ISymsHlp.at(icoIt).at(aIt)[5], ISymsHlp.at(icoIt).at(aIt)[6], &CSyms, settings->axisErrTolerance );
2076 
2077  //==================================== Compute FSC
2078  fscVal = this->computeFSC ( settings, &CSyms, static_cast< size_t > ( matchedPos ), mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2079  ISymsHlp.at(fscMaxInd).at(aIt)[6] = fscVal;
2080  fscValAvg += fscVal;
2081  }
2082 
2083  //======================================== Get FSC average over all axes
2084  fscValAvg /= 31.0;
2085 
2086  //======================================== Is this the best
2087  if ( fscValAvg > fscMax )
2088  {
2089  fscMax = fscValAvg;
2090  fscMaxInd = icoIt;
2091  }
2092 
2093  if ( settings->fastISearch ) { fscMaxInd = 0; break; }
2094  }
2095 
2096  //============================================ If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2097  if ( fscMax >= settings->fscThreshold )
2098  {
2099  //======================================== Add predicted axes to detected C axes list and also to the settings Icosahedral symmetry list
2100  for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ISymsHlp.at(fscMaxInd).size() ); retIt++ )
2101  {
2102  //==================================== Add the correct index to the settings object
2103  proshade_signed matchedPos = ProSHADE_internal_symmetry::addAxisUnlessSame ( static_cast< proshade_unsign > ( ISymsHlp.at(fscMaxInd).at(retIt)[0] ), ISymsHlp.at(fscMaxInd).at(retIt)[1], ISymsHlp.at(fscMaxInd).at(retIt)[2], ISymsHlp.at(fscMaxInd).at(retIt)[3], ISymsHlp.at(fscMaxInd).at(retIt)[5], ISymsHlp.at(fscMaxInd).at(retIt)[6], &CSyms, settings->axisErrTolerance );
2104  ProSHADE_internal_misc::addToUnsignVector ( &settings->allDetectedIAxes, static_cast < proshade_unsign > ( matchedPos ) );
2105 
2106  //==================================== Set ISyms for saving
2107  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &ISyms, ISymsHlp.at(fscMaxInd).at(retIt) );
2108  }
2109  }
2110 
2111  //============================================ Decide on recommended symmetry
2112  this->saveRecommendedSymmetry ( settings, &CSyms, &DSyms, &TSyms, &OSyms, &ISyms, axes, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2113  }
2114 
2115  if ( settings->requestedSymmetryType == "D" )
2116  {
2117  //============================================ Run only the D symmetry detection and search for requested fold
2118  std::vector< proshade_double* > DSyms = this->getDihedralSymmetriesList ( settings, &CSyms );
2119  this->saveRequestedSymmetryD ( settings, &DSyms, axes, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2120  }
2121 
2122  if ( settings->requestedSymmetryType == "T" )
2123  {
2124  //============================================ Run only the T symmetry detection
2125  std::vector< proshade_double* > TSyms = this->getPredictedTetrahedralSymmetriesList ( settings, &CSyms );
2126 
2127  if ( TSyms.size() == 7 )
2128  {
2129  //======================================== Initialise decision vars
2130  proshade_double fscVal = 0.0;
2131  proshade_double fscValAvg = 0.0;
2132 
2133  //======================================== Check if axes have high enough FSC and peak height
2134  for ( size_t tIt = 0; tIt < 7; tIt++ ) { if ( CSyms.at(settings->allDetectedTAxes.at(tIt))[5] > settings->peakThresholdMin ) { fscVal = this->computeFSC ( settings, &CSyms, settings->allDetectedTAxes.at(tIt), mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin ); fscValAvg += fscVal; } }
2135  fscValAvg /= 7.0;
2136 
2137  //======================================== If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2138  if ( fscValAvg >= ( settings->fscThreshold ) )
2139  {
2140  //==================================== The decision is T
2141  settings->setRecommendedSymmetry ( "T" );
2142  settings->setRecommendedFold ( 0 );
2143  for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedTAxes.size() ); it++ ) { ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSyms.at(settings->allDetectedTAxes.at(it)) ); }
2144  if ( settings->detectedSymmetry.size() == 0 ) { for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedTAxes.size() ); it++ ) { settings->setDetectedSymmetry ( CSyms.at(settings->allDetectedTAxes.at(it)) ); } }
2145  }
2146  }
2147  }
2148 
2149  if ( settings->requestedSymmetryType == "O" )
2150  {
2151  //============================================ Run only the O symmetry detection
2152  std::vector< proshade_double* > OSyms = this->getPredictedOctahedralSymmetriesList ( settings, &CSyms );
2153 
2154  if ( OSyms.size() == 13 )
2155  {
2156  //======================================== Initialise decision vars
2157  proshade_double fscVal = 0.0;
2158  proshade_double fscValAvg = 0.0;
2159 
2160  //======================================== Check if at least one C5 and one C3 with the correct angle have high FSC and peak height
2161  for ( size_t oIt = 0; oIt < 13; oIt++ ) { if ( CSyms.at(settings->allDetectedOAxes.at(oIt))[5] > settings->peakThresholdMin ) { fscVal = this->computeFSC ( settings, &CSyms, settings->allDetectedOAxes.at(oIt), mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin ); fscValAvg += fscVal; } }
2162  fscValAvg /= 13.0;
2163 
2164  //======================================== If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2165  if ( fscValAvg >= ( settings->fscThreshold ) )
2166  {
2167  //==================================== The decision is O
2168  settings->setRecommendedSymmetry ( "O" );
2169  settings->setRecommendedFold ( 0 );
2170  for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedOAxes.size() ); it++ ) { ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSyms.at(settings->allDetectedOAxes.at(it)) ); }
2171  if ( settings->detectedSymmetry.size() == 0 ) { for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedOAxes.size() ); it++ ) { settings->setDetectedSymmetry ( CSyms.at(settings->allDetectedOAxes.at(it)) ); } }
2172  }
2173  }
2174  }
2175 
2176  if ( settings->requestedSymmetryType == "I" )
2177  {
2178  //============================================ Find which of the I groups is the correct one
2179  proshade_double fscMax = 0.0;
2180  size_t fscMaxInd = 0;
2181  std::vector < std::vector< proshade_double* > > ISymsHlp = this->getPredictedIcosahedralSymmetriesList ( settings, &CSyms );
2182  std::vector< proshade_double* > ISyms;
2183 
2184  for ( size_t icoIt = 0; icoIt < ISymsHlp.size(); icoIt++ )
2185  {
2186  //======================================== Is this a complete icosahedron?
2187  if ( ISymsHlp.at(icoIt).size() != 31 ) { continue; }
2188 
2189  //======================================== Initialise decision vars
2190  proshade_double fscVal = 0.0;
2191  proshade_double fscValAvg = 0.0;
2192 
2193  //======================================== For each axis
2194  for ( size_t aIt = 0; aIt < ISymsHlp.at(icoIt).size(); aIt++ )
2195  {
2196  //==================================== Match to CSyms
2197  proshade_signed matchedPos = ProSHADE_internal_symmetry::addAxisUnlessSame ( static_cast< proshade_unsign > ( ISymsHlp.at(icoIt).at(aIt)[0] ), ISymsHlp.at(icoIt).at(aIt)[1], ISymsHlp.at(icoIt).at(aIt)[2], ISymsHlp.at(icoIt).at(aIt)[3], ISymsHlp.at(icoIt).at(aIt)[5], ISymsHlp.at(icoIt).at(aIt)[6], &CSyms, settings->axisErrTolerance );
2198 
2199  //==================================== Compute FSC
2200  fscVal = this->computeFSC ( settings, &CSyms, static_cast< size_t > ( matchedPos ), mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2201  ISymsHlp.at(fscMaxInd).at(aIt)[6] = fscVal;
2202  fscValAvg += fscVal;
2203  }
2204 
2205  //======================================== Get FSC average over all axes
2206  fscValAvg /= 31.0;
2207 
2208  //======================================== Is this the best
2209  if ( fscValAvg > fscMax )
2210  {
2211  fscMax = fscValAvg;
2212  fscMaxInd = icoIt;
2213  }
2214  }
2215 
2216  //============================================ If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2217  if ( fscMax >= ( settings->fscThreshold ) )
2218  {
2219  //======================================== Add predicted axes to detected C axes list and also to the settings Icosahedral symmetry list
2220  for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ISymsHlp.at(fscMaxInd).size() ); retIt++ )
2221  {
2222  //==================================== Add the correct index to the settings object
2223  proshade_signed matchedPos = ProSHADE_internal_symmetry::addAxisUnlessSame ( static_cast< proshade_unsign > ( ISymsHlp.at(fscMaxInd).at(retIt)[0] ), ISymsHlp.at(fscMaxInd).at(retIt)[1], ISymsHlp.at(fscMaxInd).at(retIt)[2], ISymsHlp.at(fscMaxInd).at(retIt)[3], ISymsHlp.at(fscMaxInd).at(retIt)[5], ISymsHlp.at(fscMaxInd).at(retIt)[6], &CSyms, settings->axisErrTolerance );
2224  ProSHADE_internal_misc::addToUnsignVector ( &settings->allDetectedIAxes, static_cast < proshade_unsign > ( matchedPos ) );
2225 
2226  //==================================== Set ISyms for saving
2227  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &ISyms, ISymsHlp.at(fscMaxInd).at(retIt) );
2228  }
2229  }
2230 
2231  //============================================ Delete all memory from ISymsHlp
2232  for ( size_t gIt = 0; gIt < ISymsHlp.size(); gIt++ ) { for ( size_t aIt = 0; aIt < ISymsHlp.at(gIt).size(); aIt++ ) { delete[] ISymsHlp.at(gIt).at(aIt); } }
2233 
2234  //============================================ If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2235  if ( fscMax >= ( settings->fscThreshold * 0.7 ) )
2236  {
2237  //======================================== The decision is I
2238  settings->setRecommendedSymmetry ( "I" );
2239  settings->setRecommendedFold ( 0 );
2240  for ( size_t it = 0; it < ISyms.size(); it++ ) { ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, ISyms.at(it) ); }
2241  if ( settings->detectedSymmetry.size() == 0 ) { for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedIAxes.size() ); it++ ) { settings->setDetectedSymmetry ( CSyms.at(settings->allDetectedIAxes.at(it)) ); } }
2242  }
2243  }
2244 
2245  //================================================ Save C symmetries to argument and if different from settings, to the settings as well
2246  this->saveDetectedSymmetries ( settings, &CSyms, allCs );
2247 
2248  //================================================ Release memory after FSC computation
2249  delete[] mapData;
2250  delete[] origCoeffs;
2251  delete[] fCoeffs;
2252  fftw_destroy_plan ( planForwardFourier );
2253  delete[] binIndexing;
2254  for (size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { delete[] bindata[binIt]; }
2255  delete[] bindata;
2256  delete[] binCounts;
2257 
2258  //================================================ Done
2259  return ;
2260 
2261 }

◆ figureIndexStartStop()

void ProSHADE_internal_data::ProSHADE_data::figureIndexStartStop ( void  )
protected

Function for determining iterator start and stop positions.

This function is called to set the xFrom, yFrom, ..., yTo and zTo iterator values for easier further calculations. It assumes that gemmi has read in the xFrom, yFrom and zFrom values already.

Definition at line 870 of file ProSHADE_data.cpp.

871 {
872  //================================================ Set ends to origin + size - 1
873  this->xTo = this->xFrom + static_cast< proshade_signed > ( this->xDimIndices ) - 1;
874  this->yTo = this->yFrom + static_cast< proshade_signed > ( this->yDimIndices ) - 1;
875  this->zTo = this->zFrom + static_cast< proshade_signed > ( this->zDimIndices ) - 1;
876 
877  //================================================ Done
878  return ;
879 
880 }

◆ findMapCOM()

void ProSHADE_internal_data::ProSHADE_data::findMapCOM ( void  )

This function finds the centre of mass of the internal map representation.

This function simply computes the centre of mass for the given ProSHADE_data object map in the "real space" (i.e. the space that counts Angstroms from the bottom left further corner). These are then saved into the ProSHADE_data object.

Definition at line 3535 of file ProSHADE_data.cpp.

3536 {
3537  //================================================ Initialise variables
3538  this->xCom = 0.0;
3539  this->yCom = 0.0;
3540  this->zCom = 0.0;
3541  proshade_double totNonZeroPoints = 0.0;
3542  proshade_signed mapIt = 0;
3543 
3544  //================================================ Compute COM from 0 ; 0 ; 0
3545  for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->xDimIndices ); xIt++ )
3546  {
3547  for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->yDimIndices ); yIt++ )
3548  {
3549  for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->zDimIndices ); zIt++ )
3550  {
3551  //==================================== Find map index
3552  mapIt = zIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( yIt + static_cast< proshade_signed > ( this->yDimIndices ) * xIt );
3553 
3554  //==================================== Use only positive density
3555  if ( this->internalMap[mapIt] <= 0.0 ) { continue; }
3556 
3557  //==================================== Compute Index COM
3558  this->xCom += this->internalMap[mapIt] * static_cast<proshade_double> ( xIt + this->xFrom );
3559  this->yCom += this->internalMap[mapIt] * static_cast<proshade_double> ( yIt + this->yFrom );
3560  this->zCom += this->internalMap[mapIt] * static_cast<proshade_double> ( zIt + this->zFrom );
3561  totNonZeroPoints += this->internalMap[mapIt];
3562  }
3563  }
3564  }
3565 
3566  this->xCom /= totNonZeroPoints;
3567  this->yCom /= totNonZeroPoints;
3568  this->zCom /= totNonZeroPoints;
3569 
3570  //================================================ Convert to real world
3571  this->xCom = static_cast< proshade_double > ( ( static_cast< proshade_single > ( this->xFrom ) * ( this->xDimSizeOriginal / static_cast< proshade_single > ( this->xDimIndicesOriginal ) ) ) +
3572  ( ( static_cast< proshade_single > ( this->xCom ) - static_cast< proshade_single > ( this->xFrom ) ) *
3573  ( static_cast< proshade_single > ( this->xDimSizeOriginal ) / static_cast< proshade_single > ( this->xDimIndicesOriginal ) ) ) );
3574  this->yCom = static_cast< proshade_double > ( ( static_cast< proshade_single > ( this->yFrom ) * ( this->yDimSizeOriginal / static_cast< proshade_single > ( this->yDimIndicesOriginal ) ) ) +
3575  ( ( static_cast< proshade_single > ( this->yCom ) - static_cast< proshade_single > ( this->yFrom ) ) *
3576  ( static_cast< proshade_single > ( this->yDimSizeOriginal ) / static_cast< proshade_single > ( this->yDimIndicesOriginal ) ) ) );
3577  this->zCom = static_cast< proshade_double > ( ( static_cast< proshade_single > ( this->zFrom ) * ( this->zDimSizeOriginal / static_cast< proshade_single > ( this->zDimIndicesOriginal ) ) ) +
3578  ( ( static_cast< proshade_single > ( this->zCom ) - static_cast< proshade_single > ( this->zFrom ) ) *
3579  ( static_cast< proshade_single > ( this->zDimSizeOriginal ) / static_cast< proshade_single > ( this->zDimIndicesOriginal ) ) ) );
3580 
3581  //================================================ Done
3582  return ;
3583 
3584 }

◆ findRequestedCSymmetryFromAngleAxis()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::findRequestedCSymmetryFromAngleAxis ( ProSHADE_settings settings,
proshade_unsign  fold,
proshade_double *  peakThres 
)

This function searches the angle-axis representation of the rotation function for a cyclic point group with given fold.

This function is a simplification of the getCyclicSymmetriesListFromAngleAxis() function, where this function does not map the whole rotation function, but rothar only to the spheres it knows it will required. Moreover, it does not search for all cyclic point groups, but only those which span all the spheres (angles) and therefore have the required fold.

In terms of operations, this function interpolates the rotation function values onto the spheres it requires, then it finds peaks and removes the small peaks, so that these can then be grouped. For each group which spans all the angles it then finds the index with highest sum of peak height over all spheres. It can then do the bi-cubic interpolation if requested. Finally, all the detected peaks are sorted by the peak height and returned.

Parameters
[in]settingsProSHADE_settings object containing all the settings for this run.
[in]foldThe fold which should be sought for by the function.
[in]peakThresThe threshold used to cut peaks.
[out]retVector of double pointers to arrays having the standard ProSHADE symmetry group structure.

Definition at line 2909 of file ProSHADE_symmetry.cpp.

2910 {
2911  //================================================ Initialise variables
2912  proshade_double soughtAngle;
2913  std::vector< proshade_double > allPeakHeights;
2914  std::vector< ProSHADE_internal_spheres::ProSHADE_rotFun_spherePeakGroup* > peakGroups;
2915  std::vector< proshade_double* > ret;
2916  bool newPeak;
2917 
2918  //================================================ Make sure we have a clean start
2919  this->sphereMappedRotFun.clear();
2920 
2921  //================================================ Convert rotation function to only the required angle-axis space spheres and find all peaks
2922  for ( proshade_double angIt = 1.0; angIt < static_cast < proshade_double > ( fold ); angIt += 1.0 )
2923  {
2924  //============================================ Figure the angles to form the symmetry
2925  soughtAngle = angIt * ( 2.0 * M_PI / static_cast<proshade_double> ( fold ) );
2926 
2927  //============================================ Create the angle-axis sphere with correct radius (angle)
2928  this->sphereMappedRotFun.emplace_back ( new ProSHADE_internal_spheres::ProSHADE_rotFun_sphere ( soughtAngle,
2929  M_PI / static_cast < proshade_double > ( this->maxShellBand ),
2930  this->maxShellBand * 2,
2931  soughtAngle,
2932  static_cast < proshade_unsign > ( angIt - 1.0 ) ) );
2933 
2934  //=========================================== Interpolate rotation function onto the sphere
2935  this->sphereMappedRotFun.at(static_cast < size_t > ( angIt - 1.0 ))->interpolateSphereValues ( this->getInvSO3Coeffs ( ) );
2936 
2937  //============================================ Find all peaks for this sphere
2938  this->sphereMappedRotFun.at(static_cast < size_t > ( angIt - 1.0 ))->findAllPeaks ( static_cast< proshade_signed > ( settings->peakNeighbours ), &allPeakHeights );
2939  }
2940 
2941  //============================================ Report progress
2942  std::stringstream hlpSS;
2943  hlpSS << "Found a total of " << std::pow ( static_cast< proshade_double > ( this->maxShellBand ) * 2.0 * ( static_cast< proshade_double > ( fold ) - 1.0 ), 2.0 ) - static_cast< proshade_double > ( allPeakHeights.size() ) << " non-peaks for thresholding.";
2944  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, hlpSS.str(), settings->messageShift );
2945 
2946  //================================================ Determine the threshold for significant peaks
2947  *peakThres = std::min ( settings->minSymPeak, determinePeakThreshold ( allPeakHeights, settings->noIQRsFromMedianNaivePeak ) );
2948 
2949  //============================================ Report progress
2950  std::stringstream hlpSS2;
2951  hlpSS2 << "Determined peak threshold " << *peakThres << ".";
2952  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, hlpSS2.str(), settings->messageShift );
2953 
2954  //================================================ Remove small peaks
2955  for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); shIt++ )
2956  {
2957  this->sphereMappedRotFun.at(shIt)->removeSmallPeaks ( *peakThres );
2958  }
2959 
2960  //================================================ Group peaks
2961  for ( proshade_unsign sphIt = 0; sphIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); sphIt++ )
2962  {
2963  //============================================ For each peak
2964  for ( proshade_unsign pkIt = 0; pkIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.at(sphIt)->getPeaks().size() ); pkIt++ )
2965  {
2966  //======================================== Check if peak belongs to an already detected peak group
2967  newPeak = true;
2968  for ( proshade_unsign pkGrpIt = 0; pkGrpIt < static_cast<proshade_unsign> ( peakGroups.size() ); pkGrpIt++ )
2969  {
2970  if ( peakGroups.at(pkGrpIt)->checkIfPeakBelongs ( static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).first ),
2971  static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).second ),
2972  sphIt, settings->axisErrTolerance, settings->verbose, settings->messageShift ) ) { newPeak = false; break; }
2973  }
2974 
2975  //======================================== If already added, go to next one
2976  if ( !newPeak ) { continue; }
2977 
2978  //======================================== If not, create a new group with this peak
2979  peakGroups.emplace_back ( new ProSHADE_internal_spheres::ProSHADE_rotFun_spherePeakGroup ( static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).first ),
2980  static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).second ),
2981  sphIt,
2982  this->sphereMappedRotFun.at(sphIt)->getAngularDim() ) );
2983  }
2984  }
2985 
2986  //================================================ For each peak group, look for the requested fold
2987  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( peakGroups.size() ); grIt++ )
2988  {
2989  //============================================ Report progress
2990  std::stringstream hlpSS3;
2991  hlpSS3 << "Now considering group with LAT " << peakGroups.at(grIt)->getLatFromIndices() << " - " << peakGroups.at(grIt)->getLatToIndices() << " and LON " << peakGroups.at(grIt)->getLonFromIndices() << " - " << peakGroups.at(grIt)->getLonToIndices() << " spanning spheres ";
2992  for ( proshade_unsign sphIt = 0; sphIt < static_cast<proshade_unsign> ( peakGroups.at(grIt)->getSpherePositions().size() ); sphIt++ ) { hlpSS3 << peakGroups.at(grIt)->getSpherePositions().at(sphIt) << " ; "; }
2993  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 5, hlpSS3.str(), settings->messageShift );
2994 
2995  //============================================ Find point groups in the peak group
2996  peakGroups.at(grIt)->findCyclicPointGroupsGivenFold ( this->sphereMappedRotFun, &ret, settings->useBiCubicInterpolationOnPeaks, fold, settings->verbose, settings->messageShift );
2997 
2998  //============================================ Release the memory
2999  delete peakGroups.at(grIt);
3000  }
3001 
3002  //================================================ Sort ret by peak height
3003  std::sort ( ret.begin(), ret.end(), sortProSHADESymmetryByPeak );
3004 
3005  //================================================ Done
3006  return ( ret );
3007 
3008 }

◆ getAllGroupElements() [1/2]

std::vector< std::vector< proshade_double > > ProSHADE_internal_data::ProSHADE_data::getAllGroupElements ( ProSHADE_settings settings,
std::vector< proshade_unsign >  axesList,
std::string  groupType = "",
proshade_double  matrixTolerance = 0.05 
)

This function returns the group elements as rotation matrices of any defined point group.

This function is essentially a wrapper for the overloaded version of this function. The purpose of this function is allow getting point group elements for axes detected in a particular structure.

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]axesListA vector of ints specifying which C axes from the full list are members of the group.
[in]groupTypeAn optional string specifying for which symmetry type the group elements are to be computed. Leave empty if you want to use the supplied axes without any questions being asked.
[in]matrixToleranceThe maximum allowed trace difference for two matrices to still be considered the same.
[out]valA vector containing a vector of 9 doubles (rotation matrix) for each group element for the requested group.

Definition at line 3151 of file ProSHADE_data.cpp.

3152 {
3153  //================================================ Initialise variables
3154  std::vector<std::vector< proshade_double > > ret = this->getAllGroupElements ( &settings->allDetectedCAxes, axesList, groupType, matrixTolerance );
3155 
3156  //================================================ Done
3157  return ( ret );
3158 
3159 }

◆ getAllGroupElements() [2/2]

std::vector< std::vector< proshade_double > > ProSHADE_internal_data::ProSHADE_data::getAllGroupElements ( std::vector< std::vector< proshade_double > > *  allCs,
std::vector< proshade_unsign >  axesList,
std::string  groupType = "",
proshade_double  matrixTolerance = 0.05 
)

This function returns the group elements as rotation matrices of any defined point group.

This function generates a list of all point group elements for any group defined by a set of cyclic point groups. The set is supplied using the first parameter for a larger set and the second parameter for specifying a subset of the first parameter set.

This function can generate appropriate elementes for all ProSHADE supported point group types (i.e. C, D, T, O and I) as well as for any supplied set of cyclic point groups (use the groupType value of "X").

Please note that the final set of point group elements will be checked for being a point group, i.e. for the fact that a product of any two members will be another already present member. If this condition is not met, error will be thrown. This poses some issues when the point group axes are slightly off, as this can lead to the point group check failing...

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]axesListA vector of ints specifying which C axes from the full list are members of the group.
[in]groupTypeAn optional string specifying for which symmetry type the group elements are to be computed. Leave empty if you want to use the supplied axes without any questions being asked.
[in]matrixToleranceThe maximum allowed trace difference for two matrices to still be considered the same.
[out]valA vector containing a vector of 9 doubles (rotation matrix) for each group element for the requested group.

Definition at line 3179 of file ProSHADE_data.cpp.

3180 {
3181  //================================================ Initialise variables
3182  std::vector<std::vector< proshade_double > > ret;
3183 
3184  //================================================ Select which symmetry type are we computing for
3185  if ( groupType == "C" )
3186  {
3187  //============================================ Sanity check
3188  axesToGroupTypeSanityCheck ( 1, static_cast< proshade_unsign > ( axesList.size() ), groupType );
3189 
3190  //============================================ Generate elements
3191  ret = computeGroupElementsForGroup ( allCs->at(axesList.at(0)).at(1),
3192  allCs->at(axesList.at(0)).at(2),
3193  allCs->at(axesList.at(0)).at(3),
3194  static_cast< proshade_signed > ( allCs->at(axesList.at(0)).at(0) ) );
3195 
3196  //============================================ Check the element to form a group
3197  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3198  else
3199  {
3200  throw ProSHADE_exception ( "Computed point group elements do not form a group.", "ES00060", __FILE__, __LINE__, __func__, "The supplied cyclic groups list does not form a group and\n : therefore such group's elements cannot be obtained. Please\n : check the cyclic groups list supplied to the\n : getAllGroupElements() function." );
3201  }
3202  }
3203  else if ( groupType == "D" )
3204  {
3205  //============================================ Sanity check
3206  axesToGroupTypeSanityCheck ( 2, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3207 
3208  //============================================ Generate elements for both axes
3209  std::vector<std::vector< proshade_double > > first = computeGroupElementsForGroup ( allCs->at(axesList.at(0)).at(1),
3210  allCs->at(axesList.at(0)).at(2),
3211  allCs->at(axesList.at(0)).at(3),
3212  static_cast< proshade_signed > ( allCs->at(axesList.at(0)).at(0) ) );
3213 
3214  std::vector<std::vector< proshade_double > > second = computeGroupElementsForGroup ( allCs->at(axesList.at(1)).at(1),
3215  allCs->at(axesList.at(1)).at(2),
3216  allCs->at(axesList.at(1)).at(3),
3217  static_cast< proshade_signed > ( allCs->at(axesList.at(1)).at(0) ) );
3218 
3219  //============================================ Join the element lists
3220  ret = joinElementsFromDifferentGroups ( &first, &second, matrixTolerance, true );
3221 
3222  //============================================ Check the element to form a group
3223  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3224  else
3225  {
3226  throw ProSHADE_exception ( "Computed point group elements do not form a group.", "ES00060", __FILE__, __LINE__, __func__, "The supplied cyclic groups list does not form a group and\n : therefore such group's elements cannot be obtained. Please\n : check the cyclic groups list supplied to the\n : getAllGroupElements() function." );
3227  }
3228  }
3229  else if ( groupType == "T" )
3230  {
3231  //============================================ Sanity check
3232  axesToGroupTypeSanityCheck ( 7, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3233 
3234  //============================================ Generate elements for all four C3 axes first
3235  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3236  {
3237  //======================================== If this is a C3 axis
3238  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3239  if ( lhs1.AlmostEquals ( rhs1 ) )
3240  {
3241  //==================================== Generate the elements
3242  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3243  allCs->at(axesList.at(grIt)).at(2),
3244  allCs->at(axesList.at(grIt)).at(3),
3245  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3246 
3247  //==================================== Join the elements to any already found
3248  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3249  }
3250  }
3251 
3252  //============================================ Generate elements for all three C2 axes second
3253  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3254  {
3255  //======================================== If this is a C3 axis
3256  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3257  if ( lhs1.AlmostEquals ( rhs1 ) )
3258  {
3259  //==================================== Generate the elements
3260  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3261  allCs->at(axesList.at(grIt)).at(2),
3262  allCs->at(axesList.at(grIt)).at(3),
3263  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3264 
3265  //==================================== Join the elements to any already found
3266  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3267  }
3268  }
3269 
3270  //============================================ Check the element to form a group
3271  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3272  else
3273  {
3274  throw ProSHADE_exception ( "Computed point group elements do not form a group.", "ES00060", __FILE__, __LINE__, __func__, "The supplied cyclic groups list does not form a group and\n : therefore such group's elements cannot be obtained. Please\n : check the cyclic groups list supplied to the\n : getAllGroupElements() function." );
3275  }
3276  }
3277  else if ( groupType == "O" )
3278  {
3279  //============================================ Sanity check
3280  axesToGroupTypeSanityCheck ( 13, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3281 
3282  //============================================ Generate elements for all three C4 axes first
3283  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3284  {
3285  //======================================== If this is a C3 axis
3286  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 4.0 );
3287  if ( lhs1.AlmostEquals ( rhs1 ) )
3288  {
3289  //==================================== Generate the elements
3290  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3291  allCs->at(axesList.at(grIt)).at(2),
3292  allCs->at(axesList.at(grIt)).at(3),
3293  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3294 
3295  //==================================== Join the elements to any already found
3296  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3297  }
3298  }
3299 
3300  //============================================ Generate elements for all four C3 axes first
3301  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3302  {
3303  //======================================== If this is a C3 axis
3304  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3305  if ( lhs1.AlmostEquals ( rhs1 ) )
3306  {
3307  //==================================== Generate the elements
3308  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3309  allCs->at(axesList.at(grIt)).at(2),
3310  allCs->at(axesList.at(grIt)).at(3),
3311  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3312 
3313  //==================================== Join the elements to any already found
3314  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3315  }
3316  }
3317 
3318  //============================================ Generate elements for all six C2 axes next
3319  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3320  {
3321  //======================================== If this is a C3 axis
3322  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3323  if ( lhs1.AlmostEquals ( rhs1 ) )
3324  {
3325  //==================================== Generate the elements
3326  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3327  allCs->at(axesList.at(grIt)).at(2),
3328  allCs->at(axesList.at(grIt)).at(3),
3329  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3330 
3331  //==================================== Join the elements to any already found
3332  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3333  }
3334  }
3335 
3336  //============================================ Check the element to form a group
3337  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3338  else
3339  {
3340  throw ProSHADE_exception ( "Computed point group elements do not form a group.", "ES00060", __FILE__, __LINE__, __func__, "The supplied cyclic groups list does not form a group and\n : therefore such group's elements cannot be obtained. Please\n : check the cyclic groups list supplied to the\n : getAllGroupElements() function." );
3341  }
3342  }
3343  else if ( groupType == "I" )
3344  {
3345  //============================================ Sanity check
3346  axesToGroupTypeSanityCheck ( 31, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3347 
3348  //============================================ Generate elements for all six C5 axes first
3349  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3350  {
3351  //======================================== If this is a C5 axis
3352  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 5.0 );
3353  if ( lhs1.AlmostEquals ( rhs1 ) )
3354  {
3355  //==================================== Generate the elements
3356  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3357  allCs->at(axesList.at(grIt)).at(2),
3358  allCs->at(axesList.at(grIt)).at(3),
3359  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3360 
3361  //==================================== Join the elements to any already found
3362  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3363  }
3364  }
3365 
3366  //============================================ Generate elements for all ten C3 axes next
3367  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3368  {
3369  //======================================== If this is a C3 axis
3370  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3371  if ( lhs1.AlmostEquals ( rhs1 ) )
3372  {
3373  //==================================== Generate the elements
3374  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3375  allCs->at(axesList.at(grIt)).at(2),
3376  allCs->at(axesList.at(grIt)).at(3),
3377  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3378 
3379  //==================================== Join the elements to any already found
3380  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3381  }
3382  }
3383 
3384  //============================================ Generate elements for all fifteen C2 axes lastly
3385  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3386  {
3387  //======================================== If this is a C3 axis
3388  const FloatingPoint< proshade_double > lhs1 ( allCs->at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3389  if ( lhs1.AlmostEquals ( rhs1 ) )
3390  {
3391  //==================================== Generate the elements
3392  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3393  allCs->at(axesList.at(grIt)).at(2),
3394  allCs->at(axesList.at(grIt)).at(3),
3395  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3396 
3397  //==================================== Join the elements to any already found
3398  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3399  }
3400  }
3401 
3402  //============================================ Check the element to form a group
3403  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3404  else
3405  {
3406  throw ProSHADE_exception ( "Computed point group elements do not form a group.", "ES00060", __FILE__, __LINE__, __func__, "The supplied cyclic groups list does not form a group and\n : therefore such group's elements cannot be obtained. Please\n : check the cyclic groups list supplied to the\n : getAllGroupElements() function." );
3407  }
3408  }
3409  else if ( groupType == "X" )
3410  {
3411  //============================================ User forced no checking for unspecified symmetry
3412  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3413  {
3414  //======================================== Compute group elements
3415  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( allCs->at(axesList.at(grIt)).at(1),
3416  allCs->at(axesList.at(grIt)).at(2),
3417  allCs->at(axesList.at(grIt)).at(3),
3418  static_cast< proshade_signed > ( allCs->at(axesList.at(grIt)).at(0) ) );
3419 
3420  //======================================== Join the elements to any already found
3421  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, true );
3422  }
3423 
3424  //============================================ Check the element to form a group
3425  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3426  else
3427  {
3428  throw ProSHADE_exception ( "Computed point group elements do not form a group.", "ES00060", __FILE__, __LINE__, __func__, "The supplied cyclic groups list does not form a group and\n : therefore such group's elements cannot be obtained. Please\n : check the cyclic groups list supplied to the\n : getAllGroupElements() function." );
3429  }
3430  }
3431  else
3432  {
3433  std::stringstream hlpSS;
3434  hlpSS << "Unknown symmetry type: >" << groupType << "<";
3435  throw ProSHADE_exception ( hlpSS.str().c_str(), "ES00058", __FILE__, __LINE__, __func__, "Function getAllGroupElements was called with symmetry type\n : value outside of the allowed values C, D, T, O, I\n : or empty for using all supplied axes." );
3436  }
3437 
3438 }

◆ getAnySphereRadius()

proshade_double ProSHADE_internal_data::ProSHADE_data::getAnySphereRadius ( proshade_unsign  shell)

This function allows access to the radius of any particular sphere.

Parameters
[out]XThe distance of the requested sphere to the centre of the coordinates.

Definition at line 3770 of file ProSHADE_data.cpp.

3771 {
3772  //================================================ Done
3773  return ( this->spheres[shell]->getShellRadius() );
3774 
3775 }

◆ getBestRotationMapPeaksEulerAngles()

std::vector< proshade_double > ProSHADE_internal_data::ProSHADE_data::getBestRotationMapPeaksEulerAngles ( ProSHADE_settings settings)

This function returns a vector of three floats, the three Euler angles of the best peak in the rotation map.

Parameters
[in]settingsA pointer to settings class containing all the information required for map overlay.
[out]valA vector of the Euler angles of the best peak in the rotation function map.

Definition at line 1300 of file ProSHADE_overlay.cpp.

1301 {
1302  //================================================ Initialise local variables
1303  std::vector < proshade_double > ret;
1304  proshade_double eulA, eulB, eulG;
1305 
1306  //================================================ Get inverse SO(3) map top peak Euler angle values
1308  this->getMaxBand() * 2,
1309  &eulA, &eulB, &eulG, settings );
1310 
1311  //================================================ Re-format to vector
1315 
1316  //================================================ Done
1317  return ( ret );
1318 
1319 }

◆ getBestTranslationMapPeaksAngstrom()

std::vector< proshade_double > ProSHADE_internal_data::ProSHADE_data::getBestTranslationMapPeaksAngstrom ( ProSHADE_internal_data::ProSHADE_data staticStructure)

This function gets the optimal translation vector and returns it as a standard library vector. It also applies the translation to the internal map.

Parameters
[in]staticStructureA pointer to the data class object of the other ( static ) structure.
[out]XA vector of doubles with the optimal translation vector in Angstroms.

Definition at line 250 of file ProSHADE_overlay.cpp.

251 {
252  //================================================ Initialise local variables
253  std::vector< proshade_double > ret;
254  proshade_double mapPeak = 0.0;
255  proshade_unsign xDimS = staticStructure->getXDim();
256  proshade_unsign yDimS = staticStructure->getYDim();
257  proshade_unsign zDimS = staticStructure->getZDim();
258  proshade_double trsX = 0.0, trsY = 0.0, trsZ = 0.0;
260  xDimS,
261  yDimS,
262  zDimS,
263  &trsX,
264  &trsY,
265  &trsZ,
266  &mapPeak );
267 
268  //================================================ Dont translate over half
269  if ( trsX > ( static_cast< proshade_double > ( xDimS ) / 2.0 ) ) { trsX = trsX - static_cast< proshade_double > ( xDimS ); }
270  if ( trsY > ( static_cast< proshade_double > ( yDimS ) / 2.0 ) ) { trsY = trsY - static_cast< proshade_double > ( yDimS ); }
271  if ( trsZ > ( static_cast< proshade_double > ( zDimS ) / 2.0 ) ) { trsZ = trsZ - static_cast< proshade_double > ( zDimS ); }
272 
273  //================================================ Convert the map positions onto translation in Angstroms and save the results
274  ProSHADE_internal_overlay::computeTranslationsFromPeak ( staticStructure, this, &trsX, &trsY, &trsZ );
275 
276  this->originalPdbTransX = trsX;
277  this->originalPdbTransY = trsY;
278  this->originalPdbTransZ = trsZ;
279 
280  proshade_single xMov = static_cast< proshade_single > ( -trsX );
281  proshade_single yMov = static_cast< proshade_single > ( -trsY );
282  proshade_single zMov = static_cast< proshade_single > ( -trsZ );
283 
284  //================================================ Save results as vector
285  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast<proshade_double> ( -xMov ) );
286  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast<proshade_double> ( -yMov ) );
287  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast<proshade_double> ( -zMov ) );
288 
289  //================================================ Save original from variables for PDB output
290  this->mapMovFromsChangeX = static_cast<proshade_double> ( this->xFrom );
291  this->mapMovFromsChangeY = static_cast<proshade_double> ( this->yFrom );
292  this->mapMovFromsChangeZ = static_cast<proshade_double> ( this->zFrom );
293 
294  //================================================ Move the map
295  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
296  this->getXFromPtr(), this->getXToPtr(),
297  this->getYFromPtr(), this->getYToPtr(),
298  this->getZFromPtr(), this->getZToPtr(),
299  this->getXAxisOrigin(), this->getYAxisOrigin(), this->getZAxisOrigin() );
300 
302  this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
303  static_cast< proshade_signed > ( this->getXDim() ), static_cast< proshade_signed > ( this->getYDim() ), static_cast< proshade_signed > ( this->getZDim() ) );
304 
305  //================================================ Keep only the change in from and to variables
306  this->mapMovFromsChangeX = static_cast<proshade_double> ( this->xFrom ) - this->mapMovFromsChangeX;
307  this->mapMovFromsChangeY = static_cast<proshade_double> ( this->yFrom ) - this->mapMovFromsChangeY;
308  this->mapMovFromsChangeZ = static_cast<proshade_double> ( this->zFrom ) - this->mapMovFromsChangeZ;
309 
310  //================================================ Done
311  return ( ret );
312 
313 }

◆ getComparisonBand()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getComparisonBand ( void  )

This function allows access to the maximum band for the comparison.

Parameters
[out]XThe bandwidth used for this comparison.

Definition at line 3869 of file ProSHADE_data.cpp.

3870 {
3871  //================================================ Done
3872  return ( this->maxCompBand );
3873 
3874 }

◆ getCyclicSymmetriesListFromAngleAxis()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::getCyclicSymmetriesListFromAngleAxis ( ProSHADE_settings settings)

This function obtains a list of all C symmetries from the angle-axis space mapped rotation function values.

This function oversees the full search for cyclic point groups in the self-rotation function. It starts with finding all prime numbers up to the user specified limit. It then checks for each of the prime numbers whether there is a cyclic point group with fold equal to the prime number.

If any such point groups are found, the function searches for nultiples of these folds, making use of the fact that any structure with cyclic point group of fold n must also contain a point group of fold n/2 if n/2 is an integer. In this manner, cyclic point group with any fold can be found using a small number of specific fold searches, thus eliminating the need to determine which folds should be considered.

Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[out]retA vector of arrays containing all detected cyclic point groups in the standard ProSHADE format, i.e. [0] = fold, [1] = x-axis, [2] = y-axis, [3] = z-axis, [4] = angle, [5] = average peak height.

Definition at line 2770 of file ProSHADE_symmetry.cpp.

2771 {
2772  //================================================ Initialise variables
2773  std::vector< proshade_unsign > primes = ProSHADE_internal_maths::findAllPrimes ( settings->maxSymmetryFold );
2774  std::vector< proshade_double* > ret, tmpHolder;
2775  std::vector< proshade_unsign > testedFolds;
2776  proshade_double symThres;
2777  proshade_unsign foldToTest;
2778  bool foldDone, anyNewSyms = true;
2779 
2780  //================================================ For each found prime number in the limit
2781  for ( proshade_unsign prIt = 0; prIt < static_cast< proshade_unsign > ( primes.size() ); prIt++ )
2782  {
2783  //============================================ Report progress
2784  std::stringstream hlpSS;
2785  hlpSS << "Searching for prime fold symmetry C" << primes.at(prIt) << ".";
2786  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str(), settings->messageShift );
2787 
2788  //============================================ Get all symmetries for this prime fold
2789  std::vector< proshade_double* > prSyms = this->findRequestedCSymmetryFromAngleAxis ( settings, primes.at(prIt), &symThres );
2790 
2791  //============================================ Save the detected C symmetries
2792  for ( size_t axIt = 0; axIt < prSyms.size(); axIt++ )
2793  {
2794  //======================================== Is this symmetry passing the threshold?
2795  if ( prSyms.at(axIt)[5] >= symThres )
2796  {
2797  //==================================== Add this symmetry to final list
2798  if ( ProSHADE_internal_maths::isAxisUnique ( &ret, prSyms.at(axIt), settings->axisErrTolerance, true ) )
2799  {
2800  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &ret, prSyms.at(axIt) );
2801  }
2802  }
2803 
2804  //======================================== Release memory
2805  delete[] prSyms.at(axIt);
2806  }
2807  }
2808 
2809  //================================================ Was anything found?
2810  if ( ret.size() < 1 ) { return ( ret ); }
2811 
2812  //================================================ Check for prime symmetry fold multiples
2813  while ( anyNewSyms )
2814  {
2815  //============================================ Initialise new iteration
2816  anyNewSyms = false;
2817 
2818  //============================================ For each passing symmetry, look if there are any combinations of symmetries that would contain it
2819  for ( proshade_unsign axIt1 = 0; axIt1 < static_cast< proshade_unsign > ( ret.size() ); axIt1++ )
2820  {
2821  for ( proshade_unsign axIt2 = 0; axIt2 < static_cast< proshade_unsign > ( ret.size() ); axIt2++ )
2822  {
2823  //==================================== Initialise iteration
2824  foldToTest = static_cast< proshade_unsign > ( ret.at(axIt1)[0] * ret.at(axIt2)[0] );
2825  if ( foldToTest > settings->maxSymmetryFold ) { continue; }
2826 
2827  //==================================== Was this fold tested already?
2828  foldDone = false;
2829  for ( proshade_unsign fIt = 0; fIt < static_cast< proshade_unsign > ( testedFolds.size() ); fIt++ ) { if ( testedFolds.at(fIt) == foldToTest ) { foldDone = true; break; } }
2830  if ( foldDone ) { continue; }
2831  else { ProSHADE_internal_misc::addToUnsignVector ( &testedFolds, foldToTest ); }
2832 
2833  //==================================== Report progress
2834  std::stringstream hlpSS2;
2835  hlpSS2 << "Searching for fold combination of detected folds " << ret.at(axIt1)[0] << " and " << ret.at(axIt2)[0] << ", i.e. C" << foldToTest << ".";
2836  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS2.str(), settings->messageShift );
2837 
2838  //==================================== Get all symmetries for this fold
2839  std::vector< proshade_double* > prSyms = this->findRequestedCSymmetryFromAngleAxis ( settings, foldToTest, &symThres );
2840 
2841  //==================================== For each detected group with the required fold
2842  for ( size_t newAxIt = 0; newAxIt < prSyms.size(); newAxIt++ )
2843  {
2844  if ( prSyms.at(newAxIt)[5] >= symThres )
2845  {
2846  //================================ Add to detected axes
2847  if ( ProSHADE_internal_maths::isAxisUnique ( &ret, prSyms.at(newAxIt), settings->axisErrTolerance, true ) )
2848  {
2849  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &tmpHolder, prSyms.at(newAxIt) );
2850  }
2851  }
2852 
2853  //==================================== Release memory
2854  delete[] prSyms.at(newAxIt);
2855  }
2856  }
2857  }
2858 
2859  //============================================ Add newly found groups and repeat if need be
2860  if ( tmpHolder.size() > 0 )
2861  {
2862  for ( proshade_unsign tmpIt = 0; tmpIt < static_cast< proshade_unsign > ( tmpHolder.size() ); tmpIt++ )
2863  {
2864  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &ret, tmpHolder.at(tmpIt) );
2865  delete[] tmpHolder.at(tmpIt);
2866  }
2867 
2868  anyNewSyms = true;
2869  tmpHolder.clear ( );
2870  }
2871  }
2872 
2873  //================================================ Sort the vector
2874  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymHlpInv );
2875 
2876  //================================================ Done
2877  return ( ret );
2878 }

◆ getDihedralSymmetriesList()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::getDihedralSymmetriesList ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSymList 
)

This function obtains a list of all D symmetries from already computed C symmetries list.

This function simply returns a vector of C symmetry pairs which are perpendicular to each other (and therefore form dihedral symmetry). The vector contains arrays of 12 double numbers with the following format: [0] = Fold of axis 1; [1] = X-axis of axis 1; [2] Y-axis of axis 1; [3] = Z-axis of axis 1; [4] = angle of axis 1; [5] = average peak height of axis 1; [6] = Fold of axis 2; [7] = X-axis of axis 2; [8] Y-axis of axis 2; [9] = Z-axis of axis 2; [10] = angle of axis 2; [11] = average peak height of axis 2. Note that the larger fold axis is listed first in this format.

Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[in]CSymListA vector containing the already detected Cyclic symmetries.

Definition at line 302 of file ProSHADE_symmetry.cpp.

303 {
304  //================================================ Initialise variables
305  std::vector< proshade_double* > ret;
306  proshade_double dotProduct;
307 
308  //================================================ Report progress
309  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting D symmetry detection.", settings->messageShift );
310 
311  //================================================If not enough axes, just end here
312  if ( CSymList->size() < 2 ) { return ( ret ); }
313 
314  //================================================ For each unique pair of axes
315  for ( proshade_unsign ax1 = 0; ax1 < static_cast<proshade_unsign> ( CSymList->size() ); ax1++ )
316  {
317  //============================================ Ignore small axes
318  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(ax1)[5] ), rhs1 ( -999.9 );
319  if ( ( CSymList->at(ax1)[5] < settings->minSymPeak ) && !( lhs1.AlmostEquals ( rhs1 ) ) ) { continue; }
320 
321  for ( proshade_unsign ax2 = 1; ax2 < static_cast<proshade_unsign> ( CSymList->size() ); ax2++ )
322  {
323  //======================================= Use unique pairs only
324  if ( ax1 >= ax2 ) { continue; }
325 
326  //======================================== Ignore small axes
327  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(ax2)[5] ), rhs2 ( -999.9 );
328  if ( ( CSymList->at(ax2)[5] < settings->minSymPeak ) && !( lhs2.AlmostEquals ( rhs2 ) ) ) { continue; }
329 
330  //======================================= Compute the dot product
331  dotProduct = ProSHADE_internal_maths::computeDotProduct ( &CSymList->at(ax1)[1], &CSymList->at(ax1)[2],
332  &CSymList->at(ax1)[3], &CSymList->at(ax2)[1],
333  &CSymList->at(ax2)[2], &CSymList->at(ax2)[3] );
334 
335  //======================================== If close to zero, these two axes are perpendicular
336  if ( std::abs( dotProduct ) < settings->axisErrTolerance )
337  {
338  //==================================== Save
339  if ( CSymList->at(ax1)[0] >= CSymList->at(ax2)[0] )
340  {
341  ProSHADE_internal_symmetry::saveDSymmetry ( &ret, CSymList, ax1, ax2 );
342 
343  std::vector< proshade_unsign > DSymInd;
347 
348  }
349  else
350  {
351  ProSHADE_internal_symmetry::saveDSymmetry ( &ret, CSymList, ax2, ax1 );
352 
353  std::vector< proshade_unsign > DSymInd;
357  }
358  }
359  }
360  }
361 
362  //================================================ Report progress
363  std::stringstream hlpSS;
364  hlpSS << "Detected " << ret.size() << " D symmetries.";
365  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, hlpSS.str(), settings->messageShift );
366 
367  //================================================ Done
368  return ( ret );
369 
370 }

◆ getEMatrixByBand()

proshade_complex ** ProSHADE_internal_data::ProSHADE_data::getEMatrixByBand ( proshade_unsign  band)

This function allows access to E matrix for a particular band.

Parameters
[in]bandThe band for which the E matrix subset order * order should be returned.
[out]XPointer to pointer of complex matrix with dimensions order * order of the E matrices.

Definition at line 3817 of file ProSHADE_data.cpp.

3818 {
3819  //================================================ Done
3820  return ( this->eMatrices[band] );
3821 
3822 }

◆ getEMatrixValue()

void ProSHADE_internal_data::ProSHADE_data::getEMatrixValue ( proshade_unsign  band,
proshade_unsign  order1,
proshade_unsign  order2,
proshade_double *  valueReal,
proshade_double *  valueImag 
)

This function allows access to E matrix by knowing the band, order1 and order2 indices.

Parameters
[in]bandThe band for which the E matrix value should be returned.
[in]order1The first order for which the E matrix value should be returned.
[in]order2The second order for which the E matrix value should be returned.
[in]valueRealThe proshade_double number pointer to where the real part of the value will be saved.
[in]valueImagThe proshade_double number pointer to where the imaginary part of the value will be saved.

Definition at line 3832 of file ProSHADE_data.cpp.

3833 {
3834  //================================================ Set pointer
3835  *valueReal = this->eMatrices[band][order1][order2][0];
3836  *valueImag = this->eMatrices[band][order1][order2][1];
3837 
3838  //================================================ Done
3839  return ;
3840 
3841 }

◆ getIcosahedralSymmetriesList()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::getIcosahedralSymmetriesList ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSymList 
)

This function obtains a list of all I symmetry axes from the already computed C symmetries list.

This function starts by checking if there is a pair of C3 and C4 symmetries with the octahedron dihedral angle ( acos ( 1/sqrt(3) ) ). If so, it will then assume existence of octahedral symmetry and it will search for three C4 axes, four C3 axes and six C2 axes with the correct angle to each other and within the group. If all required axes are detected, it will return a list of 13 axes, otherwise it will return empty or shorter list. Automated missing symmetry axis detection is also included.

Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[in]CSymListA vector containing the already detected Cyclic symmetries.

Definition at line 1808 of file ProSHADE_symmetry.cpp.

1809 {
1810  //================================================ Initialise variables
1811  std::vector< proshade_double* > ret;
1812 
1813  //================================================ Report progress
1814  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting I symmetry detection.", settings->messageShift );
1815 
1816  //================================================ Are the basic requirements for icosahedral symmetry met?
1818  {
1819  //============================================ Search for all the symmetry axes
1820  ProSHADE_internal_symmetry::findIcos6C5s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
1821  if ( ret.size() != 6 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
1822 
1823  ProSHADE_internal_symmetry::findIcos10C3s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
1824  if ( ret.size() != 16 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
1825 
1826  ProSHADE_internal_symmetry::findIcos15C2s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
1827  if ( ret.size() != 31 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
1828  else
1829  {
1830  //======================================== Sort ret by fold
1831  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymInvFoldHlp );
1832 
1833  //======================================== Save indices
1834  for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
1835  {
1836  for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
1837  {
1838  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(csIt)[0] ), rhs1 ( ret.at(retIt)[0] );
1839  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(csIt)[1] ), rhs2 ( ret.at(retIt)[1] );
1840  const FloatingPoint< proshade_double > lhs3 ( CSymList->at(csIt)[2] ), rhs3 ( ret.at(retIt)[2] );
1841  const FloatingPoint< proshade_double > lhs4 ( CSymList->at(csIt)[3] ), rhs4 ( ret.at(retIt)[3] );
1842  const FloatingPoint< proshade_double > lhs5 ( CSymList->at(csIt)[4] ), rhs5 ( ret.at(retIt)[4] );
1843  const FloatingPoint< proshade_double > lhs6 ( CSymList->at(csIt)[5] ), rhs6 ( ret.at(retIt)[5] );
1844  if ( lhs1.AlmostEquals ( rhs1 ) &&
1845  lhs2.AlmostEquals ( rhs2 ) &&
1846  lhs3.AlmostEquals ( rhs3 ) &&
1847  lhs4.AlmostEquals ( rhs4 ) &&
1848  lhs5.AlmostEquals ( rhs5 ) &&
1849  lhs6.AlmostEquals ( rhs6 ) )
1850  {
1852  }
1853  }
1854  }
1855  }
1856  }
1857 
1858  //================================================ Report progress
1859  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "I symmetry detection complete.", settings->messageShift );
1860 
1861  //================================================ Done
1862  return ( ret );
1863 
1864 }

◆ getImagEMatrixValuesForLM()

void ProSHADE_internal_data::ProSHADE_data::getImagEMatrixValuesForLM ( proshade_signed  band,
proshade_signed  order1,
double *  eMatsLMImag,
int  len 
)

This function fills the input array with the imaginary E matrix values for particular band and order1 (l as opposed to l').

Parameters
[in]bandThe band for which the imaginary E matrix values are requested.
[in]orderThe order for which the imaginary E matrix values are requested.
[in]eMatsLMImagThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4208 of file ProSHADE_data.cpp.

4209 {
4210  //================================================ Save the data into the output array
4211  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4212  {
4213  eMatsLMImag[iter] = static_cast<double> ( this->eMatrices[band][order1][iter][1] );
4214  }
4215 
4216  //================================================ Done
4217  return ;
4218 
4219 }

◆ getImagRotFunction()

void ProSHADE_internal_data::ProSHADE_data::getImagRotFunction ( double *  rotFunImag,
int  len 
)

This function fills the input array with the imaginary rotation function values.

Parameters
[in]rotFunImagThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4295 of file ProSHADE_data.cpp.

4296 {
4297  //================================================ Save the data into the output array
4298  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4299  {
4300  rotFunImag[iter] = static_cast<double> ( this->so3CoeffsInverse[iter][1] );
4301  }
4302 
4303  //================================================ Done
4304  return ;
4305 
4306 }

◆ getImagSO3Coeffs()

void ProSHADE_internal_data::ProSHADE_data::getImagSO3Coeffs ( double *  so3CoefsImag,
int  len 
)

This function fills the input array with the imaginary SO(3) coefficient values.

Parameters
[in]so3CoefsImagThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4244 of file ProSHADE_data.cpp.

4245 {
4246  //================================================ Save the data into the output array
4247  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4248  {
4249  so3CoefsImag[iter] = static_cast<double> ( this->so3Coeffs[iter][1] );
4250  }
4251 
4252  //================================================ Done
4253  return ;
4254 
4255 }

◆ getImagSphHarmValue()

proshade_double * ProSHADE_internal_data::ProSHADE_data::getImagSphHarmValue ( proshade_unsign  band,
proshade_unsign  order,
proshade_unsign  shell 
)

This function allows access to the private internal imaginary spherical harmonics values.

Parameters
[out]XPointer to the value of the internal private spherical harmonics imaginary value of the given index.

Definition at line 3757 of file ProSHADE_data.cpp.

3758 {
3759  //================================================ Done
3760  return ( &this->sphericalHarmonics[shell][seanindex ( static_cast< int > ( order ) - static_cast< int > ( band ),
3761  static_cast< int > ( band ),
3762  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ) )][1] );
3763 
3764 }

◆ getImagTranslationFunction()

void ProSHADE_internal_data::ProSHADE_data::getImagTranslationFunction ( double *  trsFunImag,
int  len 
)

This function fills the input array with the imaginary translation function values.

Parameters
[in]trsFunImagThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4331 of file ProSHADE_data.cpp.

4332 {
4333  //================================================ Save the data into the output array
4334  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4335  {
4336  trsFunImag[iter] = static_cast<double> ( this->translationMap[iter][1] );
4337  }
4338 
4339  //================================================ Done
4340  return ;
4341 
4342 }

◆ getIntegrationWeight()

proshade_double ProSHADE_internal_data::ProSHADE_data::getIntegrationWeight ( void  )

This function allows access to the integration weight for the object.

Parameters
[out]XThe integration weight for the object or 0.0 if not yet computed.

Definition at line 3781 of file ProSHADE_data.cpp.

3782 {
3783  //================================================ Done
3784  return ( this->integrationWeight );
3785 
3786 }

◆ getInternalMap()

proshade_double *& ProSHADE_internal_data::ProSHADE_data::getInternalMap ( void  )

This function allows access to the first map array value address.

Parameters
[out]internalMapPointer to the first position in the internal map array.

Definition at line 4049 of file ProSHADE_data.cpp.

4050 {
4051  //================================================ Return the requested value
4052  return ( this->internalMap );
4053 }

◆ getInvSO3Coeffs()

proshade_complex * ProSHADE_internal_data::ProSHADE_data::getInvSO3Coeffs ( void  )

This function allows access to the inverse SO(3) coefficients array.

Parameters
[out]XThe internal inverse SO(3) coefficients array variable.

Definition at line 3847 of file ProSHADE_data.cpp.

3848 {
3849  //================================================ Done
3850  return ( this->so3CoeffsInverse );
3851 
3852 }

◆ getMapCOMProcessChange()

std::vector< proshade_double > ProSHADE_internal_data::ProSHADE_data::getMapCOMProcessChange ( void  )

This function allows access to the translation caused by structure processing.

Parameters
[out]mapCOMProcessChangeVector of the distances in Angstroms that the structure has been moved internally.

Definition at line 4069 of file ProSHADE_data.cpp.

4070 {
4071  //================================================ Initialise local variables
4072  std::vector< proshade_double > ret;
4073 
4074  //================================================ Save the values
4078 
4079  //================================================ Return the requested value
4080  return ( ret );
4081 }

◆ getMapValue()

proshade_double ProSHADE_internal_data::ProSHADE_data::getMapValue ( proshade_unsign  pos)

This function returns the internal map representation value of a particular array position.

Parameters
[in]posThe position in the map array, of which the value should be returned.
[out]XThe internal map representation value at position pos.

Definition at line 3601 of file ProSHADE_data.cpp.

3602 {
3603  //================================================ Return the value
3604  return ( this->internalMap[pos] );
3605 }

◆ getMaxBand()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getMaxBand ( void  )

This function returns the maximum band value for the object.

Parameters
[out]XThe largest number of bands used in any shell of the object.

Definition at line 3611 of file ProSHADE_data.cpp.

3612 {
3613  //================================================ Return the value
3614  return ( this->maxShellBand );
3615 }

◆ getMaxSpheres()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getMaxSpheres ( void  )

This function returns the number of spheres which contain the whole object.

Parameters
[out]XThe total number of spheres to which the structure is mapped.

Definition at line 3590 of file ProSHADE_data.cpp.

3591 {
3592  //================================================ Return the value
3593  return ( this->noSpheres );
3594 }

◆ getNoRecommendedSymmetryAxes()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getNoRecommendedSymmetryAxes ( ProSHADE_settings settings)

This function returns the number of detected recommended symmetry axes.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.
[out]valThe length of the recommended symmetry axes vector.

Definition at line 4407 of file ProSHADE_data.cpp.

4408 {
4409  //================================================ Return the value
4410  return ( static_cast<proshade_unsign> ( settings->detectedSymmetry.size() ) );
4411 }

◆ getOctahedralSymmetriesList()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::getOctahedralSymmetriesList ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSymList 
)

This function obtains a list of all O symmetry axes from the already computed C symmetries list.

This function starts by checking if there is a pair of C3 and C4 symmetries with the octahedron dihedral angle ( acos ( 1/sqrt(3) ) ). If so, it will then assume existence of octahedral symmetry and it will search for three C4 axes, four C3 axes and six C2 axes with the correct angle to each other and within the group. If all required axes are detected, it will return a list of 13 axes, otherwise it will return empty or shorter list. Automated missing symmetry axis detection is also included.

Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[in]CSymListA vector containing the already detected Cyclic symmetries.

Definition at line 1204 of file ProSHADE_symmetry.cpp.

1205 {
1206  //================================================ Initialise variables
1207  std::vector< proshade_double* > ret;
1208 
1209  //================================================ Report progress
1210  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting O symmetry detection.", settings->messageShift );
1211 
1212  //================================================ Are the basic requirements for tetrahedral symmetry met?
1213  if ( ProSHADE_internal_symmetry::detectOctahedralSymmetry ( CSymList, settings->axisErrTolerance, settings->minSymPeak ) )
1214  {
1215  //============================================ Search for all the symmetry axes
1216  ProSHADE_internal_symmetry::findOcta3C4s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
1217  if ( ret.size() != 3 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
1218 
1219  ProSHADE_internal_symmetry::findOcta4C3s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
1220  if ( ret.size() != 7 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
1221 
1222  ProSHADE_internal_symmetry::findOcta6C2s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
1223  if ( ret.size() != 13 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
1224  else
1225  {
1226  for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
1227  {
1228  for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
1229  {
1230  //======================================== Sort ret by fold
1231  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymInvFoldHlp );
1232 
1233  //======================================== Save indices
1234  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(csIt)[0] ), rhs1 ( ret.at(retIt)[0] );
1235  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(csIt)[1] ), rhs2 ( ret.at(retIt)[1] );
1236  const FloatingPoint< proshade_double > lhs3 ( CSymList->at(csIt)[2] ), rhs3 ( ret.at(retIt)[2] );
1237  const FloatingPoint< proshade_double > lhs4 ( CSymList->at(csIt)[3] ), rhs4 ( ret.at(retIt)[3] );
1238  const FloatingPoint< proshade_double > lhs5 ( CSymList->at(csIt)[4] ), rhs5 ( ret.at(retIt)[4] );
1239  const FloatingPoint< proshade_double > lhs6 ( CSymList->at(csIt)[5] ), rhs6 ( ret.at(retIt)[5] );
1240  if ( lhs1.AlmostEquals ( rhs1 ) &&
1241  lhs2.AlmostEquals ( rhs2 ) &&
1242  lhs3.AlmostEquals ( rhs3 ) &&
1243  lhs4.AlmostEquals ( rhs4 ) &&
1244  lhs5.AlmostEquals ( rhs5 ) &&
1245  lhs6.AlmostEquals ( rhs6 ) )
1246  {
1248  }
1249  }
1250  }
1251  }
1252  }
1253 
1254  //================================================ Report progress
1255  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "O symmetry detection complete.", settings->messageShift );
1256 
1257  //================================================ Done
1258  return ( ret );
1259 
1260 }

◆ getOverlayRotationFunction()

void ProSHADE_internal_data::ProSHADE_data::getOverlayRotationFunction ( ProSHADE_settings settings,
ProSHADE_internal_data::ProSHADE_data obj2 
)

This function computes the overlay rotation function (i.e. the correlation function in SO(3) space).

This function assumes it is called from the object to which the rotation function is to be assigned to (presumably the moving rather than static structure). It starts by computing the E matrices, normalising these using the Patterson-like normalisation, generating SO(3) coefficients from the E matrices and finally computing their inverse SOFT transform to get the rotation function.

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]obj2A pointer to the data class object of the other ( static ) structure.

Definition at line 35 of file ProSHADE_overlay.cpp.

36 {
37  //================================================ Report progress
38  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting rotation function computation.", settings->messageShift );
39 
40  //================================================ Compute un-weighted E matrices and their weights
41  ProSHADE_internal_distances::computeEMatrices ( obj2, this, settings );
42 
43  //================================================ Normalise E matrices by the magnitudes
44  ProSHADE_internal_distances::normaliseEMatrices ( obj2, this, settings );
45 
46  //================================================ Generate SO(3) coefficients
48 
49  //================================================ Compute the inverse SO(3) Fourier Transform (SOFT) on the newly computed coefficients
51 
52  //================================================ Report completion
53  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Rotation function obtained.", settings->messageShift );
54 
55  //================================================ Done
56  return ;
57 
58 }

◆ getPredictedIcosahedralSymmetriesList()

std::vector< std::vector< proshade_double * > > ProSHADE_internal_data::ProSHADE_data::getPredictedIcosahedralSymmetriesList ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSymList 
)

This function predicts a list of all I symmetry axes from the already computed C symmetries list.

This function starts by checking if there is a pair of C3 and C5 symmetries with the icosahedron dihedral angle ( acos( std::sqrt ( ( 1.0 + 2.0 / std::sqrt ( 5.0 ) ) / 3.0 ) ) ). If found, it calls the predictIcosAxes() function, which uses the knowledge of the two axes (C5 and C3) which are closest to the dihedral angle to find the best rotation matrix matching a pre-computed icosahedron model to the detected axes. After rotating the model, the model axes become the predicted axes for the structure and their peak heights are then computed. Once complete, all the predicted axes are in the ret variable.

Warning
This function does not check if the correct number of C axes was found, it is assumed this will be checked when the determination of which symmetry was found.
Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[in]CSymListA vector containing the already detected Cyclic symmetries.
[out]retA vector of all the detected axes in the standard ProSHADE format with height either the detected value (for the detected ones) or 0 for the predicted ones.

Definition at line 1880 of file ProSHADE_symmetry.cpp.

1881 {
1882  //================================================ Initialise variables
1883  std::vector< std::vector< proshade_double* > > ret;
1884 
1885  //================================================ Report progress
1886  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting I symmetry prediction.", settings->messageShift );
1887 
1888  //================================================ Are the basic requirements for icosahedral symmetry met?
1890  {
1891  //============================================ Generate the rest of the axes
1892  ProSHADE_internal_symmetry::predictIcosAxes ( CSymList, &ret, settings->axisErrTolerance, settings->minSymPeak );
1893 
1894  //============================================ For each possible axes pair
1895  for ( size_t pIt = 0; pIt < ret.size(); pIt++ )
1896  {
1897  //======================================== Get heights for the predicted axes
1898  ProSHADE_internal_symmetry::findPredictedAxesHeights ( &(ret.at(pIt)), this, settings );
1899  }
1900  }
1901 
1902  //================================================ Sort by best peak height sum
1903  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortISymByPeak );
1904 
1905  //================================================ Report progress
1906  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "I symmetry prediction complete.", settings->messageShift );
1907 
1908  //================================================ Done
1909  return ( ret );
1910 
1911 }

◆ getPredictedOctahedralSymmetriesList()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::getPredictedOctahedralSymmetriesList ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSymList 
)

This function predicts a list of all O symmetry axes from the already computed C symmetries list.

This function starts by checking if there is a pair of C3 and C4 symmetries with the octahedron dihedral angle ( acos( ( 1.0 / sqrt ( 3.0 ) ) ) ). If found, it calls the predictOctaAxes() function, which uses the knowledge of the two axes (C4 and C3) which are closest to the dihedral angle to find the best rotation matrix matching a pre-computed octahedron model to the detected axes. After rotating the model, the model axes become the predicted axes for the structure and their peak heights are then computed. Once complete, all the predicted axes are in the ret variable.

Warning
This function does not check if the correct number of C axes was found, it is assumed this will be checked when the determination of which symmetry was found.
Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[in]CSymListA vector containing the already detected Cyclic symmetries.
[out]retA vector of all the detected axes in the standard ProSHADE format with height either the detected value (for the detected ones) or 0 for the predicted ones.

Definition at line 1927 of file ProSHADE_symmetry.cpp.

1928 {
1929  //================================================ Initialise variables
1930  std::vector< proshade_double* > ret;
1931 
1932  //================================================ Report progress
1933  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting O symmetry prediction.", settings->messageShift );
1934 
1935  //================================================ Are the basic requirements for icosahedral symmetry met?
1936  if ( ProSHADE_internal_symmetry::detectOctahedralSymmetry ( CSymList, settings->axisErrTolerance, settings->minSymPeak ) )
1937  {
1938  //============================================ Generate the rest of the axes
1939  ProSHADE_internal_symmetry::predictOctaAxes ( CSymList, &ret, settings->axisErrTolerance, settings->minSymPeak );
1940 
1941  //============================================ Get heights for the predicted axes
1943 
1944  //============================================ Add predicted axes to detected C axes list and also to the settings Icosahedral symmetry list
1945  for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ret.size() ); retIt++ )
1946  {
1947  proshade_signed matchedPos = ProSHADE_internal_symmetry::addAxisUnlessSame ( static_cast< proshade_unsign > ( ret.at(retIt)[0] ), ret.at(retIt)[1], ret.at(retIt)[2], ret.at(retIt)[3], ret.at(retIt)[5], CSymList, settings->axisErrTolerance );
1948  ProSHADE_internal_misc::addToUnsignVector ( &settings->allDetectedOAxes, static_cast < proshade_unsign > ( matchedPos ) );
1949  }
1950  }
1951 
1952  //================================================ Report progress
1953  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "O symmetry prediction complete.", settings->messageShift );
1954 
1955  //================================================ Done
1956  return ( ret );
1957 
1958 }

◆ getPredictedTetrahedralSymmetriesList()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::getPredictedTetrahedralSymmetriesList ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSymList 
)

This function predicts a list of all T symmetry axes from the already computed C symmetries list.

This function starts by checking if there is a pair of C3 and C2 symmetries with the tetrahedron dihedral angle ( acos( ( 1.0 / sqrt ( 3.0 ) ) ). If found, it calls the predictTetraAxes() function, which uses the knowledge of the two axes (C3 and C2) which are closest to the dihedral angle to find the best rotation matrix matching a pre-computed tetrhedron model to the detected axes. After rotating the model, the model axes become the predicted axes for the structure and their peak heights are then computed. Once complete, all the predicted axes are in the ret variable.

Warning
This function does not check if the correct number of C axes was found, it is assumed this will be checked when the determination of which symmetry was found.
Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[in]CSymListA vector containing the already detected Cyclic symmetries.
[out]retA vector of all the detected axes in the standard ProSHADE format with height either the detected value (for the detected ones) or 0 for the predicted ones.

Definition at line 3505 of file ProSHADE_symmetry.cpp.

3506 {
3507  //================================================ Initialise variables
3508  std::vector< proshade_double* > ret;
3509 
3510  //================================================ Report progress
3511  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting T symmetry prediction.", settings->messageShift );
3512 
3513  //================================================ Are the basic requirements for icosahedral symmetry met?
3515  {
3516  //============================================ Generate the rest of the axes
3517  ProSHADE_internal_symmetry::predictTetraAxes ( CSymList, &ret, settings->axisErrTolerance, settings->minSymPeak );
3518 
3519  //============================================ Get heights for the predicted axes
3521 
3522  //============================================ Add predicted axes to detected C axes list and also to the settings Icosahedral symmetry list
3523  for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ret.size() ); retIt++ )
3524  {
3525  proshade_signed matchedPos = ProSHADE_internal_symmetry::addAxisUnlessSame ( static_cast< proshade_unsign > ( ret.at(retIt)[0] ), ret.at(retIt)[1], ret.at(retIt)[2], ret.at(retIt)[3], ret.at(retIt)[5], CSymList, settings->axisErrTolerance );
3526  ProSHADE_internal_misc::addToUnsignVector ( &settings->allDetectedTAxes, static_cast < proshade_unsign > ( matchedPos ) );
3527  }
3528  }
3529 
3530  //================================================ Report progress
3531  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "T symmetry prediction complete.", settings->messageShift );
3532 
3533  //================================================ Done
3534  return ( ret );
3535 
3536 }

◆ getRealEMatrixValuesForLM()

void ProSHADE_internal_data::ProSHADE_data::getRealEMatrixValuesForLM ( proshade_signed  band,
proshade_signed  order1,
double *  eMatsLMReal,
int  len 
)

This function fills the input array with the real E matrix values for particular band and order1 (l as opposed to l').

Parameters
[in]bandThe band for which the real E matrix values are requested.
[in]orderThe order for which the real E matrix values are requested.
[in]eMatsLMRealThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4188 of file ProSHADE_data.cpp.

4189 {
4190  //================================================ Save the data into the output array
4191  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4192  {
4193  eMatsLMReal[iter] = static_cast<double> ( this->eMatrices[band][order1][iter][0] );
4194  }
4195 
4196  //================================================ Done
4197  return ;
4198 
4199 }

◆ getRealRotFunction()

void ProSHADE_internal_data::ProSHADE_data::getRealRotFunction ( double *  rotFunReal,
int  len 
)

This function fills the input array with the real rotation function values.

Parameters
[in]rotFunRealThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4277 of file ProSHADE_data.cpp.

4278 {
4279  //================================================ Save the data into the output array
4280  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4281  {
4282  rotFunReal[iter] = static_cast<double> ( this->so3CoeffsInverse[iter][0] );
4283  }
4284 
4285  //================================================ Done
4286  return ;
4287 
4288 }

◆ getRealSO3Coeffs()

void ProSHADE_internal_data::ProSHADE_data::getRealSO3Coeffs ( double *  so3CoefsReal,
int  len 
)

This function fills the input array with the real SO(3) coefficient values.

Parameters
[in]so3CoefsRealThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4226 of file ProSHADE_data.cpp.

4227 {
4228  //================================================ Save the data into the output array
4229  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4230  {
4231  so3CoefsReal[iter] = static_cast<double> ( this->so3Coeffs[iter][0] );
4232  }
4233 
4234  //================================================ Done
4235  return ;
4236 
4237 }

◆ getRealSphHarmValue()

proshade_double * ProSHADE_internal_data::ProSHADE_data::getRealSphHarmValue ( proshade_unsign  band,
proshade_unsign  order,
proshade_unsign  shell 
)

This function allows access to the private internal real spherical harmonics values.

Parameters
[out]XPointer to the value of the internal private spherical harmonics real value of the given index.

Definition at line 3744 of file ProSHADE_data.cpp.

3745 {
3746  //================================================ Done
3747  return ( &this->sphericalHarmonics[shell][seanindex ( static_cast< int > ( order ) - static_cast< int > ( band ),
3748  static_cast< int > ( band ),
3749  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ) )][0] );
3750 
3751 }

◆ getRealTranslationFunction()

void ProSHADE_internal_data::ProSHADE_data::getRealTranslationFunction ( double *  trsFunReal,
int  len 
)

This function fills the input array with the real translation function values.

Parameters
[in]trsFunRealThe array to which the values will be written into.
[in]lenThe lenght of the array.

Definition at line 4313 of file ProSHADE_data.cpp.

4314 {
4315  //================================================ Save the data into the output array
4316  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4317  {
4318  trsFunReal[iter] = static_cast<double> ( this->translationMap[iter][0] );
4319  }
4320 
4321  //================================================ Done
4322  return ;
4323 
4324 }

◆ getReBoxBoundaries()

void ProSHADE_internal_data::ProSHADE_data::getReBoxBoundaries ( ProSHADE_settings settings,
proshade_signed *&  ret 
)

This function finds the boundaries enclosing positive map values and adds some extra space.

This function firstly finds the boundaries which enclose the positive map values and then it proceeds to add a given amount of space to all dimensions (positive and negative) to make sure the map does not end exactly at the bounds. It returns the new boundaries in the ret variable if they are smaller than the original bounds, or just the original bounds in case decrease was not achieved.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.
[in]retA pointer to proshade_signed array of 6 storing the results - (0 = minX; 1 = maxX; 2 = minY; 3 = maxY; 4 - minZ; 5 = maxZ).

Definition at line 1316 of file ProSHADE_data.cpp.

1317 {
1318  //================================================ Report function start
1319  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Finding new boundaries.", settings->messageShift );
1320 
1321  //================================================ If same bounds as first one are required, test if possible and return these instead
1322  if ( settings->useSameBounds && ( this->inputOrder != 0 ) )
1323  {
1324  for ( proshade_unsign iter = 0; iter < 6; iter++ ) { ret[iter] = settings->forceBounds[iter]; }
1325  }
1326  //================================================ In this case, bounds need to be found de novo
1327  else
1328  {
1329  //============================================ Find the non-zero bounds
1331  static_cast< proshade_signed > ( this->xDimIndices ),
1332  static_cast< proshade_signed > ( this->yDimIndices ),
1333  static_cast< proshade_signed > ( this->zDimIndices ),
1334  ret );
1335 
1336  //============================================ Add the extra space
1338  this->xDimSize, this->yDimSize, this->zDimSize, ret, settings->boundsExtraSpace );
1339 
1340  //============================================ Beautify boundaries
1342 
1343  //============================================ Report function results
1344  std::stringstream ssHlp;
1345  ssHlp << "New boundaries are: " << ret[1] - ret[0] + 1 << " x " << ret[3] - ret[2] + 1 << " x " << ret[5] - ret[4] + 1;
1346  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, ssHlp.str(), settings->messageShift );
1347 
1348  //============================================ If need be, save boundaries to be used for all other structure
1349  if ( settings->useSameBounds && ( this->inputOrder == 0 ) )
1350  {
1351  for ( proshade_unsign iter = 0; iter < 6; iter++ ) { settings->forceBounds[iter] = ret[iter]; }
1352  }
1353  }
1354 
1355  //================================================ Report function completion
1356  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "New boundaries determined.", settings->messageShift );
1357 
1358  //================================================ Done
1359  return ;
1360 
1361 }

◆ getRecommendedSymmetryFold()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getRecommendedSymmetryFold ( ProSHADE_settings settings)

This function simply returns the detected recommended symmetry fold.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 4395 of file ProSHADE_data.cpp.

4396 {
4397  //================================================ Return the value
4398  return ( settings->recommendedSymmetryFold );
4399 
4400 }

◆ getRecommendedSymmetryType()

std::string ProSHADE_internal_data::ProSHADE_data::getRecommendedSymmetryType ( ProSHADE_settings settings)

This function simply returns the detected recommended symmetry type.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 4384 of file ProSHADE_data.cpp.

4385 {
4386  //================================================ Return the value
4387  return ( settings->recommendedSymmetryType );
4388 
4389 }

◆ getRotMatrixFromRotFunInds()

void ProSHADE_internal_data::ProSHADE_data::getRotMatrixFromRotFunInds ( proshade_signed  aI,
proshade_signed  bI,
proshade_signed  gI,
double *  rotMat,
int  len 
)

This function takes rotation function indices, converts them to Euler angles and these to rotation matrix, which it then returns.

Parameters
[in]aIThe index along the Euler alpha dimension.
[in]bIThe index along the Euler beta dimension.
[in]gIThe index along the Euler gamma dimension.
[in]rotMatThe array to which the rotation matrix will be written into.
[in]lenThe lenght of the array (must be 9).

Definition at line 4352 of file ProSHADE_data.cpp.

4353 {
4354  //================================================ Get Euler angles
4355  proshade_double eA, eB, eG;
4356  ProSHADE_internal_maths::getEulerZXZFromSOFTPosition ( static_cast< int > ( this->getMaxBand() ), aI, bI, gI, &eA, &eB, &eG );
4357 
4358  //================================================ Prepare internal rotation matrix memory
4359  proshade_double* rMat = nullptr;
4360  rMat = new proshade_double[9];
4361  ProSHADE_internal_misc::checkMemoryAllocation ( rMat, __FILE__, __LINE__, __func__ );
4362 
4363  //================================================ Convert to rotation matrix
4365 
4366  //================================================ Copy to output
4367  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4368  {
4369  rotMat[iter] = static_cast<double> ( rMat[iter] );
4370  }
4371 
4372  //================================================ Release internal memory
4373  delete[] rMat;
4374 
4375  //================================================ Done
4376  return ;
4377 
4378 }

◆ getRRPValue()

proshade_double ProSHADE_internal_data::ProSHADE_data::getRRPValue ( proshade_unsign  band,
proshade_unsign  sh1,
proshade_unsign  sh2 
)

This function allows access to the priva internal RRP matrices.

Parameters
[out]XThe value of the internal private RRP matrix for the given indices.

Definition at line 3621 of file ProSHADE_data.cpp.

3622 {
3623  //================================================ Return the value
3624  return ( this->rrpMatrices[band][sh1][sh2] );
3625 }

◆ getShellBandwidth()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getShellBandwidth ( proshade_unsign  shell)

This function allows access to the bandwidth of a particular shell.

Parameters
[in]shellThe index of the shell for which the bandwidth is required.
[out]XThe bandwidth of the requested shell.

Definition at line 3793 of file ProSHADE_data.cpp.

3794 {
3795  //================================================ Done
3796  return ( this->spheres[shell]->getLocalBandwidth ( ) );
3797 
3798 }

◆ getSO3Coeffs()

proshade_complex * ProSHADE_internal_data::ProSHADE_data::getSO3Coeffs ( void  )

This function allows access to the SO(3) coefficients array.

Parameters
[out]XThe internal SO(3) coefficients array variable.

Definition at line 3858 of file ProSHADE_data.cpp.

3859 {
3860  //================================================ Done
3861  return ( this->so3Coeffs );
3862 
3863 }

◆ getSpherePositions()

void ProSHADE_internal_data::ProSHADE_data::getSpherePositions ( ProSHADE_settings settings)

This function determines the sphere positions (radii) for sphere mapping.

This function determines the radii of the concentric spheres (as measured from the centre of the map). This is done by checking if these values have already been as and if not, then the radii are placed between points of the map starting between the centre point and its neighbours and then adding spheres until the most outlying diagonal point is covered.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 1746 of file ProSHADE_data.cpp.

1747 {
1748  //================================================ Check the current settings value is set to auto
1749  if ( this->spherePos.size() != 0 )
1750  {
1751  std::stringstream hlpSS;
1752  hlpSS << "The sphere distances were determined as " << this->spherePos.at(0);
1753  for ( proshade_unsign iter = 1; iter < static_cast<proshade_unsign> ( this->spherePos.size() ); iter++ ) { hlpSS << "; " << this->spherePos.at(iter); }
1754  hlpSS << " Angstroms.";
1755  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str(), settings->messageShift );
1756  return ;
1757  }
1758 
1759  //================================================ Find maximum diagonal
1760  proshade_unsign maxDim = static_cast< proshade_unsign > ( std::max ( this->xDimSize, std::max ( this->yDimSize, this->zDimSize ) ) );
1761  proshade_unsign minDim = static_cast< proshade_unsign > ( std::min ( this->xDimSize, std::min ( this->yDimSize, this->zDimSize ) ) );
1762  proshade_unsign midDim = static_cast< proshade_unsign > ( 0 );
1763  if ( ( this->xDimSize < static_cast< proshade_single > ( maxDim ) ) && ( this->xDimSize > static_cast< proshade_single > ( minDim ) ) ) { midDim = static_cast< proshade_unsign > ( this->xDimSize ); }
1764  else if ( ( this->yDimSize < static_cast< proshade_single > ( maxDim ) ) && ( this->yDimSize > static_cast< proshade_single > ( minDim ) ) ) { midDim = static_cast< proshade_unsign > ( this->yDimSize ); }
1765  else { midDim = static_cast< proshade_unsign > ( this->zDimSize ); }
1766 
1767  proshade_single maxDiag = static_cast< proshade_single > ( std::sqrt ( std::pow ( static_cast<proshade_single> ( maxDim ), 2.0 ) +
1768  std::pow ( static_cast<proshade_single> ( midDim ), 2.0 ) ) );
1769 
1770  //================================================ Set between the points
1771  for ( proshade_single iter = 0.5f; ( iter * settings->maxSphereDists ) < ( maxDiag / 2.0f ); iter += 1.0f )
1772  {
1773  ProSHADE_internal_misc::addToSingleVector ( &this->spherePos, ( iter * settings->maxSphereDists ) );
1774  }
1775 
1776  //================================================ Save the number of spheres
1777  this->noSpheres = static_cast<proshade_unsign> ( this->spherePos.size() );
1778 
1779  //================================================ Report progress
1780  std::stringstream hlpSS;
1781  hlpSS << "The sphere distances were determined as " << this->spherePos.at(0);
1782  for ( proshade_unsign iter = 1; iter < static_cast<proshade_unsign> ( this->spherePos.size() ); iter++ ) { hlpSS << "; " << this->spherePos.at(iter); }
1783  hlpSS << " Angstroms.";
1784  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str(), settings->messageShift );
1785 
1786  //================================================ Done
1787  return ;
1788 
1789 }

◆ getSpherePosValue()

proshade_single ProSHADE_internal_data::ProSHADE_data::getSpherePosValue ( proshade_unsign  shell)

This function allows access to sphere positions.

Parameters
[in]shellThe index of the sphere for which the position (radius) is to be obtained.
[out]XThe radius of the sphere with index shell.

Definition at line 3805 of file ProSHADE_data.cpp.

3806 {
3807  //================================================ Done
3808  return ( this->spherePos.at(shell) );
3809 
3810 }

◆ getSymmetryAxis()

std::vector< std::string > ProSHADE_internal_data::ProSHADE_data::getSymmetryAxis ( ProSHADE_settings settings,
proshade_unsign  axisNo 
)

This function returns a single symmetry axis as a vector of strings from the recommended symmetry axes list.

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]axisNoThe index of the axis to be returned.
[out]valA vector of strings containing the symmetry axis fold, x, y, z axis element, angle, peak height and averaged FSC in this order.

Definition at line 4419 of file ProSHADE_data.cpp.

4420 {
4421  //================================================ Sanity checks
4422  if ( static_cast<proshade_unsign> ( settings->detectedSymmetry.size() ) <= axisNo )
4423  {
4424  ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Requested symmetry index does not exist. Returning empty vector.", "WS00039" );
4425  return ( std::vector< std::string > ( ) );
4426  }
4427 
4428  //================================================ Initialise local variables
4429  std::vector< std::string > ret;
4430 
4431  //================================================ Input the axis data as strings
4432  std::stringstream ssHlp;
4433  ssHlp << settings->detectedSymmetry.at(axisNo)[0];
4434  ProSHADE_internal_misc::addToStringVector ( &ret, ssHlp.str() );
4435  ssHlp.str ( "" );
4436 
4437  ssHlp << settings->detectedSymmetry.at(axisNo)[1];
4438  ProSHADE_internal_misc::addToStringVector ( &ret, ssHlp.str() );
4439  ssHlp.str ( "" );
4440 
4441  ssHlp << settings->detectedSymmetry.at(axisNo)[2];
4442  ProSHADE_internal_misc::addToStringVector ( &ret, ssHlp.str() );
4443  ssHlp.str ( "" );
4444 
4445  ssHlp << settings->detectedSymmetry.at(axisNo)[3];
4446  ProSHADE_internal_misc::addToStringVector ( &ret, ssHlp.str() );
4447  ssHlp.str ( "" );
4448 
4449  ssHlp << settings->detectedSymmetry.at(axisNo)[4];
4450  ProSHADE_internal_misc::addToStringVector ( &ret, ssHlp.str() );
4451  ssHlp.str ( "" );
4452 
4453  ssHlp << settings->detectedSymmetry.at(axisNo)[5];
4454  ProSHADE_internal_misc::addToStringVector ( &ret, ssHlp.str() );
4455  ssHlp.str ( "" );
4456 
4457  ssHlp << settings->detectedSymmetry.at(axisNo)[6];
4458  ProSHADE_internal_misc::addToStringVector ( &ret, ssHlp.str() );
4459  ssHlp.str ( "" );
4460 
4461  //================================================ Done
4462  return ( ret );
4463 
4464 }

◆ getTetrahedralSymmetriesList()

std::vector< proshade_double * > ProSHADE_internal_data::ProSHADE_data::getTetrahedralSymmetriesList ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSymList 
)

This function obtains a list of all T symmetry axes from the already computed C symmetries list.

This function starts by checking if there are two C3 symmetries with the tetrahedral dihedral angle. If so, it proceeds to search for all seven symmetry axes expected to form a full tetrahedral symmetry. It then returns the list of found symmetries; if full tetrahedral symmetry was found, seven axes (four C3s and three C2s) are returned. If less than seven symmetries are returned, the procedure has failed and no tetrahedral symmetry was found.

Parameters
[in]settingsA pointer to settings class containing all the information required for symmetry detection.
[in]CSymListA vector containing the already detected Cyclic symmetries.

Definition at line 422 of file ProSHADE_symmetry.cpp.

423 {
424  //================================================ Initialise variables
425  std::vector< proshade_double* > ret;
426 
427  //================================================ Report progress
428  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting T symmetry detection.", settings->messageShift );
429 
430  //================================================ Are the basic requirements for tetrahedral symmetry met?
432  {
433  //============================================ Search for all the symmetry axes
434  ProSHADE_internal_symmetry::findTetra4C3s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
435  if ( ret.size() != 4 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
436 
437  ProSHADE_internal_symmetry::findTetra3C2s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->messageShift, settings->minSymPeak );
438  if ( ret.size() != 7 ) { ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Failed to detect some of the polyhedral symmetries, while detecting the correct dihedral angles.", "WS00031" ); return ( ret ); }
439  else
440  {
441  for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
442  {
443  for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
444  {
445  //======================================== Sort ret by fold
446  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymInvFoldHlp );
447 
448  //======================================== Save indices
449  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(csIt)[0] ), rhs1 ( ret.at(retIt)[0] );
450  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(csIt)[1] ), rhs2 ( ret.at(retIt)[1] );
451  const FloatingPoint< proshade_double > lhs3 ( CSymList->at(csIt)[2] ), rhs3 ( ret.at(retIt)[2] );
452  const FloatingPoint< proshade_double > lhs4 ( CSymList->at(csIt)[3] ), rhs4 ( ret.at(retIt)[3] );
453  const FloatingPoint< proshade_double > lhs5 ( CSymList->at(csIt)[4] ), rhs5 ( ret.at(retIt)[4] );
454  const FloatingPoint< proshade_double > lhs6 ( CSymList->at(csIt)[5] ), rhs6 ( ret.at(retIt)[5] );
455  if ( ( lhs1.AlmostEquals ( rhs1 ) ) &&
456  ( lhs2.AlmostEquals ( rhs2 ) ) &&
457  ( lhs3.AlmostEquals ( rhs3 ) ) &&
458  ( lhs4.AlmostEquals ( rhs4 ) ) &&
459  ( lhs5.AlmostEquals ( rhs5 ) ) &&
460  ( lhs6.AlmostEquals ( rhs6 ) ) )
461  {
463  }
464  }
465  }
466  }
467  }
468 
469  //================================================ Report progress
470  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "T symmetry detection complete.", settings->messageShift );
471 
472  //================================================ Done
473  return ( ret );
474 
475 }

◆ getTranslationFnPointer()

proshade_complex * ProSHADE_internal_data::ProSHADE_data::getTranslationFnPointer ( void  )

This function allows access to the translation function through a pointer.

Parameters
[out]translationMapPointer to the first position in the translation function map array.

Definition at line 4059 of file ProSHADE_data.cpp.

4060 {
4061  //================================================ Return the requested value
4062  return ( this->translationMap );
4063 }

◆ getWignerMatrixValue()

void ProSHADE_internal_data::ProSHADE_data::getWignerMatrixValue ( proshade_unsign  band,
proshade_unsign  order1,
proshade_unsign  order2,
proshade_double *  valueReal,
proshade_double *  valueImag 
)

This function allows access to the Wigner D matrix by knowing the band, order1 and order2 indices.

Parameters
[in]bandThe band for which the Wigner D matrix value should be returned.
[in]order1The first order for which the Wigner D matrix value should be returned.
[in]order2The second order for which the Wigner D matrix value should be returned.
[in]valueRealThe proshade_double number pointer to where the real part of the value will be saved.
[in]valueImagThe proshade_double number pointer to where the imaginary part of the value will be saved.

Definition at line 3884 of file ProSHADE_data.cpp.

3885 {
3886  //================================================ Set pointer
3887  *valueReal = this->wignerMatrices[band][order1][order2][0];
3888  *valueImag = this->wignerMatrices[band][order1][order2][1];
3889 
3890  //================================================ Done
3891  return ;
3892 
3893 }

◆ getXAxisOrigin()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getXAxisOrigin ( void  )

This function allows access to the map X axis origin value.

Parameters
[out]xAxisOriginThe value of X axis origin for the map.

Definition at line 4019 of file ProSHADE_data.cpp.

4020 {
4021  //================================================ Return the requested value
4022  return ( &this->xAxisOrigin );
4023 }

◆ getXDim()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getXDim ( void  )

This function allows access to the map size in indices along the X axis.

Parameters
[out]xDimSizeThe size of the internal map in indices along the X axis.

Definition at line 3929 of file ProSHADE_data.cpp.

3930 {
3931  //================================================ Return the requested value
3932  return ( this->xDimIndices );
3933 }

◆ getXDimSize()

proshade_single ProSHADE_internal_data::ProSHADE_data::getXDimSize ( void  )

This function allows access to the map size in angstroms along the X axis.

Parameters
[out]xDimSizeThe size of the internal map in angstroms along the X axis.

Definition at line 3899 of file ProSHADE_data.cpp.

3900 {
3901  //================================================ Return the requested value
3902  return ( this->xDimSize );
3903 }

◆ getXFromPtr()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getXFromPtr ( void  )

This function allows access to the map start along the X axis.

Parameters
[out]xFromPointer to the starting index along the X axis.

Definition at line 3959 of file ProSHADE_data.cpp.

3960 {
3961  //================================================ Return the requested value
3962  return ( &this->xFrom );
3963 }

◆ getXToPtr()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getXToPtr ( void  )

This function allows access to the map last position along the X axis.

Parameters
[out]xFromPointer to the final index along the X axis.

Definition at line 3989 of file ProSHADE_data.cpp.

3990 {
3991  //================================================ Return the requested value
3992  return ( &this->xTo );
3993 }

◆ getYAxisOrigin()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getYAxisOrigin ( void  )

This function allows access to the map Y axis origin value.

Parameters
[out]yAxisOriginThe value of Y axis origin for the map.

Definition at line 4029 of file ProSHADE_data.cpp.

4030 {
4031  //================================================ Return the requested value
4032  return ( &this->yAxisOrigin );
4033 }

◆ getYDim()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getYDim ( void  )

This function allows access to the map size in indices along the Y axis.

Parameters
[out]xDimSizeThe size of the internal map in indices along the Y axis.

Definition at line 3939 of file ProSHADE_data.cpp.

3940 {
3941  //================================================ Return the requested value
3942  return ( this->yDimIndices );
3943 }

◆ getYDimSize()

proshade_single ProSHADE_internal_data::ProSHADE_data::getYDimSize ( void  )

This function allows access to the map size in angstroms along the Y axis.

Parameters
[out]xDimSizeThe size of the internal map in angstroms along the Y axis.

Definition at line 3909 of file ProSHADE_data.cpp.

3910 {
3911  //================================================ Return the requested value
3912  return ( this->yDimSize );
3913 }

◆ getYFromPtr()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getYFromPtr ( void  )

This function allows access to the map start along the Y axis.

Parameters
[out]yFromPointer to the starting index along the Y axis.

Definition at line 3969 of file ProSHADE_data.cpp.

3970 {
3971  //================================================ Return the requested value
3972  return ( &this->yFrom );
3973 }

◆ getYToPtr()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getYToPtr ( void  )

This function allows access to the map last position along the Y axis.

Parameters
[out]yFromPointer to the final index along the Y axis.

Definition at line 3999 of file ProSHADE_data.cpp.

4000 {
4001  //================================================ Return the requested value
4002  return ( &this->yTo );
4003 }

◆ getZAxisOrigin()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getZAxisOrigin ( void  )

This function allows access to the map Z axis origin value.

Parameters
[out]zAxisOriginThe value of Z axis origin for the map.

Definition at line 4039 of file ProSHADE_data.cpp.

4040 {
4041  //================================================ Return the requested value
4042  return ( &this->zAxisOrigin );
4043 }

◆ getZDim()

proshade_unsign ProSHADE_internal_data::ProSHADE_data::getZDim ( void  )

This function allows access to the map size in indices along the Z axis.

Parameters
[out]xDimSizeThe size of the internal map in indices along the Z axis.

Definition at line 3949 of file ProSHADE_data.cpp.

3950 {
3951  //================================================ Return the requested value
3952  return ( this->zDimIndices );
3953 }

◆ getZDimSize()

proshade_single ProSHADE_internal_data::ProSHADE_data::getZDimSize ( void  )

This function allows access to the map size in angstroms along the Z axis.

Parameters
[out]xDimSizeThe size of the internal map in angstroms along the Z axis.

Definition at line 3919 of file ProSHADE_data.cpp.

3920 {
3921  //================================================ Return the requested value
3922  return ( this->zDimSize );
3923 }

◆ getZFromPtr()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getZFromPtr ( void  )

This function allows access to the map start along the Z axis.

Parameters
[out]zFromPointer to the starting index along the Z axis.

Definition at line 3979 of file ProSHADE_data.cpp.

3980 {
3981  //================================================ Return the requested value
3982  return ( &this->zFrom );
3983 }

◆ getZToPtr()

proshade_signed * ProSHADE_internal_data::ProSHADE_data::getZToPtr ( void  )

This function allows access to the map last position along the Z axis.

Parameters
[out]zFromPointer to the final index along the Z axis.

Definition at line 4009 of file ProSHADE_data.cpp.

4010 {
4011  //================================================ Return the requested value
4012  return ( &this->zTo );
4013 }

◆ interpolateMapFromSpheres()

void ProSHADE_internal_data::ProSHADE_data::interpolateMapFromSpheres ( proshade_double *&  densityMapRotated)

This function interpolates the density map from the sphere mapped data.

Parameters
[in]densityMapRotatedThe pointer to allocated memory where the new map values will be held.

Definition at line 1114 of file ProSHADE_overlay.cpp.

1115 {
1116  //================================================ Initialise variables
1117  proshade_double rad = 0.0, lon = 0.0, lat = 0.0, newU = 0.0, newV = 0.0, newW = 0.0;
1118  proshade_unsign lowerLonL = 0, upperLonL = 0, lowerLonU = 0, upperLonU = 0, lowerLatL = 0, upperLatL = 0, lowerLatU = 0, upperLatU = 0, lowerShell = 0, upperShell = 0;
1119  proshade_double x00 = 0.0, x01 = 0.0, x10 = 0.0, x11 = 0.0, distLLon = 0.0, distLLat = 0.0, distLRad = 0.0, valLLon = 0.0, valULon = 0.0;
1120  proshade_double lowerShellValue = 0.0, upperShellValue = 0.0;
1121  proshade_double xSamplingRate = static_cast<proshade_double> ( this->xDimSize ) / static_cast<proshade_double> ( this->xDimIndices );
1122  proshade_double ySamplingRate = static_cast<proshade_double> ( this->yDimSize ) / static_cast<proshade_double> ( this->yDimIndices );
1123  proshade_double zSamplingRate = static_cast<proshade_double> ( this->zDimSize ) / static_cast<proshade_double> ( this->zDimIndices );
1124  proshade_signed arrPos;
1125  std::vector<proshade_double> lonCOU, latCOU, lonCOL, latCOL;
1126 
1127  for ( proshade_signed uIt = 0; uIt < static_cast<proshade_signed> (this->xDimIndices); uIt++ )
1128  {
1129  for ( proshade_signed vIt = 0; vIt < static_cast<proshade_signed> (this->yDimIndices); vIt++ )
1130  {
1131  for ( proshade_signed wIt = 0; wIt < static_cast<proshade_signed> (this->zDimIndices); wIt++ )
1132  {
1133  //==================================== Convert to centered coords
1134  newU = static_cast<proshade_double> ( uIt - ( static_cast<proshade_signed> (this->xDimIndices) / 2 ) );
1135  newV = static_cast<proshade_double> ( vIt - ( static_cast<proshade_signed> (this->yDimIndices) / 2 ) );
1136  newW = static_cast<proshade_double> ( wIt - ( static_cast<proshade_signed> (this->zDimIndices) / 2 ) );
1137 
1138  //==================================== Deal with 0 ; 0 ; 0
1139  if ( ( newU == 0.0 ) && ( newV == 0.0 ) && ( newW == 0.0 ) )
1140  {
1141  arrPos = wIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( vIt + static_cast< proshade_signed > ( this->yDimIndices ) * uIt );
1142  densityMapRotated[arrPos] = this->internalMap[arrPos];
1143  continue;
1144  }
1145 
1146  //==================================== Convert to spherical coords
1147  rad = sqrt ( pow( ( newU * xSamplingRate ), 2.0 ) +
1148  pow( ( newV * ySamplingRate ), 2.0 ) +
1149  pow( ( newW * zSamplingRate ), 2.0 ) );
1150  lon = atan2 ( ( newV * ySamplingRate ), ( newU * xSamplingRate ) );
1151  lat = asin ( ( newW * zSamplingRate ) / rad );
1152 
1153  //==================================== Deal with nan's
1154  if ( rad != rad ) { rad = 0.0; }
1155  if ( lon != lon ) { lon = 0.0; }
1156  if ( lat != lat ) { lat = 0.0; }
1157 
1158  //==================================== Find shells above and below
1159  lowerShell = 0;
1160  upperShell = 0;
1161  for ( proshade_unsign iter = 0; iter < (this->noSpheres-1); iter++ )
1162  {
1163  if ( ( static_cast< proshade_double > ( this->spherePos.at(iter) ) <= rad ) && ( static_cast< proshade_double > ( this->spherePos.at(iter+1) ) > rad ) )
1164  {
1165  lowerShell = iter;
1166  upperShell = iter+1;
1167  break;
1168  }
1169  }
1170 
1171  if ( upperShell == 0 )
1172  {
1173  arrPos = wIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( vIt + static_cast< proshade_signed > ( this->yDimIndices ) * uIt );
1174  densityMapRotated[arrPos] = 0.0;
1175  continue;
1176  }
1177 
1178  //==================================== Get the longitude and lattitude cut-offs for this shell resolution
1179  lonCOL.clear(); latCOL.clear(); lonCOU.clear(); latCOU.clear();
1180  ProSHADE_internal_overlay::computeAngularThreshold ( &lonCOL, &latCOL, this->spheres[lowerShell]->getLocalAngRes() );
1181  ProSHADE_internal_overlay::computeAngularThreshold ( &lonCOU, &latCOU, this->spheres[upperShell]->getLocalAngRes() );
1182 
1183  //==================================== Find the angle cutoffs around the point
1184  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( lonCOL.size() ); iter++ )
1185  {
1186  if ( iter == ( static_cast<proshade_unsign> ( lonCOL.size() ) - 1 ) )
1187  {
1188  lowerLonL = 0;
1189  upperLonL = 1;
1190  break;
1191  }
1192  if ( ( std::floor(10000. * lonCOL.at(iter)) <= std::floor(10000. * lon) ) && ( std::floor(10000. * lonCOL.at(iter+1)) > std::floor(10000. * lon) ) )
1193  {
1194  lowerLonL = iter;
1195  upperLonL = iter+1;
1196  break;
1197  }
1198  }
1199  if ( upperLonL == this->spheres[lowerShell]->getLocalAngRes() ) { upperLonL = 0; }
1200 
1201  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( lonCOU.size() ); iter++ )
1202  {
1203  if ( iter == ( static_cast<proshade_unsign> ( lonCOU.size() ) - 1 ) )
1204  {
1205  lowerLonU = 0;
1206  upperLonU = 1;
1207  break;
1208  }
1209  if ( ( std::floor(10000. * lonCOU.at(iter)) <= std::floor(10000. * lon) ) && ( std::floor(10000. * lonCOU.at(iter+1)) > std::floor(10000. * lon) ) )
1210  {
1211  lowerLonU = iter;
1212  upperLonU = iter+1;
1213  break;
1214  }
1215  }
1216  if ( upperLonU == this->spheres[upperShell]->getLocalAngRes() ) { upperLonU = 0; }
1217 
1218  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( latCOL.size() ); iter++ )
1219  {
1220  if ( iter == ( static_cast<proshade_unsign> ( latCOL.size() ) - 1 ) )
1221  {
1222  lowerLatL = 0;
1223  upperLatL = 1;
1224  break;
1225  }
1226  if ( ( std::floor(10000. * latCOL.at(iter)) <= std::floor(10000. * lat) ) && ( std::floor(10000. * latCOL.at(iter+1)) > std::floor(10000. * lat) ) )
1227  {
1228  lowerLatL = iter;
1229  upperLatL = iter+1;
1230  break;
1231  }
1232  }
1233  if ( upperLatL == this->spheres[lowerShell]->getLocalAngRes() ) { upperLatL = 0; }
1234 
1235  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( latCOU.size() ); iter++ )
1236  {
1237  if ( iter == ( static_cast<proshade_unsign> ( latCOU.size() ) - 1 ) )
1238  {
1239  lowerLatU = 0;
1240  upperLatU = 1;
1241  break;
1242  }
1243  if ( ( std::floor(10000. * latCOU.at(iter)) <= std::floor(10000. * lat) ) && ( std::floor(10000. * latCOU.at(iter+1)) > std::floor(10000. * lat) ) )
1244  {
1245  lowerLatU = iter;
1246  upperLatU = iter+1;
1247  break;
1248  }
1249  }
1250  if ( upperLatU == this->spheres[upperShell]->getLocalAngRes() ) { upperLatU = 0; }
1251 
1252  //==================================== Interpolate lower shell
1253  x00 = this->spheres[lowerShell]->getRotatedMappedData ( lowerLatL * this->spheres[lowerShell]->getLocalAngRes() + lowerLonL );
1254  x01 = this->spheres[lowerShell]->getRotatedMappedData ( lowerLatL * this->spheres[lowerShell]->getLocalAngRes() + upperLonL );
1255  x10 = this->spheres[lowerShell]->getRotatedMappedData ( upperLatL * this->spheres[lowerShell]->getLocalAngRes() + lowerLonL );
1256  x11 = this->spheres[lowerShell]->getRotatedMappedData ( upperLatL * this->spheres[lowerShell]->getLocalAngRes() + upperLonL );
1257 
1258  distLLon = std::abs ( lon - lonCOL.at(lowerLonL) ) / ( std::abs( lon - lonCOL.at(lowerLonL) ) + std::abs( lon - lonCOL.at(upperLonL) ) );
1259  valLLon = ( ( 1.0 - distLLon ) * x00 ) + ( distLLon * x01 );
1260  valULon = ( ( 1.0 - distLLon ) * x10 ) + ( distLLon * x11 );
1261 
1262  distLLat = std::abs ( lat - latCOL.at(lowerLatL) ) / ( std::abs( lat - latCOL.at(lowerLatL) ) + std::abs( lat - latCOL.at(upperLatL) ) );
1263  lowerShellValue = ( ( 1.0 - distLLat ) * valLLon ) + ( distLLat * valULon );
1264 
1265  //==================================== Interpolate upper shell
1266  x00 = this->spheres[upperShell]->getRotatedMappedData ( lowerLatU * this->spheres[upperShell]->getLocalAngRes() + lowerLonU );
1267  x01 = this->spheres[upperShell]->getRotatedMappedData ( lowerLatU * this->spheres[upperShell]->getLocalAngRes() + upperLonU );
1268  x10 = this->spheres[upperShell]->getRotatedMappedData ( upperLatU * this->spheres[upperShell]->getLocalAngRes() + lowerLonU );
1269  x11 = this->spheres[upperShell]->getRotatedMappedData ( upperLatU * this->spheres[upperShell]->getLocalAngRes() + upperLonU );
1270 
1271  distLLon = std::abs ( lon - lonCOU.at(lowerLonU) ) / ( std::abs( lon - lonCOU.at(lowerLonU) ) + std::abs( lon - lonCOU.at(upperLonU) ) );
1272  valLLon = ( ( 1.0 - distLLon ) * x00 ) + ( distLLon * x01 );
1273  valULon = ( ( 1.0 - distLLon ) * x10 ) + ( distLLon * x11 );
1274 
1275  distLLat = std::abs ( lat - latCOU.at(lowerLatU) ) / ( std::abs( lat - latCOU.at(lowerLatU) ) + std::abs( lat - latCOU.at(upperLatU) ) );
1276  upperShellValue = ( ( 1.0 - distLLat ) * valLLon ) + ( distLLat * valULon );
1277 
1278  //==================================== Interpolate between shells
1279  distLRad = std::abs ( rad - static_cast< proshade_double > ( this->spherePos.at(lowerShell) ) ) / ( std::abs( rad - static_cast< proshade_double > ( this->spherePos.at(lowerShell) ) ) +
1280  std::abs( rad - static_cast< proshade_double > ( this->spherePos.at(upperShell) ) ) );
1281 
1282  arrPos = wIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( vIt + static_cast< proshade_signed > ( this->yDimIndices ) * uIt );
1283  densityMapRotated[arrPos] = ( ( 1.0 - distLRad ) * lowerShellValue ) + ( distLRad * upperShellValue );
1284  }
1285 
1286  }
1287 
1288  }
1289 
1290  //================================================ Done
1291  return ;
1292 
1293 }

◆ invertMirrorMap()

void ProSHADE_internal_data::ProSHADE_data::invertMirrorMap ( ProSHADE_settings settings)

Function for inverting the map to its mirror image.

This function switches all index values along the three axes from 0 ... max to max ... 0. This should not normally be done, but in the case where the wrong hand has been used in the map re-construction process, this may be helpful.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.

Definition at line 1175 of file ProSHADE_data.cpp.

1176 {
1177  //================================================ Report function start
1178  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map inversion.", settings->messageShift );
1179 
1180  //================================================ Initialise variables
1181  proshade_signed arrayPos, invPos;
1182 
1183  //================================================ Create helper map
1184  proshade_double* hlpMap = new proshade_double [this->xDimIndices * this->yDimIndices * this->zDimIndices];
1185  ProSHADE_internal_misc::checkMemoryAllocation ( hlpMap, __FILE__, __LINE__, __func__ );
1186 
1187  //================================================ Save map values to the helper map
1188  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1189  {
1190  hlpMap[iter] = this->internalMap[iter];
1191  }
1192 
1193  //================================================ Invert the values
1194  for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->xDimIndices ); xIt++ )
1195  {
1196  for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->yDimIndices ); yIt++ )
1197  {
1198  for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->zDimIndices ); zIt++ )
1199  {
1200  //==================================== Var init
1201  arrayPos = zIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( yIt + static_cast< proshade_signed > ( this->yDimIndices ) * xIt );
1202  invPos = ( static_cast< proshade_signed > ( this->zDimIndices - 1 ) - zIt ) + static_cast< proshade_signed > ( this->zDimIndices ) * ( ( static_cast< proshade_signed > ( this->yDimIndices - 1 ) - yIt ) + static_cast< proshade_signed > ( this->yDimIndices ) * ( static_cast< proshade_signed > ( this->xDimIndices - 1 ) - xIt ) );
1203 
1204  //==================================== And save
1205  this->internalMap[invPos] = hlpMap[arrayPos];
1206  }
1207  }
1208  }
1209 
1210  //================================================ Release memory
1211  delete[] hlpMap;
1212 
1213  //================================================ Report function completion
1214  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Map inversion completed.", settings->messageShift );
1215 
1216  //================================================ Done
1217  return ;
1218 
1219 }

◆ invertSHCoefficients()

void ProSHADE_internal_data::ProSHADE_data::invertSHCoefficients ( void  )

This function computes the shell mapped data from inverting the Spherical Harmonics coefficients.

Definition at line 1021 of file ProSHADE_overlay.cpp.

1022 {
1023  //================================================ Initialise local variables
1024  double *sigR = nullptr, *sigI = nullptr, *rcoeffs = nullptr, *icoeffs = nullptr, *weights = nullptr, *workspace = nullptr;
1025  fftw_plan idctPlan, ifftPlan;
1026 
1027  //================================================ For each shell
1028  for ( int shell = 0; shell < static_cast<int> ( this->noSpheres ); shell++ )
1029  {
1030  //=========================================== Initialise internal variables
1031  proshade_unsign oneDim = this->spheres[shell]->getLocalBandwidth() * 2;
1032 
1033  //=========================================== Allocate memory
1034  ProSHADE_internal_overlay::initialiseInverseSHComputation ( this->spheres[shell]->getLocalBandwidth(), sigR, sigI, rcoeffs, icoeffs, weights, workspace, idctPlan, ifftPlan );
1035 
1036  //=========================================== Compute weights for the transform using the appropriate shell related band
1037  makeweights ( static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ), weights );
1038 
1039  //============================================ Allocate rotated shell mapped data memory
1040  this->spheres[shell]->allocateRotatedMap ( );
1041 
1042  //============================================ Load SH coeffs to arrays
1043  for ( unsigned int iter = 0; iter < static_cast<unsigned int> ( oneDim * oneDim ); iter++ )
1044  {
1045  rcoeffs[iter] = this->rotSphericalHarmonics[shell][iter][0];
1046  icoeffs[iter] = this->rotSphericalHarmonics[shell][iter][1];
1047  sigR[iter] = 0.0;
1048  sigI[iter] = 0.0;
1049  }
1050 
1051  //============================================ Get inverse spherical harmonics transform for the shell
1052  InvFST_semi_fly ( rcoeffs,
1053  icoeffs,
1054  sigR,
1055  sigI,
1056  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ),
1057  workspace,
1058  0,
1059  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ),
1060  &idctPlan,
1061  &ifftPlan );
1062 
1063  //=========================================== Copy the results to the rotated shells array
1064  for ( unsigned int iter = 0; iter < static_cast<unsigned int> ( oneDim * oneDim ); iter++ )
1065  {
1066  this->spheres[shell]->setRotatedMappedData ( iter, sigR[iter] );
1067  }
1068 
1069  //=========================================== Release the plans
1070  fftw_destroy_plan ( idctPlan );
1071  fftw_destroy_plan ( ifftPlan );
1072 
1073  //=========================================== Release the memory
1074  delete[] sigR;
1075  delete[] rcoeffs;
1076  delete[] weights;
1077  delete[] workspace;
1078  }
1079 
1080  //================================================ Done
1081  return ;
1082 
1083 }

◆ mapToSpheres()

void ProSHADE_internal_data::ProSHADE_data::mapToSpheres ( ProSHADE_settings settings)

This function converts the internal map onto a set of concentric spheres.

This function starts by determining the spherical harmonics values which were not supplied by the user, these may be bandwidth, taylor series cap, integration order, etc. It then proceeds to determine the optimal sphere distances, unless these were determined by the user.

Finally, the function creates a new instance of the ProSHADE_sphere class for each of the already determined sphere positions. Note: The constructor of ProSHADE_sphere is where the mapping then happens.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 1803 of file ProSHADE_data.cpp.

1804 {
1805  //================================================ Report progress
1806  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting sphere mapping procedure.", settings->messageShift );
1807 
1808  //================================================ Determine spherical harmonics variables
1809  settings->determineAllSHValues ( this->xDimIndices, this->yDimIndices,
1810  this->xDimSize, this->yDimSize, this->zDimSize );
1811  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Sphere settings determined.", settings->messageShift );
1812 
1813  //================================================ Find number of spheres supported
1814  this->getSpherePositions ( settings );
1815  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Sphere positions obtained.", settings->messageShift );
1816 
1817  //================================================ Create sphere objects and map the density
1819  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->spherePos.size() ); iter++ )
1820  {
1821  std::stringstream ss;
1822  ss << "Now mapping sphere " << iter << " .";
1823  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss.str(), settings->messageShift );
1824 
1826  this->xDimSize, this->yDimSize, this->zDimSize, iter,
1827  &this->spherePos, settings->progressiveSphereMapping, settings->maxBandwidth,
1828  this->internalMap, &this->maxShellBand );
1829  }
1830 
1831  //================================================ Report completion
1832  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Sphere mapping procedure completed.", settings->messageShift );
1833 
1834  //================================================ Done
1835  return ;
1836 
1837 }

◆ maskMap()

void ProSHADE_internal_data::ProSHADE_data::maskMap ( ProSHADE_settings settings)

Function for computing the map mask using blurring and X IQRs from median.

This function takes all the internal map representation information from the calling object and the internal map itself and proceeds to write all this information in MRC MAP format for visualisation and further processing by other software. It is dependent on the internal information being correct.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.

Definition at line 1276 of file ProSHADE_data.cpp.

1277 {
1278  //================================================ Report function start
1279  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Computing mask.", settings->messageShift );
1280 
1281  //================================================ Initialise the blurred map
1282  proshade_double* blurredMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1283  ProSHADE_internal_misc::checkMemoryAllocation ( blurredMap, __FILE__, __LINE__, __func__ );
1284 
1285  //================================================ Compute blurred map
1287  this->xDimSize, this->yDimSize, this->zDimSize, settings->blurFactor );
1288 
1289  //================================================ Compute mask from blurred map and save it into the original map
1291 
1292  //================================================ Print the mask if need be
1293  if ( settings->saveMask ) { if ( settings->maskFileName == "" ) { this->writeMask ( "proshade_mask.map", blurredMap ); } else { std::stringstream ss; ss << settings->maskFileName << "_" << this->inputOrder << ".map"; this->writeMask ( ss.str(), blurredMap ); } }
1294 
1295  //================================================ Release memory
1296  delete[] blurredMap;
1297 
1298  //================================================ Report function completion
1299  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Mask computed.", settings->messageShift );
1300 
1301  //================================================ Done
1302  return ;
1303 
1304 }

◆ normaliseEMatrixValue()

void ProSHADE_internal_data::ProSHADE_data::normaliseEMatrixValue ( proshade_unsign  band,
proshade_unsign  order1,
proshade_unsign  order2,
proshade_double  normF 
)

This function allows normalising the E matrix value.

Parameters
[in]bandThe band indice of the E matrix to which the value should be assigned.
[in]order1The first order indice of the E matrix to which the value should be assigned.
[in]order2The second order indice of the E matrix to which the value should be assigned.
[in]normFThe value by which the original E matrix value will be divided to normalise it.

Definition at line 4136 of file ProSHADE_data.cpp.

4137 {
4138  //================================================ Mutate
4139  this->eMatrices[band][order1][order2][0] /= normF;
4140  this->eMatrices[band][order1][order2][1] /= normF;
4141 
4142  //================================================ Done
4143  return ;
4144 
4145 }

◆ normaliseMap()

void ProSHADE_internal_data::ProSHADE_data::normaliseMap ( ProSHADE_settings settings)

Function for normalising the map values to mean 0 and sd 1..

This function takes the map and changes its value to have mean 0 and standard deviation of 1. This should make wo maps with very different density levels more comparable, but it remains to be seen if this causes any trouble. Can be turned off using the settings options.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.

Definition at line 1229 of file ProSHADE_data.cpp.

1230 {
1231  //================================================ Report function start
1232  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map normalisation.", settings->messageShift );
1233 
1234  //================================================ Initialise vector of map values
1235  std::vector<proshade_double> mapVals ( this->xDimIndices * this->yDimIndices * this->zDimIndices, 0.0 );
1236 
1237  //================================================ Get all map values
1238  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1239  {
1240  mapVals.at(iter) = this->internalMap[iter];
1241  }
1242 
1243  //================================================ Get mean and sd
1244  proshade_double* meanSD = new proshade_double[2];
1245  ProSHADE_internal_maths::vectorMeanAndSD ( &mapVals, meanSD );
1246 
1247  //================================================ Normalise the values
1248  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1249  {
1250  this->internalMap[iter] = ( this->internalMap[iter] - meanSD[0] ) / meanSD[1];
1251  }
1252 
1253  //================================================ Clear the vector
1254  mapVals.clear ( );
1255 
1256  //================================================ Release memory
1257  delete[] meanSD;
1258 
1259  //================================================ Report function completion
1260  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Map normalisation completed.", settings->messageShift );
1261 
1262  //================================================ Done
1263  return ;
1264 
1265 }

◆ prepareFSCFourierMemory()

void ProSHADE_internal_data::ProSHADE_data::prepareFSCFourierMemory ( fftw_complex *&  mapData,
fftw_complex *&  origCoeffs,
fftw_complex *&  fCoeffs,
proshade_signed *&  binIndexing,
proshade_signed *  noBins,
proshade_double **&  bindata,
proshade_signed *&  binCounts,
fftw_plan *  planForwardFourier,
proshade_double *&  fscByBin 
)

This function allocates the memory and makes all preparations required for FSC computation.

Parameters
[in]mapDataThe input array for Fourier transform.
[in]origCoeffsThe array for holding the Fourier coefficients of the original (non-rotated) density.
[in]fCoeffsThe array for holding the results of Fourier transform.
[in]binIndexingA map that will be filled with binning indices for fast binning.
[in]noBinsThe number of bins will be stored in this variable.
[in]bindataAn array to store the bin sums and other FSC computation temporary results.
[in]binCountsAn array that will be used to store the number of reflactions in each bin.
[in]fscByBinThis array will hold FSC values for each bin. This is useful in further computations, but could be internal for FSC only computation.

Definition at line 2320 of file ProSHADE_data.cpp.

2321 {
2322  //================================================ Decide number of bins and allocate which reflection belongs to which bin
2324 
2325  //================================================ Allocate memory for FSC sums
2326  bindata = new proshade_double*[*noBins];
2327  binCounts = new proshade_signed [*noBins];
2328  fscByBin = new proshade_double [*noBins];
2329 
2330  //================================================ Allcate memory for bin sumation
2331  for ( size_t binIt = 0; binIt < static_cast< size_t > ( *noBins ); binIt++ )
2332  {
2333  bindata[binIt] = new proshade_double[12];
2334  ProSHADE_internal_misc::checkMemoryAllocation ( bindata[binIt], __FILE__, __LINE__, __func__ );
2335  }
2336 
2337  //================================================ Allocate memory for Fourier transform imputs and outputs
2338  mapData = new fftw_complex [this->xDimIndices * this->yDimIndices * this->zDimIndices];
2339  origCoeffs = new fftw_complex [this->xDimIndices * this->yDimIndices * this->zDimIndices];
2340  fCoeffs = new fftw_complex [this->xDimIndices * this->yDimIndices * this->zDimIndices];
2341 
2342  //================================================ Check memory allocation
2343  ProSHADE_internal_misc::checkMemoryAllocation ( mapData, __FILE__, __LINE__, __func__ );
2344  ProSHADE_internal_misc::checkMemoryAllocation ( origCoeffs, __FILE__, __LINE__, __func__ );
2345  ProSHADE_internal_misc::checkMemoryAllocation ( fCoeffs, __FILE__, __LINE__, __func__ );
2346  ProSHADE_internal_misc::checkMemoryAllocation ( bindata, __FILE__, __LINE__, __func__ );
2347  ProSHADE_internal_misc::checkMemoryAllocation ( binCounts, __FILE__, __LINE__, __func__ );
2348  ProSHADE_internal_misc::checkMemoryAllocation ( fscByBin, __FILE__, __LINE__, __func__ );
2349 
2350  //================================================ Prepare memory for Fourier transform
2351  *planForwardFourier = fftw_plan_dft_3d ( static_cast< int > ( this->xDimIndices ), static_cast< int > ( this->yDimIndices ), static_cast< int > ( this->zDimIndices ), mapData, fCoeffs, FFTW_FORWARD, FFTW_ESTIMATE );
2352 
2353  //================================================ Compute Fourier transform of the original map
2354  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { mapData[iter][0] = this->internalMap[iter]; mapData[iter][1] = 0.0; }
2355  fftw_execute ( *planForwardFourier );
2356  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { origCoeffs[iter][0] = fCoeffs[iter][0]; origCoeffs[iter][1] = fCoeffs[iter][1]; }
2357 
2358  //================================================ Done
2359  return ;
2360 
2361 }

◆ processInternalMap()

void ProSHADE_internal_data::ProSHADE_data::processInternalMap ( ProSHADE_settings settings)

This function simply clusters several other functions which should be called together.

This function serves to cluster the map normalisation, map masking, map centering and map extra space addition into a single function. This allows for simpler code and does not take any control away, as all the decisions are ultimately driven by the settings. This function also shifts the map so that its centre of box is at the desired position.

This function also does some internal value saving and auto-determination of any parameters that the user did not supply. This, however, means, that this function MUST be called for every structure that is to be processed by ProSHADE. This is of importance to people whe want to use only a perticular functions.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.
Warning
This function MUST be called on any structure that is to be processed by ProSHADE.

Definition at line 1695 of file ProSHADE_data.cpp.

1696 {
1697  //================================================ Move given point to box centre
1698  if ( !( ( std::isinf ( settings->boxCentre.at(0) ) ) || ( std::isinf ( settings->boxCentre.at(1) ) ) || ( std::isinf ( settings->boxCentre.at(2) ) ) ) ) { this->shiftToBoxCentre ( settings ); }
1699  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map left at original position.", settings->messageShift ); }
1700 
1701  //================================================ Shift map to centre of rotation if so required
1702  if ( !( ( std::isinf ( settings->centrePosition.at(0) ) ) || ( std::isinf ( settings->centrePosition.at(1) ) ) || ( std::isinf ( settings->centrePosition.at(2) ) ) ) ) { this->shiftToRotationCentre ( settings ); }
1703  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map rotation centre not shifted.", settings->messageShift ); }
1704 
1705  //================================================ Invert map
1706  if ( settings->invertMap ) { this->invertMirrorMap ( settings ); }
1707  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map inversion (mirror image) not requested.", settings->messageShift ); }
1708 
1709  //================================================ Normalise map
1710  if ( settings->normaliseMap ) { this->normaliseMap ( settings ); }
1711  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map normalisation not requested.", settings->messageShift ); }
1712 
1713  //================================================ Compute mask
1714  if ( settings->maskMap ) { this->maskMap ( settings ); }
1715  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Masking not requested.", settings->messageShift ); }
1716 
1717  //================================================ Centre map
1718  if ( settings->moveToCOM ) { this->centreMapOnCOM ( settings ); }
1719  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map centering not requested.", settings->messageShift ); }
1720 
1721  //================================================ Remove phase, if required
1722  if ( !settings->usePhase ) { this->removePhaseInormation ( settings ); ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Phase information removed from the data.", settings->messageShift ); }
1723  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Phase information retained in the data.", settings->messageShift ); }
1724 
1725  //================================================ Add extra space
1726  if ( settings->addExtraSpace != 0.0f ) { this->addExtraSpace ( settings ); }
1727  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Extra space not requested.", settings->messageShift ); }
1728 
1729  //================================================ Set settings values which were left on AUTO by user and will not be set later
1730  settings->setVariablesLeftOnAuto ( );
1731 
1732  //================================================ Done
1733  return ;
1734 
1735 }

◆ readInGemmi()

void ProSHADE_internal_data::ProSHADE_data::readInGemmi ( gemmi::Structure  gemmiStruct,
ProSHADE_settings settings 
)
protected

Function for reading co-ordinate data from Gemmi object.

This function processes the input Gemmi structure into ProSHADE internal map. It starts with ProSHADE optional modifications of the co-ordinates (i.e. setting all B-factors to given value and removing waters). It then proceeds to move the co-ordinates so that their minimal point is at position [20, 20, 20] (this is to make sure map density will be at the centre of the box) and computes the theoretical density map using Gemmi's Cromer & Libermann method. It then moves the map box to the original co-ordinates position.

If map re-sampling is required, then this is done here as well.

Finally, this function sets all the ProSHADE internal values to what other functions expect and terminates.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.
Warning
For multiple models, this function works, but the map is not perfectly fitted to the PDB file.

Definition at line 735 of file ProSHADE_data.cpp.

736 {
737  //================================================ Set resolution if need be
738  if ( settings->requestedResolution < 0.0f )
739  {
740  settings->setResolution ( 8.0 );
741  }
742 
743  //================================================ Change B-factors if need be
744  if ( settings->pdbBFactorNewVal >= 0.0 )
745  {
747  }
748 
749  //================================================ Remove waters if required
750  if ( settings->removeWaters )
751  {
752  ProSHADE_internal_mapManip::removeWaters ( &gemmiStruct, settings->firstModelOnly );
753  }
754 
755  //================================================ Get PDB COM values
756  proshade_double xCOMPdb, yCOMPdb, zCOMPdb;
757  ProSHADE_internal_mapManip::findPDBCOMValues ( gemmiStruct, &xCOMPdb, &yCOMPdb, &zCOMPdb, settings->firstModelOnly );
758 
759  //================================================ Find the ranges
760  proshade_single xF = 0.0f, xT = 0.0f, yF = 0.0f, yT = 0.0f, zF = 0.0f, zT = 0.0f;
761  ProSHADE_internal_mapManip::determinePDBRanges ( gemmiStruct, &xF, &xT, &yF, &yT, &zF, &zT, settings->firstModelOnly );
762 
763  //================================================ Move ranges to have all FROM values 20
764  proshade_single xMov = static_cast< proshade_single > ( settings->coOrdsExtraSpace - xF );
765  proshade_single yMov = static_cast< proshade_single > ( settings->coOrdsExtraSpace - yF );
766  proshade_single zMov = static_cast< proshade_single > ( settings->coOrdsExtraSpace - zF );
767  ProSHADE_internal_mapManip::movePDBForMapCalc ( &gemmiStruct, xMov, yMov, zMov, settings->firstModelOnly );
768 
769  //================================================ Set the angstrom sizes
770  this->xDimSize = static_cast< proshade_single > ( xT - xF + ( 2.0f * settings->coOrdsExtraSpace ) );
771  this->yDimSize = static_cast< proshade_single > ( yT - yF + ( 2.0f * settings->coOrdsExtraSpace ) );
772  this->zDimSize = static_cast< proshade_single > ( zT - zF + ( 2.0f * settings->coOrdsExtraSpace ) );
773 
774  //================================================ Generate map from nicely placed atoms (cell size will be range + 40)
775  ProSHADE_internal_mapManip::generateMapFromPDB ( gemmiStruct, this->internalMap, settings->requestedResolution, this->xDimSize, this->yDimSize, this->zDimSize, &this->xTo, &this->yTo, &this->zTo, settings->forceP1, settings->firstModelOnly );
776 
777  //================================================ Remove negative values if so required
778  if ( settings->removeNegativeDensity ) { for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { if ( this->internalMap[iter] < 0.0 ) { this->internalMap[iter] = 0.0; } } }
779 
780  //================================================ Set the internal variables to correct values
781  this->setPDBMapValues ( );
782 
783  //================================================ Move map back to the original PDB location
784  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->xDimSize, this->yDimSize, this->zDimSize,
785  &this->xFrom, &this->xTo, &this->yFrom, &this->yTo, &this->zFrom, &this->zTo,
786  &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin );
787  ProSHADE_internal_mapManip::moveMapByFourier ( this->internalMap, xMov, yMov, zMov, this->xDimSize, this->yDimSize, this->zDimSize,
788  static_cast< proshade_signed > ( this->xDimIndices ), static_cast< proshade_signed > ( this->yDimIndices ),
789  static_cast< proshade_signed > ( this->zDimIndices ) );
790 
791  //================================================ If specific resolution is requested, make sure the map has it
792  this->reSampleMap ( settings );
793 
794  //================================================ Save the original sizes
795  this->xDimSizeOriginal = this->xDimSize;
796  this->yDimSizeOriginal = this->yDimSize;
797  this->zDimSizeOriginal = this->zDimSize;
798 
799  //================================================ Save the original index counts
800  this->xDimIndicesOriginal = this->xDimIndices;
801  this->yDimIndicesOriginal = this->yDimIndices;
802  this->zDimIndicesOriginal = this->zDimIndices;
803 
804  //================================================ Save the original axis origins
805  this->xAxisOriginOriginal = this->xAxisOrigin;
806  this->yAxisOriginOriginal = this->yAxisOrigin;
807  this->zAxisOriginOriginal = this->zAxisOrigin;
808 
809  //================================================ Compute and save the COM
810  this->findMapCOM ( );
811  this->originalMapXCom = this->xCom;
812  this->originalMapYCom = this->yCom;
813  this->originalMapZCom = this->zCom;
814 
815  //================================================ Done
816  return;
817 
818 }

◆ readInMAP()

void ProSHADE_internal_data::ProSHADE_data::readInMAP ( ProSHADE_settings settings,
proshade_double *  maskArr = nullptr,
proshade_unsign  maskXDim = 0,
proshade_unsign  maskYDim = 0,
proshade_unsign  maskZDim = 0,
proshade_double *  weightsArr = nullptr,
proshade_unsign  weigXDim = 0,
proshade_unsign  weigYDim = 0,
proshade_unsign  weigZDim = 0 
)
protected

Function for reading map data using gemmi library.

This function reads in the map data using the information from the settings object and saves all the results into the structure calling it. More specifically, the data are parsed from the input file, mask (if any is supplied) is applied here, the Fourier weights are applied, map re-sampling is done and then the final map details are saved for further processing.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.
[in]maskArrAn array of mask values (default nullptr) to be used instead of an input mask file.
[in]maskXDimThe size of maskArray x dimension in indices (defaults to 0).
[in]maskYDimThe size of maskArray y dimension in indices (defaults to 0).
[in]maskZDimThe size of maskArray z dimension in indices (defaults to 0).
[in]weightsArrAn array of weights (default nullptr) to be used instead of input file.
[in]weigXDimThe size of weightsArray x dimension in indices (defaults to 0).
[in]weigYDimThe size of weightsArray y dimension in indices (defaults to 0).
[in]weigZDimThe size of weightsArray z dimension in indices (defaults to 0).

Definition at line 619 of file ProSHADE_data.cpp.

620 {
621  //================================================ Open the file
622  gemmi::Ccp4<float> map;
623  map.read_ccp4 ( gemmi::MaybeGzipped ( this->fileName.c_str() ) );
624 
625  //================================================ Convert to XYZ and create complete map, if need be
626  map.setup ( gemmi::GridSetup::ReorderOnly, NAN );
627 
628  //================================================ Read in the rest of the map file header
630  &this->xDimIndices, &this->yDimIndices, &this->zDimIndices,
631  &this->xDimSize, &this->yDimSize, &this->zDimSize,
632  &this->aAngle, &this->bAngle, &this->cAngle,
633  &this->xFrom, &this->yFrom, &this->zFrom,
634  &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin,
635  &this->xAxisOrder, &this->yAxisOrder, &this->zAxisOrder,
636  &this->xGridIndices, &this->yGridIndices, &this->zGridIndices );
637 
638  //================================================ Save the map density to ProSHADE variable
639  ProSHADE_internal_io::readInMapData ( &map, this->internalMap, this->xDimIndices, this->yDimIndices, this->zDimIndices, this->xAxisOrder, this->yAxisOrder, this->zAxisOrder );
640 
641  //================================================ If mask is supplied and the correct task is used
642  ProSHADE_internal_io::applyMask ( this->internalMap, settings->appliedMaskFileName, this->xDimIndices, this->yDimIndices, this->zDimIndices, settings->verbose, settings->messageShift,
643  maskArr, maskXDim, maskYDim, maskZDim );
644 
645  //================================================ Apply Fourier weights
646  ProSHADE_internal_io::applyWeights ( this->internalMap, settings->fourierWeightsFileName, this->xDimIndices, this->yDimIndices, this->zDimIndices, settings->verbose, settings->messageShift,
647  weightsArr, weigXDim, weigYDim, weigZDim );
648 
649  //================================================ Remove negative values if so required
650  if ( settings->removeNegativeDensity ) { for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { if ( this->internalMap[iter] < 0.0 ) { this->internalMap[iter] = 0.0; } } }
651 
652  //================================================ Set resolution if need be
653  if ( settings->requestedResolution < 0.0f )
654  {
655  settings->setResolution ( std::min ( static_cast<proshade_single> ( this->xDimSize ) / static_cast<proshade_single> ( this->xDimIndices ),
656  std::min ( static_cast<proshade_single> ( this->yDimSize ) / static_cast<proshade_single> ( this->yDimIndices ),
657  static_cast<proshade_single> ( this->zDimSize ) / static_cast<proshade_single> ( this->zDimIndices ) ) ) * 2.0f );
658  }
659 
660  //================================================ Set iterators from and to
661  this->figureIndexStartStop ( );
662 
663  //================================================ If specific resolution is requested, make sure the map has it
664  this->reSampleMap ( settings );
665 
666  //================================================ Save the original sizes
667  this->xDimSizeOriginal = this->xDimSize;
668  this->yDimSizeOriginal = this->yDimSize;
669  this->zDimSizeOriginal = this->zDimSize;
670 
671  //================================================ Save the original index counts
672  this->xDimIndicesOriginal = this->xDimIndices;
673  this->yDimIndicesOriginal = this->yDimIndices;
674  this->zDimIndicesOriginal = this->zDimIndices;
675 
676  //================================================ Save the original axis origins
677  this->xAxisOriginOriginal = this->xAxisOrigin;
678  this->yAxisOriginOriginal = this->yAxisOrigin;
679  this->zAxisOriginOriginal = this->zAxisOrigin;
680 
681  //================================================ Compute and save the COM
682  this->findMapCOM ( );
683  this->originalMapXCom = this->xCom;
684  this->originalMapYCom = this->yCom;
685  this->originalMapZCom = this->zCom;
686 
687  //================================================ Done
688 
689 }

◆ readInPDB()

void ProSHADE_internal_data::ProSHADE_data::readInPDB ( ProSHADE_settings settings)
protected

Function for reading pdb data.

This function reads in the pdb data using the information from the settings object, converts the co-ordinates onto a theoretical map and and saves all the results into the structure calling it.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.
Warning
For multiple models, this function works, but the map is not perfectly fitted to the PDB file.

Definition at line 700 of file ProSHADE_data.cpp.

701 {
702  //================================================ Set resolution if need be
703  if ( settings->requestedResolution < 0.0f )
704  {
705  settings->setResolution ( 8.0 );
706  }
707 
708  //================================================ Open PDB file for reading
709  gemmi::Structure pdbFile = gemmi::read_structure ( gemmi::MaybeGzipped ( this->fileName ) );
710 
711  //================================================ Once we have Gemmi object, run the Gemmi function
712  this->readInGemmi ( pdbFile, settings );
713 
714  //================================================ Done
715  return;
716 
717 }

◆ readInStructure() [1/2]

void ProSHADE_internal_data::ProSHADE_data::readInStructure ( gemmi::Structure  gemmiStruct,
proshade_unsign  inputO,
ProSHADE_settings settings 
)

This function initialises the basic ProSHADE_data variables and reads in a single structure from Gemmi co-ordinate object.

This function is basically the constructor for the ProSHADE_data class. It reads in a structure from the supplied gemmi::Structure object in the same way a co-ordinate structure would be read from file.

Parameters
[in]gemmiStructThe Gemmi Structure object that should be read in.
[in]inputOThe order of this structure in this run's input.
[in]settingsA pointer to settings class containing all the information required for reading in the map.

Definition at line 567 of file ProSHADE_data.cpp.

568 {
569  //================================================ Report function start
570  std::stringstream ss;
571  ss << "Starting to load the structure from Gemmi object " << inputO;
572  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, ss.str(), settings->messageShift );
573 
574  //================================================ Check if instance is empty
575  if ( !this->isEmpty )
576  {
577  throw ProSHADE_exception ( "Structure data class not empty.", "E000005", __FILE__, __LINE__, __func__, "Attempted to read in structure into a ProSHADE_data\n : object which already does have structure read in\n : i.e. " + this->fileName );
578  }
579 
580  //================================================ Save the filename
581  this->fileName = gemmiStruct.name;
582 
583  //================================================ Check what is the input format
584  this->fileType = ProSHADE_internal_io::GEMMI;
585 
586  //================================================ Save input order
587  this->inputOrder = inputO;
588 
589  //================================================ Decide how to proceed
590  this->readInGemmi ( gemmiStruct, settings );
591 
592  //================================================ This structure is now full
593  this->isEmpty = false;
594 
595  //================================================ Report function completion
596  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Structure read in successfully.", settings->messageShift );
597 
598  //================================================ Done
599  return ;
600 
601 }

◆ readInStructure() [2/2]

void ProSHADE_internal_data::ProSHADE_data::readInStructure ( std::string  fName,
proshade_unsign  inputO,
ProSHADE_settings settings,
proshade_double *  maskArr = nullptr,
proshade_unsign  maskXDim = 0,
proshade_unsign  maskYDim = 0,
proshade_unsign  maskZDim = 0,
proshade_double *  weightsArr = nullptr,
proshade_unsign  weigXDim = 0,
proshade_unsign  weigYDim = 0,
proshade_unsign  weigZDim = 0 
)

This function initialises the basic ProSHADE_data variables and reads in a single structure.

This function is basically the constructor for the ProSHADE_data class. It reads in a structure (independent of the structure type) and fills in all the appropriate variables of the class.

Parameters
[in]fNameThe file name of the file which should be loaded.
[in]inputOThe order of this structure in this run's input.
[in]settingsA pointer to settings class containing all the information required for reading in the map.
[in]maskArrAn array of mask values (default nullptr) to be used instead of an input mask file.
[in]maskXDimThe size of maskArray x dimension in indices (defaults to 0).
[in]maskYDimThe size of maskArray y dimension in indices (defaults to 0).
[in]maskZDimThe size of maskArray z dimension in indices (defaults to 0).
[in]weightsArrAn array of weights (default nullptr) to be used instead of input file.
[in]weigXDimThe size of weightsArray x dimension in indices (defaults to 0).
[in]weigYDimThe size of weightsArray y dimension in indices (defaults to 0).
[in]weigZDimThe size of weightsArray z dimension in indices (defaults to 0).

Definition at line 509 of file ProSHADE_data.cpp.

510 {
511  //================================================ Report function start
512  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting to read the structure: " + fName, settings->messageShift );
513 
514  //================================================ Check if instance is empty
515  if ( !this->isEmpty )
516  {
517  throw ProSHADE_exception ( "Structure data class not empty.", "E000005", __FILE__, __LINE__, __func__, "Attempted to read in structure into a ProSHADE_data\n : object which already does have structure read in\n : i.e. " + this->fileName );
518  }
519 
520  //================================================ Save the filename
521  this->fileName = fName;
522 
523  //================================================ Check what is the input format
525 
526  //================================================ Save input order
527  this->inputOrder = inputO;
528 
529  //================================================ Decide how to proceed
530  switch ( this->fileType )
531  {
532  case ProSHADE_internal_io::UNKNOWN:
533  throw ProSHADE_exception ( "Unknown file type.", "E000006", __FILE__, __LINE__, __func__, "When attempting to read the file\n : " + this->fileName + "\n : the file extension was determined as unknown. This could\n : mean either that the file does not exist, or that it is\n : not one of the supported extensions." );
534 
535  case ProSHADE_internal_io::GEMMI:
536  throw ProSHADE_exception ( "Unknown file type.", "E000006", __FILE__, __LINE__, __func__, "When attempting to read the file\n : " + this->fileName + "\n : the file extension was determined as unknown. This could\n : mean either that the file does not exist, or that it is\n : not one of the supported extensions." );
537 
538  case ProSHADE_internal_io::PDB:
539  this->readInPDB ( settings );
540  break;
541 
542  case ProSHADE_internal_io::MAP:
543  this->readInMAP ( settings, maskArr, maskXDim, maskYDim, maskZDim, weightsArr, weigXDim, weigYDim, weigZDim );
544  break;
545  }
546 
547  //================================================ This structure is now full
548  this->isEmpty = false;
549 
550  //================================================ Report function completion
551  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Structure read in successfully.", settings->messageShift );
552 
553  //================================================ Done
554  return ;
555 
556 }

◆ removePhaseInormation()

void ProSHADE_internal_data::ProSHADE_data::removePhaseInormation ( ProSHADE_settings settings)

This function removes phase from the map, effectively converting it to Patterson map.

This function is called when the phase information needs to be removed from the internal map representation. It does the forward Fourier transform, removes the phase from the Fourier coefficients and then the inverse Fourier transform, thus resulting with the Patterson map. It does write over the original map.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.

Definition at line 3657 of file ProSHADE_data.cpp.

3658 {
3659  //================================================ Report function start
3660  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Removing phase from the map.", settings->messageShift );
3661 
3662  //================================================ Copy map for processing
3663  fftw_complex* mapCoeffs = new fftw_complex[this->xDimIndices * this->yDimIndices * this->zDimIndices];
3664  fftw_complex* pattersonMap = new fftw_complex[this->xDimIndices * this->yDimIndices * this->zDimIndices];
3665 
3666  //================================================ Check memory allocation
3667  ProSHADE_internal_misc::checkMemoryAllocation ( mapCoeffs, __FILE__, __LINE__, __func__ );
3668  ProSHADE_internal_misc::checkMemoryAllocation ( pattersonMap, __FILE__, __LINE__, __func__ );
3669 
3670  //================================================ Copy data to map
3671  for ( proshade_unsign iter = 0; iter < (this->xDimIndices * this->yDimIndices * this->zDimIndices); iter++ )
3672  {
3673  pattersonMap[iter][0] = this->internalMap[iter];
3674  pattersonMap[iter][1] = 0.0;
3675  }
3676 
3677  //================================================ Prepare FFTW plans
3678  fftw_plan forward = fftw_plan_dft_3d ( static_cast< int > ( this->xDimIndices ), static_cast< int > ( this->yDimIndices ), static_cast< int > ( this->zDimIndices ),
3679  pattersonMap, mapCoeffs, FFTW_FORWARD, FFTW_ESTIMATE );
3680  fftw_plan inverse = fftw_plan_dft_3d ( static_cast< int > ( this->xDimIndices ), static_cast< int > ( this->yDimIndices ), static_cast< int > ( this->zDimIndices ),
3681  mapCoeffs, pattersonMap, FFTW_BACKWARD, FFTW_ESTIMATE );
3682 
3683  //================================================ Run forward Fourier
3684  fftw_execute ( forward );
3685 
3686  //================================================ Remove the phase
3688 
3689  //================================================ Run inverse Fourier
3690  fftw_execute ( inverse );
3691 
3692  //================================================ Save the results
3693  proshade_signed mapIt, patIt, patX, patY, patZ;
3694  for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->xDimIndices ); xIt++ )
3695  {
3696  for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->yDimIndices ); yIt++ )
3697  {
3698  for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->zDimIndices ); zIt++ )
3699  {
3700  //==================================== Centre patterson map
3701  patX = xIt - ( static_cast<proshade_signed> ( this->xDimIndices ) / 2 ); if ( patX < 0 ) { patX += this->xDimIndices; }
3702  patY = yIt - ( static_cast<proshade_signed> ( this->yDimIndices ) / 2 ); if ( patY < 0 ) { patY += this->yDimIndices; }
3703  patZ = zIt - ( static_cast<proshade_signed> ( this->zDimIndices ) / 2 ); if ( patZ < 0 ) { patZ += this->zDimIndices; }
3704 
3705  //==================================== Find indices
3706  mapIt = zIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( yIt + static_cast< proshade_signed > ( this->yDimIndices ) * xIt );
3707  patIt = patZ + static_cast< proshade_signed > ( this->zDimIndices ) * ( patY + static_cast< proshade_signed > ( this->yDimIndices ) * patX );
3708 
3709  //==================================== Copy
3710  this->internalMap[mapIt] = pattersonMap[patIt][0];
3711  }
3712  }
3713  }
3714 
3715  //================================================ Release memory
3716  delete[] pattersonMap;
3717  delete[] mapCoeffs;
3718 
3719  //================================================ Delete FFTW plans
3720  fftw_destroy_plan ( forward );
3721  fftw_destroy_plan ( inverse );
3722 
3723  //================================================ Change settings to reflect Patterson map
3724  if ( !settings->usePhase )
3725  {
3726  this->xDimSize *= 2.0f;
3727  this->yDimSize *= 2.0f;
3728  this->zDimSize *= 2.0f;
3729  settings->setResolution ( settings->requestedResolution * 2.0f );
3730  }
3731 
3732  //================================================ Report function completion
3733  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Phase information removed.", settings->messageShift );
3734 
3735  //================================================ Done
3736  return ;
3737 
3738 }

◆ reportOverlayResults()

void ProSHADE_internal_data::ProSHADE_data::reportOverlayResults ( ProSHADE_settings settings,
std::vector< proshade_double > *  rotationCentre,
std::vector< proshade_double > *  eulerAngles,
std::vector< proshade_double > *  finalTranslation 
)

This function reports the results of the overlay mode.

Parameters
[in]settingsProSHADE_settings object specifying the details of how the computations should be done.
[in]rotationCentrePointer to vector for saving the position of the centre of rotation about which the rotation is to be done.
[in]mapBoxMovementPointer to vector for saving the sum of all translations done internally by ProSHADE to this input map.
[in]eulerAnglesPointer to vector where the three Euler angles will be saved into.
[in]finalTranslationPointer to a vector where the translation required to move structure from origin to optimal overlay with static structure will be saved into.

Definition at line 4512 of file ProSHADE_data.cpp.

4513 {
4514  //================================================ Empty line
4516 
4517  //================================================ Write out rotation centre translation results
4518  std::stringstream rotCen; rotCen << std::setprecision (3) << std::showpos << "The rotation centre to origin translation vector is: " << -rotationCentre->at(0) << " " << -rotationCentre->at(1) << " " << -rotationCentre->at(2);
4519  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, rotCen.str(), settings->messageShift );
4520 
4521  //================================================ Write out rotation matrix about origin
4522  proshade_double* rotMat = new proshade_double[9];
4523  ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
4524  ProSHADE_internal_maths::getRotationMatrixFromEulerZXZAngles ( eulerAngles->at(0), eulerAngles->at(1), eulerAngles->at(2), rotMat );
4525 
4526  std::stringstream rotMatSS;
4527  rotMatSS << std::setprecision (3) << std::showpos << "The rotation matrix about origin is : " << rotMat[0] << " " << rotMat[1] << " " << rotMat[2] << std::endl;
4528  rotMatSS << std::setprecision (3) << std::showpos << " : " << rotMat[3] << " " << rotMat[4] << " " << rotMat[5] << std::endl;
4529  rotMatSS << std::setprecision (3) << std::showpos << " : " << rotMat[6] << " " << rotMat[7] << " " << rotMat[8];
4530  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, rotMatSS.str(), settings->messageShift );
4531 
4532  delete[] rotMat;
4533 
4534  //================================================ Write out origin to overlay translation results
4535  std::stringstream finTrs; finTrs << std::setprecision (3) << std::showpos << "The rotation centre to overlay translation vector is: " << finalTranslation->at(0) << " " << finalTranslation->at(1) << " " << finalTranslation->at(2);
4536  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, finTrs.str(), settings->messageShift );
4537 
4538  //================================================ Done
4539  return ;
4540 
4541 }

◆ reportSymmetryResults()

void ProSHADE_internal_data::ProSHADE_data::reportSymmetryResults ( ProSHADE_settings settings)

This function takes prints the report for symmetry detection.

This is a very simple function which provides the basic textual output for the symmetry detection task.

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection reporting.

Definition at line 3479 of file ProSHADE_data.cpp.

3480 {
3481  //================================================ Improve this!
3482  if ( settings->recommendedSymmetryType == "" )
3483  {
3484  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, "Did not detect any symmetry!", settings->messageShift );
3485  }
3486  else
3487  {
3488  std::stringstream ssHlp;
3489  std::vector< proshade_double > comMove = this->getMapCOMProcessChange ( );
3490  ssHlp << std::endl << "Detected " << settings->recommendedSymmetryType << " symmetry with fold " << settings->recommendedSymmetryFold << " about point [" << comMove.at(0) << " , " << comMove.at(1) << " , " << comMove.at(2) << "] away from centre of mass .";
3491  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str(), settings->messageShift );
3492 
3493  if ( settings->detectedSymmetry.size() > 0 )
3494  {
3495  ssHlp.clear(); ssHlp.str ( "" );
3496  ssHlp << " Fold X Y Z Angle Height Average FSC";
3497  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str(), settings->messageShift );
3498  }
3499  for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( settings->detectedSymmetry.size() ); symIt++ )
3500  {
3501  ssHlp.clear(); ssHlp.str ( "" );
3502  ssHlp << std::showpos << std::fixed << std::setprecision(0) << " " << settings->detectedSymmetry.at(symIt)[0] << std::setprecision(5) << " " << settings->detectedSymmetry.at(symIt)[1] << " " << settings->detectedSymmetry.at(symIt)[2] << " " << settings->detectedSymmetry.at(symIt)[3] << " " << settings->detectedSymmetry.at(symIt)[4] << " " << settings->detectedSymmetry.at(symIt)[5] << " " << settings->detectedSymmetry.at(symIt)[6];
3503  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str(), settings->messageShift );
3504  }
3505 
3506  std::stringstream hlpSS3;
3507  ssHlp.clear(); ssHlp.str ( "" );
3508  hlpSS3 << std::endl << "To facilitate manual checking for symmetries, the following is a list of all detected C symmetries:";
3509  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, hlpSS3.str(), settings->messageShift );
3510 
3511  if ( settings->allDetectedCAxes.size() > 0 )
3512  {
3513  ssHlp.clear(); ssHlp.str ( "" );
3514  ssHlp << " Fold X Y Z Angle Height Average FSC";
3515  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str(), settings->messageShift );
3516  }
3517  for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( settings->allDetectedCAxes.size() ); symIt++ )
3518  {
3519  ssHlp.clear(); ssHlp.str ( "" );
3520  ssHlp << std::showpos << std::fixed << std::setprecision(0) << " " << settings->allDetectedCAxes.at(symIt)[0] << std::setprecision(5) << " " << settings->allDetectedCAxes.at(symIt)[1] << " " << settings->allDetectedCAxes.at(symIt)[2] << " " << settings->allDetectedCAxes.at(symIt)[3] << " " << settings->allDetectedCAxes.at(symIt)[4] << " " << settings->allDetectedCAxes.at(symIt)[5] << " " << settings->allDetectedCAxes.at(symIt)[6];
3521  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str(), settings->messageShift );
3522  }
3523 
3524  }
3525 
3526  //================================================ Done
3527  return ;
3528 
3529 }

◆ reSampleMap()

void ProSHADE_internal_data::ProSHADE_data::reSampleMap ( ProSHADE_settings settings)

This function changes the internal map sampling to conform to particular resolution value.

This function will take the requested resolution value from the settings object and will proceed to change the internal map sampling to conform to requested resolution / 2 and therefore to the requested resolution map.

Parameters
[in]settingsA pointer to settings class containing all the information required for reading in the map.

Definition at line 1440 of file ProSHADE_data.cpp.

1441 {
1442  //================================================ Sanity check
1443  if ( !settings->changeMapResolution && !settings->changeMapResolutionTriLinear ) { return ; }
1444 
1445  //================================================ Initialise the internal variable
1446  proshade_single* changeVals = new proshade_single[6];
1447 
1448  //================================================ Find COM before map re-sampling
1449  proshade_double xMapCOMPreReSampl = 0.0, yMapCOMPreReSampl = 0.0, zMapCOMPreReSampl = 0.0;
1450  ProSHADE_internal_mapManip::findMAPCOMValues ( this->internalMap, &xMapCOMPreReSampl, &yMapCOMPreReSampl, &zMapCOMPreReSampl, this->xDimSize, this->yDimSize, this->zDimSize, this->xFrom, this->xTo, this->yFrom, this->yTo, this->zFrom, this->zTo );
1451 
1452  //================================================ Now re-sample the map
1453  if ( settings->changeMapResolution )
1454  {
1455  ProSHADE_internal_mapManip::reSampleMapToResolutionFourier ( this->internalMap, settings->requestedResolution, this->xDimIndices, this->yDimIndices, this->zDimIndices,
1456  this->xDimSize, this->yDimSize, this->zDimSize, changeVals );
1457 
1458  if ( settings->changeMapResolutionTriLinear )
1459  {
1460  ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Requested both Fourier-space and real-space map re-sampling. Defaulting to only Fourier space re-samplling.", "WM00049" );
1461  }
1462  }
1463  if ( settings->changeMapResolutionTriLinear && !settings->changeMapResolution )
1464  {
1465  ProSHADE_internal_mapManip::reSampleMapToResolutionTrilinear ( this->internalMap, settings->requestedResolution, this->xDimIndices, this->yDimIndices, this->zDimIndices,
1466  this->xDimSize, this->yDimSize, this->zDimSize, changeVals );
1467 
1468  }
1469 
1470  //================================================ Set the internal values to reflect the new map size
1471  this->xDimIndices += static_cast<proshade_unsign> ( changeVals[0] );
1472  this->yDimIndices += static_cast<proshade_unsign> ( changeVals[1] );
1473  this->zDimIndices += static_cast<proshade_unsign> ( changeVals[2] );
1474 
1475  this->xGridIndices = this->xDimIndices;
1476  this->yGridIndices = this->yDimIndices;
1477  this->zGridIndices = this->zDimIndices;
1478 
1479  this->xTo += static_cast<proshade_unsign> ( changeVals[0] );
1480  this->yTo += static_cast<proshade_unsign> ( changeVals[1] );
1481  this->zTo += static_cast<proshade_unsign> ( changeVals[2] );
1482 
1483  this->xDimSize = changeVals[3];
1484  this->yDimSize = changeVals[4];
1485  this->zDimSize = changeVals[5];
1486 
1487  //================================================ Find COM after map re-sampling and corner move
1488  proshade_double xMapCOMPostReSampl = 0.0, yMapCOMPostReSampl = 0.0, zMapCOMPostReSampl = 0.0;
1489  ProSHADE_internal_mapManip::findMAPCOMValues ( this->internalMap, &xMapCOMPostReSampl, &yMapCOMPostReSampl, &zMapCOMPostReSampl, this->xDimSize, this->yDimSize, this->zDimSize, this->xFrom, this->xTo, this->yFrom, this->yTo, this->zFrom, this->zTo );
1490 
1491  //================================================ Figure how much the new map moved
1492  proshade_single xMov = static_cast< proshade_single > ( xMapCOMPostReSampl - xMapCOMPreReSampl );
1493  proshade_single yMov = static_cast< proshade_single > ( yMapCOMPostReSampl - yMapCOMPreReSampl );
1494  proshade_single zMov = static_cast< proshade_single > ( zMapCOMPostReSampl - zMapCOMPreReSampl );
1495 
1496  //================================================ Move by indices (this should be sufficient)
1497  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->xDimSize, this->yDimSize, this->zDimSize, &this->xFrom, &this->xTo,
1498  &this->yFrom, &this->yTo, &this->zFrom, &this->zTo, &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin );
1499 
1500  ProSHADE_internal_mapManip::moveMapByFourier ( this->internalMap, xMov, yMov, zMov, this->xDimSize, this->yDimSize, this->zDimSize,
1501  static_cast< proshade_signed > ( this->xDimIndices ), static_cast< proshade_signed > ( this->yDimIndices ), static_cast< proshade_signed > ( this->zDimIndices ) );
1502 
1503  //================================================ Release memory
1504  delete[] changeVals;
1505 
1506  //================================================ Done
1507  return ;
1508 
1509 }

◆ rotateMapRealSpace()

std::vector< proshade_double > ProSHADE_internal_data::ProSHADE_data::rotateMapRealSpace ( proshade_double  axX,
proshade_double  axY,
proshade_double  axZ,
proshade_double  axAng,
proshade_double *&  map 
)

This function rotates a map based on the given angle-axis rotation.

This function takes the axis and angle of the required rotation as well as a pointer to which the rotated map should be saved into and proceeds to rotate the map in real space using tri-linear interpolation.

Parameters
[in]axXThe x-axis element of the angle-axis rotation representation.
[in]axYThe y-axis element of the angle-axis rotation representation.
[in]axZThe z-axis element of the angle-axis rotation representation.
[in]axAngThe angle about the axis by which the rotation is to be done.
[in]mapA pointer which will be set to point to the rotated map.
[out]retThe rotation centre about which the rotation was done in Angstroms.

Definition at line 632 of file ProSHADE_overlay.cpp.

633 {
634  //================================================ Initialise local variables
635  bool withinBounds = true;
636  proshade_double c000, c001, c010, c011, c100, c101, c110, c111, c00, c01, c10, c11, c0, c1;
637  size_t arrPos = 0;
638  proshade_double xCOM, yCOM, zCOM;
639  std::vector< proshade_double > ret;
640 
641  //================================================ Store sampling rates
642  proshade_single xSampRate = this->xDimSize / static_cast< proshade_single > ( this->xTo - this->xFrom );
643  proshade_single ySampRate = this->yDimSize / static_cast< proshade_single > ( this->yTo - this->yFrom );
644  proshade_single zSampRate = this->zDimSize / static_cast< proshade_single > ( this->zTo - this->zFrom );
645 
646  //================================================ Compute map COM
647  ProSHADE_internal_mapManip::findMAPCOMValues ( this->internalMap, &xCOM, &yCOM, &zCOM, this->xDimSize, this->yDimSize, this->zDimSize, this->xFrom, this->xTo, this->yFrom, this->yTo, this->zFrom, this->zTo );
648 
649  //================================================ Allocate local variables
650  proshade_single *mins = new proshade_single[3];
651  proshade_single *maxs = new proshade_single[3];
652  proshade_single *rotMat = new proshade_single[9];
653  proshade_single *rotVec;
654  proshade_single *interpMins = new proshade_single[3];
655  proshade_single *interpMaxs = new proshade_single[3];
656  proshade_single *interpDiff = new proshade_single[3];
657  proshade_single *movs = new proshade_single[3];
658  map = new proshade_double[ this->xDimIndices * this->yDimIndices * this->zDimIndices ];
659 
660  //================================================ Check memory allocation
661  ProSHADE_internal_misc::checkMemoryAllocation ( mins, __FILE__, __LINE__, __func__ );
662  ProSHADE_internal_misc::checkMemoryAllocation ( maxs, __FILE__, __LINE__, __func__ );
663  ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
664  ProSHADE_internal_misc::checkMemoryAllocation ( interpMins, __FILE__, __LINE__, __func__ );
665  ProSHADE_internal_misc::checkMemoryAllocation ( interpMaxs, __FILE__, __LINE__, __func__ );
666  ProSHADE_internal_misc::checkMemoryAllocation ( interpDiff, __FILE__, __LINE__, __func__ );
667  ProSHADE_internal_misc::checkMemoryAllocation ( movs, __FILE__, __LINE__, __func__ );
668  ProSHADE_internal_misc::checkMemoryAllocation ( map, __FILE__, __LINE__, __func__ );
669 
670  //================================================ Fill map with zeroes
671  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { map[iter] = 0.0; }
672 
673  //================================================ Determine map max's and min's in terms of the hkl system
674  mins[0] = std::floor ( static_cast< proshade_single > ( this->xDimIndices ) / -2.0f );
675  mins[1] = std::floor ( static_cast< proshade_single > ( this->yDimIndices ) / -2.0f );
676  mins[2] = std::floor ( static_cast< proshade_single > ( this->zDimIndices ) / -2.0f );
677 
678  maxs[0] = -mins[0];
679  maxs[1] = -mins[1];
680  maxs[2] = -mins[2];
681 
682  if ( this->xDimIndices % 2 == 0 ) { maxs[0] -= 1.0f; }
683  if ( this->yDimIndices % 2 == 0 ) { maxs[1] -= 1.0f; }
684  if ( this->zDimIndices % 2 == 0 ) { maxs[2] -= 1.0f; }
685 
686  //================================================ Rotate about COM instead of map midpoint
687  movs[0] = 0.0; //( mins[0] - static_cast< proshade_single > ( this->xFrom ) );
688  movs[1] = 0.0; //( mins[1] - static_cast< proshade_single > ( this->yFrom ) );
689  movs[2] = 0.0; //( mins[2] - static_cast< proshade_single > ( this->zFrom ) );
690 
691  //================================================ Save rotation centre
692  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast< proshade_double > ( ( -mins[0] * xSampRate ) + ( static_cast< proshade_single > ( this->xFrom ) * xSampRate ) ) );
693  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast< proshade_double > ( ( -mins[1] * ySampRate ) + ( static_cast< proshade_single > ( this->yFrom ) * ySampRate ) ) );
694  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast< proshade_double > ( ( -mins[2] * zSampRate ) + ( static_cast< proshade_single > ( this->zFrom ) * zSampRate ) ) );
695 
696  //================================================ Get rotation matrix from Euler angles
697  ProSHADE_internal_maths::getRotationMatrixFromAngleAxis ( rotMat, axX, axY, axZ, axAng );
698 
699  //================================================ For each point
700  for ( proshade_single xIt = mins[0]; xIt <= maxs[0]; xIt += 1.0f )
701  {
702  for ( proshade_single yIt = mins[1]; yIt <= maxs[1]; yIt += 1.0f )
703  {
704  for ( proshade_single zIt = mins[2]; zIt <= maxs[2]; zIt += 1.0f )
705  {
706  //==================================== Compute new point position
707  rotVec = ProSHADE_internal_maths::compute3x3MatrixVectorMultiplication ( rotMat, xIt - movs[0], yIt - movs[1], zIt - movs[2] );
708 
709  //==================================== Find surrounding grid points indices and check for boundaries
710  withinBounds = true;
711  for ( size_t posIt = 0; posIt < 3; posIt++ )
712  {
713  //================================ Determine surrounding points indices in this dimension
714  interpMins[posIt] = std::floor ( rotVec[posIt] );
715  interpMaxs[posIt] = interpMins[posIt] + 1.0f;
716 
717  //================================ Check for boundaries
718  if ( ( maxs[posIt] < interpMins[posIt] ) || ( interpMins[posIt] < mins[posIt] ) || ( maxs[posIt] < interpMaxs[posIt] ) || ( interpMaxs[posIt] < mins[posIt] ) )
719  {
720  withinBounds = false;
721  break;
722  }
723 
724  //================================ Compute the difference from position to min index along this axis
725  interpDiff[posIt] = rotVec[posIt] - interpMins[posIt];
726  }
727  if ( !withinBounds ) { continue; }
728 
729  //==================================== Make sure interpolation max's are within bounds
730  for ( size_t posIt = 0; posIt < 3; posIt++ )
731  {
732  interpMaxs[posIt] = std::min ( maxs[posIt], std::max ( mins[posIt], interpMaxs[posIt] ) );
733  }
734 
735  //==================================== Release memory
736  delete[] rotVec;
737 
738  //==================================== Find the surrounding points values from their indices
739  arrPos = static_cast< size_t > ( ( interpMins[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMins[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMins[0] - mins[0] ) ) );
740  c000 = this->internalMap[arrPos];
741 
742  arrPos = static_cast< size_t > ( ( interpMaxs[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMins[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMins[0] - mins[0] ) ) );
743  c001 = this->internalMap[arrPos];
744 
745  arrPos = static_cast< size_t > ( ( interpMins[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMaxs[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMins[0] - mins[0] ) ) );
746  c010 = this->internalMap[arrPos];
747 
748  arrPos = static_cast< size_t > ( ( interpMaxs[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMaxs[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMins[0] - mins[0] ) ) );
749  c011 = this->internalMap[arrPos];
750 
751  arrPos = static_cast< size_t > ( ( interpMins[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMins[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMaxs[0] - mins[0] ) ) );
752  c100 = this->internalMap[arrPos];
753 
754  arrPos = static_cast< size_t > ( ( interpMaxs[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMins[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMaxs[0] - mins[0] ) ) );
755  c101 = this->internalMap[arrPos];
756 
757  arrPos = static_cast< size_t > ( ( interpMins[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMaxs[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMaxs[0] - mins[0] ) ) );
758  c110 = this->internalMap[arrPos];
759 
760  arrPos = static_cast< size_t > ( ( interpMaxs[2] - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( interpMaxs[1] - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( interpMaxs[0] - mins[0] ) ) );
761  c111 = this->internalMap[arrPos];
762 
763  //==================================== Interpolate along x-axis
764  c00 = ( c000 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c100 * static_cast< proshade_double > ( interpDiff[0] ) );
765  c01 = ( c001 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c101 * static_cast< proshade_double > ( interpDiff[0] ) );
766  c10 = ( c010 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c110 * static_cast< proshade_double > ( interpDiff[0] ) );
767  c11 = ( c011 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c111 * static_cast< proshade_double > ( interpDiff[0] ) );
768 
769  //==================================== Interpolate along y-axis
770  c0 = ( c00 * ( 1.0 - static_cast< proshade_double > ( interpDiff[1] ) ) ) + ( c10 * static_cast< proshade_double > ( interpDiff[1] ) );
771  c1 = ( c01 * ( 1.0 - static_cast< proshade_double > ( interpDiff[1] ) ) ) + ( c11 * static_cast< proshade_double > ( interpDiff[1] ) );
772 
773  //==================================== Interpolate along z-axis
774  arrPos = static_cast< size_t > ( ( zIt - mins[2] ) + static_cast< proshade_single > ( this->zDimIndices ) * ( ( yIt - mins[1] ) + static_cast< proshade_single > ( this->yDimIndices ) * ( xIt - mins[0] ) ) );
775  map[arrPos] = ( c0 * ( 1.0 - static_cast< proshade_double > ( interpDiff[2] ) ) ) + ( c1 * static_cast< proshade_double > ( interpDiff[2] ) );
776  }
777  }
778  }
779 
780  //================================================ Release memory
781  delete[] mins;
782  delete[] maxs;
783  delete[] rotMat;
784  delete[] interpMins;
785  delete[] interpMaxs;
786  delete[] interpDiff;
787  delete[] movs;
788 
789  //================================================ Done
790  return ( ret );
791 
792 }

◆ rotateMapRealSpaceInPlace()

std::vector< proshade_double > ProSHADE_internal_data::ProSHADE_data::rotateMapRealSpaceInPlace ( proshade_double  eulA,
proshade_double  eulB,
proshade_double  eulG 
)

This function rotates a map based on the given Euler angles in place.

This function takes the Euler angles of the required rotation and proceeds to make use of the rotateMapRealSpace () function to rotate the map in real space using trilinear interpolation, replacing the original map with the rotated one.

Parameters
[in]eulerAlphaThe rotation expressed as a pointer to Euler alpha angle.
[in]eulerBetaThe rotation expressed as a pointer to Euler beta angle.
[in]eulerGammaThe rotation expressed as a pointer to Euler gamma angle.
[out]retThe rotation centre about which the rotation was done in Angstroms.

Definition at line 805 of file ProSHADE_overlay.cpp.

806 {
807  //================================================ Initialise local variables
808  proshade_double axX, axY, axZ, axAng, tmp, *rMat, *map;
809 
810  //================================================ Allocate local memory
811  rMat = new proshade_double[9];
812 
813  //================================================ Check local memory allocation
814  ProSHADE_internal_misc::checkMemoryAllocation ( rMat, __FILE__, __LINE__, __func__ );
815 
816  //================================================ Convert Euler angles to rotation matrix
818 
819  //================================================ Transpose the rotation matrix
820  tmp = rMat[1];
821  rMat[1] = rMat[3];
822  rMat[3] = tmp;
823 
824  tmp = rMat[2];
825  rMat[2] = rMat[6];
826  rMat[6] = tmp;
827 
828  tmp = rMat[5];
829  rMat[5] = rMat[7];
830  rMat[7] = tmp;
831 
832  //================================================ Convert rotation matrix to angle-axis
833  ProSHADE_internal_maths::getAxisAngleFromRotationMatrix ( rMat, &axX, &axY, &axZ, &axAng );
834 
835  //================================================ Rotate the internal map
836  std::vector< proshade_double > ret = this->rotateMapRealSpace ( axX, axY, axZ, axAng, map );
837 
838  //================================================ Copy the rotated map in place of the internal map
839  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
840  {
841  this->internalMap[iter] = map[iter];
842  }
843 
844  //================================================ Release local memory
845  delete[] rMat;
846  delete[] map;
847 
848  //================================================ Save rotation centre for co-ordinates
849  this->originalPdbRotCenX = ret.at(0);
850  this->originalPdbRotCenY = ret.at(1);
851  this->originalPdbRotCenZ = ret.at(2);
852 
853  //================================================ Done
854  return ( ret );
855 
856 }

◆ rotateMapReciprocalSpace()

void ProSHADE_internal_data::ProSHADE_data::rotateMapReciprocalSpace ( ProSHADE_settings settings,
proshade_double  eulerAlpha,
proshade_double  eulerBeta,
proshade_double  eulerGamma 
)

This function rotates a map based on the given Euler angles.

This function starts by computing the Wigner D matrices for the given Euler angles and then it proceeds to multiply the spherical harmonics coefficients with these, thus producing spherical harmonics coefficients of a rotated structure. Then, it computes the inverse spherical harmonics decomposition, thus obtaining the sphere mapped values for the rotated structure. Finally, it interpolates these sphere mapped values back to Cartesian grid, thus obtaining a map rotated by the given Euler angles.

Parameters
[in]settingsThe settings object specifying how exactly the rotation is to be done.
[in]eulerAlphaThe rotation expressed as a pointer to Euler alpha angle.
[in]eulerBetaThe rotation expressed as a pointer to Euler beta angle.
[in]eulerGammaThe rotation expressed as a pointer to Euler gamma angle.

Definition at line 571 of file ProSHADE_overlay.cpp.

572 {
573  //================================================ Set maximum comparison bandwidth to maximum object bandwidth
574  this->maxCompBand = this->spheres[this->noSpheres-1]->getLocalBandwidth();
575 
576  //================================================ Save map COM after processing but before rotation
577  this->findMapCOM ( );
578  this->mapCOMProcessChangeX += ( this->xCom - this->originalMapXCom );
579  this->mapCOMProcessChangeY += ( this->yCom - this->originalMapYCom );
580  this->mapCOMProcessChangeZ += ( this->zCom - this->originalMapZCom );
581 
582  //================================================ Compute the Wigner D matrices for the Euler angles
583  ProSHADE_internal_wigner::computeWignerMatricesForRotation ( settings, this, -eulerAlpha, eulerBeta, -eulerGamma );
584 
585  //================================================ Initialise rotated Spherical Harmonics memory
586  this->allocateRotatedSHMemory ( );
587 
588  //================================================ Multiply SH coeffs by Wigner
589  this->computeRotatedSH ( );
590 
591  //================================================ Inverse the SH coeffs to shells
592  this->invertSHCoefficients ( );
593 
594  //================================================ Find spherical cut-offs
595  std::vector<proshade_double> lonCO, latCO;
596  ProSHADE_internal_overlay::computeAngularThreshold ( &lonCO, &latCO, settings->maxBandwidth * 2 );
597 
598  //================================================ Allocate memory for the rotated map
599  proshade_double *densityMapRotated = new proshade_double [this->xDimIndices * this->yDimIndices * this->zDimIndices];
600  ProSHADE_internal_misc::checkMemoryAllocation ( densityMapRotated, __FILE__, __LINE__, __func__ );
601  for ( unsigned int iter = 0; iter < static_cast<unsigned int> ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { densityMapRotated[iter] = 0.0; }
602 
603  //================================================ Interpolate onto cartesian grid
604  this->interpolateMapFromSpheres ( densityMapRotated );
605 
606  //================================================ Copy map
607  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
608  {
609  this->internalMap[iter] = densityMapRotated[iter];
610  }
611 
612  //================================================ Release rotated map (original is now rotated)
613  delete[] densityMapRotated;
614 
615  //================================================ Done
616  return ;
617 
618 }

◆ saveDetectedSymmetries()

void ProSHADE_internal_data::ProSHADE_data::saveDetectedSymmetries ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSyms,
std::vector< std::vector< proshade_double > > *  allCs 
)

This function takes the results of point group searches and saves then into the output variables.

This function takes the CSyms as they are returned by the findRequestedCSymmetryFromAngleAxis() or the getCyclicSymmetriesListFromAngleAxis() functions and re-saves then to the output variables of the detectSymmetryFromAngleAxisSpace() function. It also releases the memory of the CSyms argument.

Warning
This function releases the memory of the CSyms argument.
Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]CSymsA pointer to vector
[in]axesA pointer to a vector to which all the axes of the recommended symmetry (if any) will be saved.
[in]allCsA pointer to a vector to which all the detected cyclic symmetries will be saved into.

Definition at line 2276 of file ProSHADE_data.cpp.

2277 {
2278  //================================================ Initialise variables
2279  bool isArgSameAsSettings = true;
2280 
2281  //================================================ For each detected point group
2282  for ( proshade_unsign cIt = 0; cIt < static_cast<proshade_unsign> ( CSyms->size() ); cIt++ )
2283  {
2284  //============================================ Create vector to replace the pointer
2285  std::vector< proshade_double > nextSym;
2286  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms->at(cIt)[0] );
2287  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms->at(cIt)[1] );
2288  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms->at(cIt)[2] );
2289  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms->at(cIt)[3] );
2290  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms->at(cIt)[4] );
2291  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms->at(cIt)[5] );
2292  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms->at(cIt)[6] );
2294 
2295  //============================================ Copy the vector to output variable and if different, then also to settings object
2296  if ( ( cIt == 0 ) && ( settings->allDetectedCAxes.size() == 0 ) ) { isArgSameAsSettings = false; }
2297  if ( !isArgSameAsSettings ) { ProSHADE_internal_misc::addToDoubleVectorVector ( &settings->allDetectedCAxes, nextSym ); }
2298 
2299  //============================================ Release memory
2300  nextSym.clear ( );
2301  delete[] CSyms->at(cIt);
2302  }
2303 
2304  //================================================ Done
2305  return ;
2306 
2307 }

◆ saveRecommendedSymmetry()

void ProSHADE_internal_data::ProSHADE_data::saveRecommendedSymmetry ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSym,
std::vector< proshade_double * > *  DSym,
std::vector< proshade_double * > *  TSym,
std::vector< proshade_double * > *  OSym,
std::vector< proshade_double * > *  ISym,
std::vector< proshade_double * > *  axes,
fftw_complex *  mapData,
fftw_complex *  origCoeffs,
fftw_complex *  fCoeffs,
fftw_plan *  planForwardFourier,
proshade_signed  noBins,
proshade_signed *  binIndexing,
proshade_double **  bindata,
proshade_signed *  binCounts,
proshade_double *&  fscByBin 
)

This function takes all the detected symmetry results and decides on which are to be recommended for this structure.

This function is the brains of symmetry detection in the sense that it decides which symmetry group ProSHADE recommends as being detected. It starts by taking all C symmetries and building a histogram of their peak heights. From this histogram, it determines a threshold which contains only the most reliable axes.

Next, the function tests for all axes being over this threshold for the polyhedral symmetries - I, O and T in this order. If all such axes (with appropriate folds) are found, their FSCs will be checked against the supplied (settings object) threshold (default: 0.80). If all axes pass the FSC test, then the corresponding polyhedral symmetry is determined as recommended.

Should no polyhedral symmetries be found, the list of detected D symmetries will be tested next with very similar approach - both axes are required to pass the peak height threshold as well as the FSC threshold. Should multiple axes pairs pass, the one with the highest fold will be decided as the recommended one.

Finally, if no dihedral symmetry is found, the C symmetries list will be searched, again with the peak height and FSC criteria. If multiple symmetry axes are found, the one with the highest fold will be determined as the recommended one, while if no symmetries axis passes both tests, then no symmetry will be returned as detected.

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]CSymA vector of pointers to double arrays, each array being a single Cyclic symmetry entry.
[in]DSymA vector of pointers to double arrays, each array being a single Dihedral symmetry entry.
[in]TSymA vector of pointers to double arrays, all of which together form the axes of tetrahedral symmetry.
[in]OSymA vector of pointers to double arrays, all of which together form the axes of octahedral symmetry.
[in]ISymA vector of pointers to double arrays, all of which together form the axes of icosahedral symmetry.
[in]axesA vector to which all the axes of the recommended symmetry (if any) will be saved.
[in]mapDataFFTW complex array which will be the input for the Fourier transform done by the planForwardFourier plan.
[in]fCoeffsFFTW complex array where the Fourier transform coefficients will be saved into by the planForwardFourier plan.
[in]origCoeffsFFTW complex array holding already compute Fourier transform of the non-rotated map.
[in]planForwardFourierA prepared FFTW3 plan for transforming the mapData onto fCoeffs.
[in]noBinsThe number of bins as already pre-computed.
[in]binIndexingA map of pre-computed bin assignments for each reflection in the format as outputted by FFTW.
[in]bindataPre-allocated array of dimensions noBins x 12 serving as workspace for the bin summation and FSC computation. This array is modified by the function in case the caller would be interested in these results.
[in]binCountsPre-allocated array of dimension noBins serving to store the bin sizes for FSC computation. This array is modified by the function in case the caller would be interested in these results.
[in]fscByBinThis array will hold FSC values for each bin. This is useful in further computations, but could be internal for FSC only computation.

Definition at line 2558 of file ProSHADE_data.cpp.

2559 {
2560  //================================================ Report progress
2561  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting recommended symmetry decision procedure.", settings->messageShift );
2562 
2563  //================================================ If no C symmetries, nothing to save...
2564  if ( CSym->size() == 0 )
2565  {
2566  settings->setRecommendedSymmetry ( "" );
2567  settings->setRecommendedFold ( 0 );
2568  return;
2569  }
2570 
2571  //================================================ Initialise local variables
2572  proshade_double step = 0.01;
2573  proshade_double sigma = 0.03;
2574  proshade_signed windowSize = 9;
2575  proshade_double IFSCAverage = 0.0, OFSCAverage = 0.0, TFSCAverage = 0.0;
2576  bool IIsBest = false, OIsBest = false, TIsBest = false;
2577 
2578  //================================================ Find the top group minimum threshold using smoothened histogram
2579  proshade_double bestHistPeakStart = ProSHADE_internal_maths::findTopGroupSmooth ( CSym, 5, step, sigma, windowSize );
2580  if ( bestHistPeakStart > settings->peakThresholdMin ) { bestHistPeakStart = settings->peakThresholdMin; }
2581 
2582  //================================================ Report progress
2583  proshade_unsign noPassed = 0; for ( size_t cIt = 0; cIt < CSym->size(); cIt++ ) { if ( CSym->at(cIt)[5] > bestHistPeakStart ) { noPassed += 1; } }
2584  std::stringstream ss;
2585  ss << "Smoothening has resolved in " << noPassed << " C symmetries.";
2586  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, ss.str(), settings->messageShift );
2587  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Starting FSC computation to confirm the C symmetries existence.", settings->messageShift );
2588 
2589  //================================================ Decide if I is the answer
2590  bool alreadyDecided = false;
2591  if ( ISym->size() == 31 )
2592  {
2593  //============================================ Initialise decision vars
2594  proshade_double fscVal = 0.0;
2595  proshade_double fscValAvg = 0.0;
2596 
2597  //============================================ Check if at least one C5 and one C3 with the correct angle have high FSC and peak height
2598  for ( size_t iIt = 0; iIt < 31; iIt++ ) { fscVal = this->computeFSC ( settings, CSym, settings->allDetectedIAxes.at(iIt), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin ); fscValAvg += fscVal; if ( fscVal < settings->fscThreshold ) { fscValAvg = 0.0; break; } }
2599  fscValAvg /= 31.0;
2600  IFSCAverage = fscValAvg;
2601  }
2602 
2603  //================================================ Decide if O is the answer
2604  if ( ( OSym->size() == 13 ) && !alreadyDecided )
2605  {
2606  //============================================ Initialise decision vars
2607  proshade_double fscVal = 0.0;
2608  proshade_double fscValAvg = 0.0;
2609 
2610  //============================================ Check if at least one C5 and one C3 with the correct angle have high FSC and peak height
2611  for ( size_t oIt = 0; oIt < 13; oIt++ ) { fscVal = this->computeFSC ( settings, CSym, settings->allDetectedOAxes.at(oIt), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin ); fscValAvg += fscVal; if ( fscVal < settings->fscThreshold ) { fscValAvg = 0.0; break; } }
2612  fscValAvg /= 13.0;
2613  OFSCAverage = fscValAvg;
2614  }
2615 
2616  //================================================ Decide if T is the answer
2617  if ( ( TSym->size() == 7 ) && !alreadyDecided )
2618  {
2619  //============================================ Initialise decision vars
2620  proshade_double fscVal = 0.0;
2621  proshade_double fscValAvg = 0.0;
2622 
2623  //============================================ Check if at least one C5 and one C3 with the correct angle have high FSC and peak height
2624  for ( size_t tIt = 0; tIt < 7; tIt++ ) { fscVal = this->computeFSC ( settings, CSym, settings->allDetectedTAxes.at(tIt), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin ); fscValAvg += fscVal; if ( fscVal < settings->fscThreshold ) { fscValAvg = 0.0; break; } }
2625  fscValAvg /= 7.0;
2626  TFSCAverage = fscValAvg;
2627  }
2628 
2629  //================================================ If we are using phaseless detection, different threshold needs to be used due to large number of false positives
2630  proshade_double newThres = settings->fscThreshold;
2631  if ( !settings->usePhase )
2632  {
2633  proshade_double phaselessStep = 0.01;
2634  proshade_double phaselessSigma = 0.005;
2635  proshade_signed phaselessWSize = 5;
2636  newThres = ProSHADE_internal_maths::findTopGroupSmooth ( CSym, 6, phaselessStep, phaselessSigma, phaselessWSize, 0.94 );
2637  }
2638 
2639  //================================================ Decide between polyhedral
2640  if ( ( IFSCAverage > std::max( OFSCAverage * 0.9, TFSCAverage * 0.8 ) ) && ( IFSCAverage > newThres ) ) { IIsBest = true; }
2641  if ( ( OFSCAverage > std::max( IFSCAverage * 1.1, TFSCAverage * 0.9 ) ) && ( OFSCAverage > newThres ) ) { OIsBest = true; }
2642  if ( ( TFSCAverage > std::max( IFSCAverage * 1.2, OFSCAverage * 1.1 ) ) && ( TFSCAverage > newThres ) ) { TIsBest = true; }
2643  if ( !IIsBest && !OIsBest && !TIsBest && ( std::max( IFSCAverage, std::max( OFSCAverage, TFSCAverage ) ) > newThres ) )
2644  {
2645  const FloatingPoint< proshade_double > lhsPolyI ( IFSCAverage ), lhsPolyO ( OFSCAverage ), lhsPolyT ( TFSCAverage ), rhsPolyMax ( std::max( IFSCAverage, std::max( OFSCAverage, TFSCAverage ) ) );
2646  if ( lhsPolyI.AlmostEquals( rhsPolyMax ) ) { IIsBest = true; }
2647  if ( lhsPolyO.AlmostEquals( rhsPolyMax ) ) { OIsBest = true; }
2648  if ( lhsPolyT.AlmostEquals( rhsPolyMax ) ) { TIsBest = true; }
2649  }
2650 
2651  //================================================ Now we know I is best polyhedral and conforms to threshold
2652  if ( IIsBest )
2653  {
2654  //============================================ The decision is I
2655  settings->setRecommendedSymmetry ( "I" );
2656  settings->setRecommendedFold ( 0 );
2657  for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedIAxes.size() ); it++ ) { ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(settings->allDetectedIAxes.at(it)) ); }
2658  if ( settings->detectedSymmetry.size() == 0 ) { for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedIAxes.size() ); it++ ) { settings->setDetectedSymmetry ( CSym->at(settings->allDetectedIAxes.at(it)) ); } }
2659 
2660  //============================================ Done
2661  alreadyDecided = true;
2662  }
2663 
2664  //================================================ Now we know O is best polyhedral and conforms to threshold
2665  if ( OIsBest && !alreadyDecided )
2666  {
2667  //============================================ The decision is O
2668  settings->setRecommendedSymmetry ( "O" );
2669  settings->setRecommendedFold ( 0 );
2670  for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedOAxes.size() ); it++ ) { ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(settings->allDetectedOAxes.at(it)) ); }
2671  if ( settings->detectedSymmetry.size() == 0 ) { for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedOAxes.size() ); it++ ) { settings->setDetectedSymmetry ( CSym->at(settings->allDetectedOAxes.at(it)) ); } }
2672 
2673  //============================================ Done
2674  alreadyDecided = true;
2675  }
2676 
2677  //================================================ Now we know T is best polyhedral and conforms to threshold
2678  if ( TIsBest && !alreadyDecided )
2679  {
2680  settings->setRecommendedSymmetry ( "T" );
2681  settings->setRecommendedFold ( 0 );
2682  for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedTAxes.size() ); it++ ) { ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(settings->allDetectedTAxes.at(it)) ); }
2683  if ( settings->detectedSymmetry.size() == 0 ) { for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( settings->allDetectedTAxes.size() ); it++ ) { settings->setDetectedSymmetry ( CSym->at(settings->allDetectedTAxes.at(it)) ); } }
2684 
2685  //============================================ Done
2686  alreadyDecided = true;
2687  }
2688 
2689  //================================================ Decide if D is the answer
2690  if ( ( settings->allDetectedDAxes.size() > 0 ) && ( DSym->size() > 0 ) && !alreadyDecided )
2691  {
2692  //============================================ Initialise decision vars
2693  proshade_signed bestD = -1;
2694  proshade_unsign bestFold = 0;
2695 
2696  //============================================ Find FSCs
2697  for ( size_t dIt = 0; dIt < settings->allDetectedDAxes.size(); dIt++ )
2698  {
2699  //======================================== Do not consider more than top 20, takes time and is unlikely to produce anything...
2700  if ( dIt > 20 ) { continue; }
2701 
2702  //======================================== Check the peak heights
2703  const FloatingPoint< proshade_double > lhs999a ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[5] ), lhs999b ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[5] ), rhs999 ( static_cast< proshade_double > ( -999.9 ) );
2704  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[5] < bestHistPeakStart ) && !( lhs999a.AlmostEquals( rhs999 ) ) ) { continue; }
2705  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[5] < bestHistPeakStart ) && !( lhs999b.AlmostEquals( rhs999 ) ) ) { continue; }
2706 
2707  //======================================== Find FSCs
2708  this->computeFSC ( settings, CSym, settings->allDetectedDAxes.at(dIt).at(0), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2709  this->computeFSC ( settings, CSym, settings->allDetectedDAxes.at(dIt).at(1), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2710  }
2711 
2712  //============================================ Find FSC top group threshold
2713  proshade_double bestHistFSCStart = ProSHADE_internal_maths::findTopGroupSmooth ( CSym, 6, step, sigma, windowSize );
2714 
2715  //============================================ Check if both C symmetries are reliable
2716  for ( size_t dIt = 0; dIt < settings->allDetectedDAxes.size(); dIt++ )
2717  {
2718  //======================================== Check the peak heights
2719  const FloatingPoint< proshade_double > lhs999a2 ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[5] ), lhs999b2 ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[5] ), rhs999 ( static_cast< proshade_double > ( -999.9 ) );
2720  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[5] < bestHistPeakStart ) && !( lhs999a2.AlmostEquals( rhs999 ) ) ) { continue; }
2721  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[5] < bestHistPeakStart ) && !( lhs999b2.AlmostEquals( rhs999 ) ) ) { continue; }
2722 
2723  //======================================== Does this improve the best fold?
2724  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[0] > static_cast< proshade_double > ( bestFold ) ) || ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[0] > static_cast< proshade_double > ( bestFold ) ) )
2725  {
2726  //==================================== Check the FSC vals
2727  if ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[6] < newThres ) { continue; }
2728  if ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[6] < newThres ) { continue; }
2729  if ( std::max ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[6], CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[6] ) < bestHistFSCStart ) { continue; }
2730 
2731  //==================================== All good!
2732  bestFold = static_cast< proshade_unsign > ( std::max ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[0], CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[0] ) );
2733  bestD = static_cast< proshade_signed > ( dIt );
2734  }
2735  }
2736 
2737  //============================================ Anything?
2738  if ( bestD != -1 )
2739  {
2740  //======================================== The decision is D
2741  settings->setRecommendedSymmetry ( "D" );
2742  settings->setRecommendedFold ( static_cast< proshade_unsign > ( std::max ( CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(0))[0], CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(1))[0] ) ) );
2743  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(0)) );
2744  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(1)) );
2745  if ( settings->detectedSymmetry.size() == 0 )
2746  {
2747  settings->setDetectedSymmetry ( CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(0)) );
2748  settings->setDetectedSymmetry ( CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(1)) );
2749  }
2750 
2751  //======================================== Done
2752  alreadyDecided = true;
2753  }
2754  }
2755 
2756  //================================================ Decide if C is the answer
2757  if ( ( CSym->size() > 0 ) && !alreadyDecided )
2758  {
2759  //============================================ Initialise decision vars
2760  proshade_signed bestC = -1;
2761  proshade_unsign bestFold = 0;
2762 
2763  //============================================ Find FSCs for C syms
2764  for ( size_t cIt = 0; cIt < CSym->size(); cIt++ )
2765  {
2766  //======================================== Do not consider more than top 20, takes time and is unlikely to produce anything...
2767  if ( cIt > 15 ) { break; }
2768 
2769  //======================================== Check the peak height
2770  if ( CSym->at(cIt)[5] < bestHistPeakStart ) { continue; }
2771 
2772  //======================================== Compute FSC
2773  this->computeFSC ( settings, CSym, cIt, mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2774  }
2775 
2776  //============================================ Find FSC top group threshold
2777  proshade_double bestHistFSCStart = ProSHADE_internal_maths::findTopGroupSmooth ( CSym, 6, step, sigma, windowSize );
2778 
2779  //============================================ Find reliable C syms
2780  for ( size_t cIt = 0; cIt < CSym->size(); cIt++ )
2781  {
2782  //======================================== Check if this improves the best already found fold
2783  if ( CSym->at(cIt)[0] > static_cast< proshade_double > ( bestFold ) )
2784  {
2785  //==================================== If FSC passes
2786  if ( ( CSym->at(cIt)[6] > newThres ) && ( CSym->at(cIt)[6] >= bestHistFSCStart ) )
2787  {
2788  bestFold = static_cast< proshade_unsign > ( CSym->at(cIt)[0] );
2789  bestC = static_cast< proshade_signed > ( cIt );
2790  }
2791  }
2792  }
2793 
2794  //============================================ Anything?
2795  if ( bestC != -1 )
2796  {
2797  //======================================== The decision is C
2798  settings->setRecommendedSymmetry ( "C" );
2799  settings->setRecommendedFold ( static_cast< proshade_unsign > ( CSym->at( static_cast< size_t > ( bestC ) )[0] ) );
2800  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at( static_cast< size_t > ( bestC ) ) );
2801  if ( settings->detectedSymmetry.size() == 0 ) { settings->setDetectedSymmetry ( CSym->at( static_cast< size_t > ( bestC ) ) ); }
2802 
2803  //======================================== Done
2804  alreadyDecided = true;
2805  }
2806  }
2807 
2808  //================================================ Done
2809  return ;
2810 
2811 }

◆ saveRequestedSymmetryC()

void ProSHADE_internal_data::ProSHADE_data::saveRequestedSymmetryC ( ProSHADE_settings settings,
std::vector< proshade_double * > *  CSym,
std::vector< proshade_double * > *  axes 
)

This function takes the C symmetries and searched for the requested symmetry.

This is a simple search function, which searches the symmetry results for the requested symmetry fold, and if more such symmetries are found, takes the one with the highest average peak height. If the requested fold was found, it will save it to the settings object, while it will set the object to fold 0 if the requested symmetry was not found (although there may be other symmetries present).

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]CSymA vector of pointers to double arrays, each array being a single Cyclic symmetry entry.
[in]axesA vector to which all the axes of the requested symmetry (if any) will be saved.

Definition at line 2824 of file ProSHADE_data.cpp.

2825 {
2826  //================================================ Initialise variables
2827  proshade_unsign bestIndex = 0;
2828  proshade_double highestSym = 0.0;
2829 
2830  //================================================ Search for best fold
2831  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( CSym->size() ); iter++ )
2832  {
2833  //============================================ Check if it is tbe correct fold
2834  const FloatingPoint< proshade_double > lhs1 ( CSym->at(iter)[0] ), rhs1 ( static_cast< proshade_double > ( settings->requestedSymmetryFold ) );
2835  if ( !lhs1.AlmostEquals ( rhs1 ) ) { continue; }
2836 
2837  //============================================ If correct, is it the highest found?
2838  if ( CSym->at(iter)[5] > highestSym )
2839  {
2840  highestSym = CSym->at(iter)[5];
2841  bestIndex = iter;
2842  }
2843  }
2844 
2845  //================================================ Found?
2846  if ( highestSym > 0.0 )
2847  {
2848  settings->setRecommendedSymmetry ( "C" );
2849  settings->setRecommendedFold ( static_cast< proshade_unsign > ( CSym->at(bestIndex)[0] ) );
2850  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(bestIndex) );
2851 
2852  if ( settings->detectedSymmetry.size() == 0 ) { settings->setDetectedSymmetry ( CSym->at(bestIndex) ); }
2853  }
2854  else
2855  {
2856  settings->setRecommendedSymmetry ( "" );
2857  settings->setRecommendedFold ( 0 );
2858  }
2859 
2860  //================================================ Done
2861  return ;
2862 
2863 }

◆ saveRequestedSymmetryD()

void ProSHADE_internal_data::ProSHADE_data::saveRequestedSymmetryD ( ProSHADE_settings settings,
std::vector< proshade_double * > *  DSym,
std::vector< proshade_double * > *  axes,
fftw_complex *  mapData,
fftw_complex *  origCoeffs,
fftw_complex *  fCoeffs,
fftw_plan *  planForwardFourier,
proshade_signed  noBins,
proshade_signed *  binIndexing,
proshade_double **  bindata,
proshade_signed *  binCounts,
proshade_double *&  fscByBin 
)

This function takes the D symmetries and searched for the requested symmetry.

This is a simple search function, which searches the symmetry results for the requested symmetry fold, and if more such symmetries are found, takes the one with the highest average peak height sum. If the requested fold was found, it will save it to the settings object, while it will set the object to fold 0 if the requested symmetry was not found (albeit there may be other symmetries present).

Parameters
[in]settingsA pointer to settings class containing all the information required for map symmetry detection.
[in]DSymA vector of pointers to double arrays, each array being a single Dihedral symmetry entry.
[in]axesA vector to which all the axes of the requested symmetry (if any) will be saved.

Definition at line 2876 of file ProSHADE_data.cpp.

2877 {
2878  //================================================ Initialise variables
2879  proshade_unsign bestIndex = 0;
2880  proshade_double highestSym = 0.0;
2881 
2882  //================================================ Search for best fold
2883  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( DSym->size() ); iter++ )
2884  {
2885  //============================================ Check if it is tbe correct fold
2886  const FloatingPoint< proshade_double > lhs1 ( std::max ( DSym->at(iter)[0], DSym->at(iter)[7] ) ), rhs1 ( static_cast< proshade_double > ( settings->requestedSymmetryFold ) );
2887  if ( !lhs1.AlmostEquals ( rhs1 ) ) { continue; }
2888 
2889  //============================================ Check if peak height is decent
2890  const FloatingPoint< proshade_double > lhs999a ( DSym->at(iter)[5] ), lhs999b ( DSym->at(iter)[12] ), rhs999 ( static_cast< proshade_double > ( -999.9 ) );
2891  if ( ( DSym->at(iter)[5] < settings->peakThresholdMin ) && !( lhs999a.AlmostEquals( rhs999 ) ) ) { continue; }
2892  if ( ( DSym->at(iter)[12] < settings->peakThresholdMin ) && !( lhs999b.AlmostEquals( rhs999 ) ) ) { continue; }
2893 
2894  //============================================ If correct, compute FSC
2895  this->computeFSC ( settings, &DSym->at(iter)[0], mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2896  this->computeFSC ( settings, &DSym->at(iter)[7], mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts, fscByBin );
2897 
2898  //============================================ If best, store it
2899  if ( ( DSym->at(iter)[6] + DSym->at(iter)[13] ) > highestSym )
2900  {
2901  highestSym = ( DSym->at(iter)[6] + DSym->at(iter)[13] );
2902  bestIndex = iter;
2903  }
2904  }
2905 
2906  //================================================ Found?
2907  if ( highestSym > 0.0 )
2908  {
2909  settings->setRecommendedSymmetry ( "D" );
2910  settings->setRecommendedFold ( static_cast< proshade_unsign > ( std::max ( DSym->at(bestIndex)[0], DSym->at(bestIndex)[7] ) ) );
2911  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, &DSym->at(bestIndex)[0] );
2912  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, &DSym->at(bestIndex)[7] );
2913 
2914  if ( settings->detectedSymmetry.size() == 0 )
2915  {
2916  settings->setDetectedSymmetry ( &DSym->at(bestIndex)[0] );
2917  settings->setDetectedSymmetry ( &DSym->at(bestIndex)[7] );
2918  }
2919  }
2920  else
2921  {
2922  settings->setRecommendedSymmetry ( "" );
2923  settings->setRecommendedFold ( 0 );
2924  }
2925 
2926  //================================================ Done
2927  return ;
2928 
2929 }

◆ setEMatrixValue()

void ProSHADE_internal_data::ProSHADE_data::setEMatrixValue ( proshade_unsign  band,
proshade_unsign  order1,
proshade_unsign  order2,
proshade_complex  val 
)

This function allows setting the E matrix value.

Parameters
[in]bandThe band indice of the E matrix to which the value should be assigned.
[in]order1The first order indice of the E matrix to which the value should be assigned.
[in]order2The second order indice of the E matrix to which the value should be assigned.
[in]valThe value which should be saved.

Definition at line 4118 of file ProSHADE_data.cpp.

4119 {
4120  //================================================ Mutate
4121  this->eMatrices[band][order1][order2][0] = val[0];
4122  this->eMatrices[band][order1][order2][1] = val[1];
4123 
4124  //================================================ Done
4125  return ;
4126 
4127 }

◆ setIntegrationWeight()

void ProSHADE_internal_data::ProSHADE_data::setIntegrationWeight ( proshade_double  intW)

This function allows setting the integration weight for the object.

Parameters
[in]intWThe integration weight to be set for this object.

Definition at line 4087 of file ProSHADE_data.cpp.

4088 {
4089  //================================================ Mutate
4090  this->integrationWeight = intW;
4091 
4092  //================================================ Done
4093  return ;
4094 
4095 }

◆ setIntegrationWeightCumul()

void ProSHADE_internal_data::ProSHADE_data::setIntegrationWeightCumul ( proshade_double  intW)

This function allows setting the cumulative integration weight for the object.

Parameters
[in]intWThe integration weight to be added to the current value for this object.

Definition at line 4101 of file ProSHADE_data.cpp.

4102 {
4103  //================================================ Mutate
4104  this->integrationWeight += intW;
4105 
4106  //================================================ Done
4107  return ;
4108 
4109 }

◆ setPDBMapValues()

void ProSHADE_internal_data::ProSHADE_data::setPDBMapValues ( void  )
protected

Function for determining iterator start and stop positions.

This function is called to set the xFrom, yFrom, ..., yTo and zTo iterator values for easier further calculations.

Definition at line 824 of file ProSHADE_data.cpp.

825 {
826  //================================================ Set starts to 0
827  this->xFrom = 0;
828  this->yFrom = 0;
829  this->zFrom = 0;
830 
831  //================================================ Set angles to 90 degrees
832  this->aAngle = 90.0;
833  this->bAngle = 90.0;
834  this->cAngle = 90.0;
835 
836  //================================================ Set dimension sizes in indices
837  this->xDimIndices = static_cast< proshade_unsign > ( this->xTo );
838  this->yDimIndices = static_cast< proshade_unsign > ( this->yTo );
839  this->zDimIndices = static_cast< proshade_unsign > ( this->zTo );
840 
841  //================================================ Set the to indices properly
842  this->xTo -= 1;
843  this->yTo -= 1;
844  this->zTo -= 1;
845 
846  //================================================ Set grid indexing to cell indexing
847  this->xGridIndices = this->xDimIndices;
848  this->yGridIndices = this->yDimIndices;
849  this->zGridIndices = this->zDimIndices;
850 
851  //================================================ Set axis order
852  this->xAxisOrder = 1;
853  this->yAxisOrder = 2;
854  this->zAxisOrder = 3;
855 
856  //================================================ Set origin to the first index
857  this->xAxisOrigin = this->xFrom;
858  this->yAxisOrigin = this->yFrom;
859  this->zAxisOrigin = this->zFrom;
860 
861  //================================================ Done
862  return ;
863 
864 }

◆ setSO3CoeffValue()

void ProSHADE_internal_data::ProSHADE_data::setSO3CoeffValue ( proshade_unsign  position,
proshade_complex  val 
)

This function allows setting the SOFT coefficient values using array position and value.

Parameters
[in]positionThe 1D array position at which the new value should be saved.
[in]valComplex value to be saved into the array.

Definition at line 4152 of file ProSHADE_data.cpp.

4153 {
4154  //================================================ Mutate
4155  this->so3Coeffs[position][0] = val[0];
4156  this->so3Coeffs[position][1] = val[1];
4157 
4158  //================================================ Done
4159  return ;
4160 
4161 }

◆ setWignerMatrixValue()

void ProSHADE_internal_data::ProSHADE_data::setWignerMatrixValue ( proshade_complex  val,
proshade_unsign  band,
proshade_unsign  order1,
proshade_unsign  order2 
)

This function allows setting the Wigner D matrix value by its band, order1 and order2 co-ordinate.

Parameters
[in]valproshade_complex value of the Wigner D matrix at position band, order1, order2.
[in]bandThe band of the Wigner D matrix value.
[in]order1The first order of the Wigner D matrix value.
[in]order2The second order of the Wigner D matrix value.

Definition at line 4170 of file ProSHADE_data.cpp.

4171 {
4172  //================================================ Mutate
4173  this->wignerMatrices[band][order1][order2][0] = val[0];
4174  this->wignerMatrices[band][order1][order2][1] = val[1];
4175 
4176  //================================================ Done
4177  return ;
4178 
4179 }

◆ shellBandExists()

bool ProSHADE_internal_data::ProSHADE_data::shellBandExists ( proshade_unsign  shell,
proshade_unsign  bandVal 
)

This function checks if particular shell has a particular band.

This function is useful for the progressive shell mapping, where it may not be clear in one part of the code whether a particular shell does or does not have a particular band value. Therefore, this function allows simple check.

Parameters
[in]shellThe index (number) of the shell for which the check should be done.
[in]bandValThe band value which should be sought for the shell.
[out]XTrue if the shell has the band, false otherwise.

Definition at line 3637 of file ProSHADE_data.cpp.

3638 {
3639  if ( this->spheres[shell]->getLocalBandwidth( ) >= bandVal )
3640  {
3641  return ( true );
3642  }
3643  else
3644  {
3645  return ( false );
3646  }
3647 }

◆ shiftToBoxCentre()

void ProSHADE_internal_data::ProSHADE_data::shiftToBoxCentre ( ProSHADE_settings settings)

Function for shifting map so that its centre of box is at required position.

This function takes a real world position and shifts the map so that this position is at the centre of the box. This is very useful if you know which position you want, for example, symmetry to be computed over.

Parameters
[in]settingsA pointer to settings class containing all the information required for processing of the map.

Definition at line 1075 of file ProSHADE_data.cpp.

1076 {
1077  //================================================ Report function start
1078  std::stringstream ss;
1079  ss << "Moving map box centre to " << settings->boxCentre.at(0) << "; " << settings->boxCentre.at(1) << "; " << settings->boxCentre.at(2) << " .";
1080  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, ss.str(), settings->messageShift );
1081 
1082  //================================================ Figure sampling rates
1083  proshade_double xSamplingRate = static_cast<proshade_double> ( this->xDimSize ) / static_cast<proshade_double> ( this->xDimIndices );
1084  proshade_double ySamplingRate = static_cast<proshade_double> ( this->yDimSize ) / static_cast<proshade_double> ( this->yDimIndices );
1085  proshade_double zSamplingRate = static_cast<proshade_double> ( this->zDimSize ) / static_cast<proshade_double> ( this->zDimIndices );
1086 
1087  //================================================ Figure the box centre
1088  proshade_double startCentreX = ( ( ( static_cast<proshade_double> ( this->xTo ) - static_cast<proshade_double> ( this->xFrom ) ) / 2.0 ) * xSamplingRate );
1089  proshade_double startCentreY = ( ( ( static_cast<proshade_double> ( this->yTo ) - static_cast<proshade_double> ( this->yFrom ) ) / 2.0 ) * ySamplingRate );
1090  proshade_double startCentreZ = ( ( ( static_cast<proshade_double> ( this->zTo ) - static_cast<proshade_double> ( this->zFrom ) ) / 2.0 ) * zSamplingRate );
1091 
1092  //================================================ Figure the requested point distance from box start
1093  proshade_double boxStartX = settings->boxCentre.at(0) - ( static_cast<proshade_double> ( this->xFrom ) * xSamplingRate );
1094  proshade_double boxStartY = settings->boxCentre.at(1) - ( static_cast<proshade_double> ( this->yFrom ) * ySamplingRate );
1095  proshade_double boxStartZ = settings->boxCentre.at(2) - ( static_cast<proshade_double> ( this->zFrom ) * zSamplingRate );
1096 
1097  //================================================ Figure the shift
1098  proshade_double xShift = startCentreX - boxStartX;
1099  proshade_double yShift = startCentreY - boxStartY;
1100  proshade_double zShift = startCentreZ - boxStartZ;
1101 
1102  //================================================ If requested point outside of map, complain
1103  if ( ( ( settings->boxCentre.at(0) < ( static_cast<proshade_double> ( this->xFrom ) * xSamplingRate ) ) ||
1104  ( settings->boxCentre.at(0) > ( static_cast<proshade_double> ( this->xFrom ) * xSamplingRate + static_cast<proshade_double> ( this->xDimSize ) ) ) ) ||
1105  ( ( settings->boxCentre.at(1) < ( static_cast<proshade_double> ( this->yFrom ) * ySamplingRate ) ) ||
1106  ( settings->boxCentre.at(1) > ( static_cast<proshade_double> ( this->yFrom ) * ySamplingRate + static_cast<proshade_double> ( this->yDimSize ) ) ) ) ||
1107  ( ( settings->boxCentre.at(2) < ( static_cast<proshade_double> ( this->zFrom ) * zSamplingRate ) ) ||
1108  ( settings->boxCentre.at(2) > ( static_cast<proshade_double> ( this->zFrom ) * zSamplingRate + static_cast<proshade_double> ( this->zDimSize ) ) ) ) )
1109  {
1110  ProSHADE_internal_messages::printWarningMessage ( settings->verbose, "!!! ProSHADE WARNING !!! Requested box centre to be co-ordinate position outside of co-ordinates range. Please re-view the requested box centre position.", "WM00068" );
1111  }
1112 
1113  //================================================ Do the shift
1115  static_cast< proshade_single > ( xShift ),
1116  static_cast< proshade_single > ( yShift ),
1117  static_cast< proshade_single > ( zShift ),
1118  this->xDimSize, this->yDimSize, this->zDimSize,
1119  static_cast< proshade_signed > ( this->xDimIndices ),
1120  static_cast< proshade_signed > ( this->yDimIndices ),
1121  static_cast< proshade_signed > ( this->zDimIndices ) );
1122 
1123  //================================================ Report function completion
1124  std::stringstream ss2;
1125  ss2 << "Position " << settings->boxCentre.at(0) << "; " << settings->boxCentre.at(1) << "; " << settings->boxCentre.at(2) << " set at the centre of the map box.";
1126  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, ss2.str(), settings->messageShift );
1127 
1128  //================================================ Done
1129  return ;
1130 
1131 }

◆ shiftToRotationCentre()

void ProSHADE_internal_data::ProSHADE_data::shiftToRotationCentre ( ProSHADE_settings settings)

Function for shifting map so that its rotation centre is at the centre of the box.

This function takes the distance between the detected optimal centre of rotation (as detected by the specialised task) and the centre of the map and proceeds to shift the map so that these two positions would be the same.

Parameters
[in]settingsA pointer to settings class containing all the information required for processing of the map.

Definition at line 1140 of file ProSHADE_data.cpp.

1141 {
1142  //================================================ Report function start
1143  std::stringstream ss;
1144  ss << "Shifting map rotation centre ( " << settings->centrePosition.at(0) << "; " << settings->centrePosition.at(1) << "; " << settings->centrePosition.at(2) << " ) to the centre of the box.";
1145  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, ss.str(), settings->messageShift );
1146 
1147  //================================================ Do the shift
1149  static_cast< proshade_single > ( -settings->centrePosition.at(0) ),
1150  static_cast< proshade_single > ( -settings->centrePosition.at(1) ),
1151  static_cast< proshade_single > ( -settings->centrePosition.at(2) ),
1152  this->xDimSize, this->yDimSize, this->zDimSize,
1153  static_cast< proshade_signed > ( this->xDimIndices ),
1154  static_cast< proshade_signed > ( this->yDimIndices ),
1155  static_cast< proshade_signed > ( this->zDimIndices ) );
1156 
1157  //================================================ Report function completion
1158  std::stringstream ss2;
1159  ss2 << "Map shifted by " << settings->centrePosition.at(0) << "; " << settings->centrePosition.at(1) << "; " << settings->centrePosition.at(2) << " A.";
1160  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, ss2.str(), settings->messageShift );
1161 
1162  //================================================ Done
1163  return ;
1164 
1165 }

◆ so3CoeffsArrayIndex()

int ProSHADE_internal_data::ProSHADE_data::so3CoeffsArrayIndex ( proshade_signed  order1,
proshade_signed  order2,
proshade_signed  band 
)

This function gets the SO(3) coefficients array index for a particular so(3) band, order1 and order2 position.

It should be noted that this function assumes that the orders are in the format -l < 0 < l and NOT 0 < 2l + 1.

Parameters
[in]order1The first order for which the SO(3) value index is requested.
[in]order2The second order for which the SO(3) value index is requested.
[in]bandThe band for which the SO(3) value index is requested.
[out]valIndex position of the SO(3) value.

Definition at line 4266 of file ProSHADE_data.cpp.

4267 {
4268  //================================================ Return the value
4269  return ( static_cast<int> ( so3CoefLoc ( static_cast< int > ( order1 ), static_cast< int > ( order2 ), static_cast< int > ( band ), static_cast< int > ( this->getMaxBand() ) ) ) );
4270 }

◆ translateMap()

void ProSHADE_internal_data::ProSHADE_data::translateMap ( proshade_double  trsX,
proshade_double  trsY,
proshade_double  trsZ 
)

This function simply translates the map by a given number of Angstroms along the three axes.

This function calls the internal functions to first provide the maximum possible movement by changing the frame of the map and secondly, it make the precise movement within this new frame using the Fourier translation approach.

Parameters
[in]settingsThe settings object specifying how exactly the rotation is to be done.
[in]trsXThe translation expressed as a number of angstroms to move by along the x-axis.
[in]trsYThe translation expressed as a number of angstroms to move by along the y-axis.
[in]trsZThe translation expressed as a number of angstroms to move by along the z-axis.

Definition at line 868 of file ProSHADE_overlay.cpp.

869 {
870  //================================================ Initialise local variables
871  proshade_single xMov = static_cast< proshade_single > ( -trsX );
872  proshade_single yMov = static_cast< proshade_single > ( -trsY );
873  proshade_single zMov = static_cast< proshade_single > ( -trsZ );
874 
875  //================================================ Move the whole map frame to minimise the Fourier movement
876  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
877  this->getXFromPtr(), this->getXToPtr(), this->getYFromPtr(), this->getYToPtr(),
878  this->getZFromPtr(), this->getZToPtr(), this->getXAxisOrigin(), this->getYAxisOrigin(), this->getZAxisOrigin() );
879 
880  //================================================ Finalise the movement by in-frame Fourier movement
881  ProSHADE_internal_mapManip::moveMapByFourier ( this->getInternalMap(), xMov, yMov, zMov, this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
882  static_cast< proshade_signed > ( this->getXDim() ), static_cast< proshade_signed > ( this->getYDim() ),
883  static_cast< proshade_signed > ( this->getZDim() ) );
884 
885  //================================================ Done
886  return ;
887 
888 }

◆ writeGemmi()

void ProSHADE_internal_data::ProSHADE_data::writeGemmi ( std::string  fName,
gemmi::Structure  gemmiStruct,
proshade_double  euA = 0.0,
proshade_double  euB = 0.0,
proshade_double  euG = 0.0,
proshade_double  trsX = 0.0,
proshade_double  trsY = 0.0,
proshade_double  trsZ = 0.0,
proshade_double  rotX = 0.0,
proshade_double  rotY = 0.0,
proshade_double  rotZ = 0.0,
bool  firstModel = true 
)

This function writes out the gemmi::Structure object with ProSHADE type rotation and translation applied.

This function takes loaded gemmi::Structure object and applies specific rotation and translations to it. These are intended to be the results of ProSHADE Overlay mode compuations, but could be anything else, as long as the usage is correct. Finally, it writes out a PDB formatted file with the now positions.

Parameters
[in]fNameThe filename (including path) to where the output PDB file should be saved.
[in]gemmiStructgemmi::Structure object which should be modified and written out.
[in]euAThe Euler angle alpha by which the co-ordinates should be rotated (leave empty if no rotation is required).
[in]euBThe Euler angle beta by which the co-ordinates should be rotated (leave empty if no rotation is required).
[in]euGThe Euler angle gamma by which the co-ordinates should be rotated (leave empty if no rotation is required).
[in]trsXThe translation to be done along X-axis in Angstroms.
[in]trsYThe translation to be done along Y-axis in Angstroms.
[in]trsZThe translation to be done along Z-axis in Angstroms.
[in]rotXThe translation to be done along X-axis in Angstroms.
[in]rotYThe translation to be done along Y-axis in Angstroms.
[in]rotZThe translation to be done along Z-axis in Angstroms.
[in]firstModelShould only the first model, or rather all of them be used?

Definition at line 996 of file ProSHADE_data.cpp.

997 {
998  //================================================ If the map was rotated, do the same for the co-ordinates, making sure we take into account the rotation centre of the map
999  if ( ( euA != 0.0 ) || ( euB != 0.0 ) || ( euG != 0.0 ) )
1000  {
1001  //============================================ Rotate the co-ordinates
1002  ProSHADE_internal_mapManip::rotatePDBCoordinates ( &gemmiStruct, euA, euB, euG, rotX, rotY, rotZ, firstModel );
1003  }
1004 
1005  //================================================ Translate by required translation and the map centering (if applied)
1006  ProSHADE_internal_mapManip::translatePDBCoordinates ( &gemmiStruct, trsX, trsY, trsZ, firstModel );
1007 
1008  //================================================ Write the PDB file
1009  std::ofstream outCoOrdFile;
1010  outCoOrdFile.open ( fName.c_str() );
1011 
1012  if ( outCoOrdFile.is_open() )
1013  {
1014  gemmi::PdbWriteOptions opt;
1015  write_pdb ( gemmiStruct, outCoOrdFile, opt );
1016  }
1017  else
1018  {
1019  std::stringstream hlpMessage;
1020  hlpMessage << "Failed to open the PDB file " << fName << " for output.";
1021  throw ProSHADE_exception ( hlpMessage.str().c_str(), "EP00048", __FILE__, __LINE__, __func__, "ProSHADE has failed to open the PDB output file. This is\n : likely caused by either not having the write privileges\n : to the required output path, or by making a mistake in\n : the path." );
1022  }
1023 
1024  outCoOrdFile.close ( );
1025 
1026  //================================================ Done
1027  return ;
1028 }

◆ writeMap()

void ProSHADE_internal_data::ProSHADE_data::writeMap ( std::string  fName,
std::string  title = "Created by ProSHADE and written by GEMMI",
int  mode = 2 
)

Function for writing out the internal structure representation in MRC MAP format.

This function takes all the internal map representation information from the calling object and proceeds to write all this information in MRC MAP format for visualisation and possibly further processing by other software. This function will write out axis order XYZ and spacegroup P1 irrespective of the input axis order and spacegroup.

Parameters
[in]fNameThe filename (including path) to where the output MAP file should be saved.
[in]titleString with the map title to be written into the header - default value is "Created by ProSHADE and written by GEMMI"
[in]modeThe type of the data, leave at default 2 (mean float type) unless you specifically required other types.

Definition at line 892 of file ProSHADE_data.cpp.

893 {
894  //================================================ Create and prepare new Grid gemmi object
895  gemmi::Grid<float> mapData;
896  mapData.set_unit_cell ( static_cast< double > ( this->xDimSize ), static_cast< double > ( this->yDimSize ), static_cast< double > ( this->zDimSize ), static_cast< double > ( this->aAngle ), static_cast< double > ( this->bAngle ), static_cast< double > ( this->cAngle ) );
897  mapData.set_size_without_checking ( static_cast< int > ( this->xDimIndices ), static_cast< int > ( this->yDimIndices ), static_cast< int > ( this->zDimIndices ) );
898  mapData.axis_order = gemmi::AxisOrder::XYZ;
899  mapData.spacegroup = &gemmi::get_spacegroup_p1();
900 
901  //================================================ Create and prepare new Ccp4 gemmi object
902  gemmi::Ccp4<float> map;
903  map.grid = mapData;
904  map.update_ccp4_header ( mode );
905 
906  //================================================ Fill in the header
908  this->xDimIndices, this->yDimIndices, this->zDimIndices,
909  this->xDimSize, this->yDimSize, this->zDimSize,
910  this->aAngle, this->bAngle, this->cAngle,
911  this->xFrom, this->yFrom, this->zFrom,
912  this->xAxisOrigin, this->yAxisOrigin, this->zAxisOrigin,
913  this->xAxisOrder, this->yAxisOrder, this->zAxisOrder,
914  this->xGridIndices, this->yGridIndices, this->zGridIndices,
915  title, mode );
916 
917  //================================================ Copy internal map to grid
918  proshade_unsign arrPos = 0;
919  for ( proshade_unsign uIt = 0; uIt < this->xDimIndices; uIt++ )
920  {
921  for ( proshade_unsign vIt = 0; vIt < this->yDimIndices; vIt++ )
922  {
923  for ( proshade_unsign wIt = 0; wIt < this->zDimIndices; wIt++ )
924  {
925  arrPos = wIt + this->zDimIndices * ( vIt + this->yDimIndices * uIt );
926  map.grid.set_value ( static_cast< int > ( uIt ), static_cast< int > ( vIt ), static_cast< int > ( wIt ), static_cast<float> ( this->internalMap[arrPos] ) );
927  }
928  }
929  }
930 
931  //================================================ Update the statistics in the header
932  map.update_ccp4_header ( mode, true );
933 
934  //================================================ Write out the map
935  map.write_ccp4_map ( fName );
936 
937  //================================================ Done
938  return ;
939 
940 }

◆ writeMask()

void ProSHADE_internal_data::ProSHADE_data::writeMask ( std::string  fName,
proshade_double *  mask 
)

Function for writing out a mask in MRC MAP format.

This function takes a mask map and the filename and proceeds to write out the mask into the requested file name in th MRC MAP format. It assumes that the mask has the same dimmensions as the map.

Parameters
[in]fileNameThe filename (including path) to where the output should be saved.
[in]maskPointer to the mask map array.

Definition at line 1038 of file ProSHADE_data.cpp.

1039 {
1040  //================================================ Allocate the memory
1041  proshade_double* hlpMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1042  ProSHADE_internal_misc::checkMemoryAllocation ( hlpMap, __FILE__, __LINE__, __func__ );
1043 
1044  //================================================ Copy original map and over-write with the mask
1045  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1046  {
1047  hlpMap[iter] = this->internalMap[iter];
1048  this->internalMap[iter] = mask[iter];
1049  }
1050 
1051  //================================================ Write out the mask
1052  this->writeMap ( fName );
1053 
1054  //================================================ Copy the original map values back
1055  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1056  {
1057  this->internalMap[iter] = hlpMap[iter];
1058  }
1059 
1060  //================================================ Release memory
1061  delete[] hlpMap;
1062 
1063  //================================================ Done
1064  return ;
1065 
1066 }

◆ writeOutOverlayFiles()

void ProSHADE_internal_data::ProSHADE_data::writeOutOverlayFiles ( ProSHADE_settings settings,
proshade_double  eulA,
proshade_double  eulB,
proshade_double  eulG,
std::vector< proshade_double > *  rotCentre,
std::vector< proshade_double > *  ultimateTranslation 
)

This function writes out the rotated map, co-ordinates and transformation JSON file.

This function takes basically all the results of the overlay mode and appropriately applies them to write out the moved density map, if possible the moved co-ordinates and also the overlay operations listing JSON file.

Parameters
[in]settingsA pointer to settings class containing all the information required for map manipulation.
[in]eulAThe Euler alpha angle value, by which the moving structure is to be rotated by.
[in]eulBThe Euler beta angle value, by which the moving structure is to be rotated by.
[in]eulGThe Euler gamma angle value, by which the moving structure is to be rotated by.
[in]rotCentreThe rotation centre position.
[in]ultimateTranslationThe final translation as determined by the translation function.

Definition at line 4478 of file ProSHADE_data.cpp.

4479 {
4480  //================================================ Write out rotated map
4481  std::stringstream fNameHlp;
4482  fNameHlp << settings->overlayStructureName << ".map";
4483  this->writeMap ( fNameHlp.str() );
4484 
4485  //================================================ Write out rotated co-ordinates if possible
4486  if ( ProSHADE_internal_io::isFilePDB ( this->fileName ) )
4487  {
4488  fNameHlp.str("");
4489  fNameHlp << settings->overlayStructureName << ".pdb";
4490  this->writePdb ( fNameHlp.str(), eulA, eulB, eulG, ultimateTranslation->at(0), ultimateTranslation->at(1), ultimateTranslation->at(2), rotCentre->at(0), rotCentre->at(1), rotCentre->at(2), settings->firstModelOnly );
4491  }
4492 
4493  //================================================ Write out the json file with the results
4494  ProSHADE_internal_io::writeRotationTranslationJSON ( rotCentre->at(0), rotCentre->at(1), rotCentre->at(2),
4495  eulA, eulB, eulG,
4496  ultimateTranslation->at(0), ultimateTranslation->at(1), ultimateTranslation->at(2),
4497  settings->rotTrsJSONFile );
4498 
4499  //================================================ Done
4500  return ;
4501 
4502 }

◆ writePdb()

void ProSHADE_internal_data::ProSHADE_data::writePdb ( std::string  fName,
proshade_double  euA = 0.0,
proshade_double  euB = 0.0,
proshade_double  euG = 0.0,
proshade_double  trsX = 0.0,
proshade_double  trsY = 0.0,
proshade_double  trsZ = 0.0,
proshade_double  rotX = 0.0,
proshade_double  rotY = 0.0,
proshade_double  rotZ = 0.0,
bool  firstModel = true 
)

This function writes out the co-ordinates file with ProSHADE type rotation and translation applied.

This function first checks if this internal structure originated from co-ordinate file (only if co-ordinates are provided can they be written out). If so, it will proceed to read in the original co-ordinates into gemmi::Structure object and call the gemmi writing out function.

Parameters
[in]fNameThe filename (including path) to where the output PDB file should be saved.
[in]euAThe Euler angle alpha by which the co-ordinates should be rotated (leave empty if no rotation is required).
[in]euBThe Euler angle beta by which the co-ordinates should be rotated (leave empty if no rotation is required).
[in]euGThe Euler angle gamma by which the co-ordinates should be rotated (leave empty if no rotation is required).
[in]trsXThe translation to be done along X-axis in Angstroms.
[in]trsYThe translation to be done along Y-axis in Angstroms.
[in]trsZThe translation to be done along Z-axis in Angstroms.
[in]rotXThe translation to be done along X-axis in Angstroms.
[in]rotYThe translation to be done along Y-axis in Angstroms.
[in]rotZThe translation to be done along Z-axis in Angstroms.
[in]firstModelShould only the first model, or rather all of them be used?

Definition at line 959 of file ProSHADE_data.cpp.

960 {
961  //================================================ Check for co-ordinate origin
962  if ( !ProSHADE_internal_io::isFilePDB ( this->fileName ) )
963  {
964  throw ProSHADE_exception ( "Cannot write co-ordinate file if the input file did not contain co-ordinates.", "EP00047", __FILE__, __LINE__, __func__, "You have called the WritePDB function on structure which\n : was created by reading in a map. This is not allowed as\n : ProSHADE cannot create co-ordinates from map file." );
965  }
966 
967  //================================================ Open PDB file for reading
968  gemmi::Structure pdbFile = gemmi::read_structure ( gemmi::MaybeGzipped ( this->fileName ) );
969 
970  //================================================ Write out using the gemmi::Structure object
971  this->writeGemmi ( fName, pdbFile, euA, euB, euG, trsX, trsY, trsZ, rotX, rotY, rotZ, firstModel );
972 
973  //================================================ Done
974  return ;
975 }

◆ zeroPaddToDims()

void ProSHADE_internal_data::ProSHADE_data::zeroPaddToDims ( proshade_unsign  xDim,
proshade_unsign  yDim,
proshade_unsign  zDim 
)

This function changes the size of a structure to fit the supplied new limits.

This function increases the map size by symetrically adding zeroes in each required dimension. The first zero is always added AFTER the structure, so for even size increases, there will be misplacement of centre of mass. The map position in the "real" world should not change.

Parameters
[in]xDimThe X dimension size to which this structure should be padded into.
[in]yDimThe Y dimension size to which this structure should be padded into.
[in]zDimThe Z dimension size to which this structure should be padded into.

Definition at line 433 of file ProSHADE_overlay.cpp.

434 {
435  //================================================ Sanity check
436  if ( ( this->xDimIndices > xDim ) || ( this->yDimIndices > yDim ) || ( this->zDimIndices > zDim ) )
437  {
438  throw ProSHADE_exception ( "Cannot zero-pad in negative direction.", "EO00034", __FILE__, __LINE__, __func__, "The requested padded size of a structure is smaller than\n : the current size. If the user sees this error, there is\n : likely a considerable bug. Please report this error." );
439  }
440 
441  //================================================ If done, do nothing
442  if ( ( this->xDimIndices == xDim ) && ( this->yDimIndices == yDim ) && ( this->zDimIndices == zDim ) ) { return ; }
443 
444  //================================================ Find out how many zeroes need to be added before and after
445  proshade_unsign addXPre, addYPre, addZPre, addXPost, addYPost, addZPost;
446  ProSHADE_internal_overlay::computeBeforeAfterZeroCounts ( &addXPre, &addYPre, &addZPre, &addXPost, &addYPost, &addZPost, xDim, yDim, zDim, this->xDimIndices, this->yDimIndices, this->zDimIndices );
447 
448  //================================================ Create a new map
449  proshade_double* newMap = new proshade_double [xDim * yDim * zDim];
450 
451  //================================================ Do the hard work
452  ProSHADE_internal_overlay::paddMapWithZeroes ( this->internalMap, newMap, xDim, yDim, zDim, this->xDimIndices, this->yDimIndices, this->zDimIndices, addXPre, addYPre, addZPre );
453 
454  //================================================ Create a new internal map and copy
455  delete[] this->internalMap;
456  this->internalMap = new proshade_double [xDim * yDim * zDim];
457  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( xDim * yDim * zDim ); iter++ ) { this->internalMap[iter] = newMap[iter]; }
458 
459  //================================================ Release memory
460  delete[] newMap;
461 
462  //================================================ Update map related variables
463  this->xDimSize = static_cast< proshade_single > ( xDim ) * ( this->xDimSize / static_cast< proshade_single > ( this->xDimIndices ) );
464  this->yDimSize = static_cast< proshade_single > ( yDim ) * ( this->yDimSize / static_cast< proshade_single > ( this->yDimIndices ) );
465  this->zDimSize = static_cast< proshade_single > ( zDim ) * ( this->zDimSize / static_cast< proshade_single > ( this->zDimIndices ) );
466  this->xDimIndices = xDim ; this->yDimIndices = yDim ; this->zDimIndices = zDim;
467  this->xGridIndices = xDim ; this->yGridIndices = yDim ; this->zGridIndices = zDim;
468  this->xFrom -= addXPre ; this->yFrom -= addYPre ; this->zFrom -= addZPre;
469  this->xTo += addXPost; this->yTo += addYPost; this->zTo += addZPost;
470  this->xAxisOrigin -= addXPre ; this->yAxisOrigin -= addYPre ; this->zAxisOrigin -= addZPre ;
471 
472  //================================================ Done
473  return ;
474 
475 }

The documentation for this class was generated from the following files:
ProSHADE_settings::noIQRsFromMedianNaivePeak
proshade_double noIQRsFromMedianNaivePeak
When doing peak searching, how many IQRs from the median the threshold for peak height should be (in ...
Definition: ProSHADE_settings.hpp:120
ProSHADE_internal_distances::normaliseEMatrices
void normaliseEMatrices(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function normalises the E matrices.
Definition: ProSHADE_distances.cpp:572
sortProSHADESymmetryByPeak
bool sortProSHADESymmetryByPeak(proshade_double *a, proshade_double *b)
This function allows using std::sort to sort vectors of ProSHADE symmetry format..
Definition: ProSHADE_symmetry.cpp:2886
ProSHADE_internal_data::ProSHADE_data::originalMapYCom
proshade_double originalMapYCom
The COM of the first map to be loaded/computed without any furhter changes being reflacted along the ...
Definition: ProSHADE_data.hpp:92
ProSHADE_settings::maxBandwidth
proshade_unsign maxBandwidth
The bandwidth of spherical harmonics decomposition for the largest sphere.
Definition: ProSHADE_settings.hpp:58
ProSHADE_internal_mapManip::addExtraBoundSpace
void addExtraBoundSpace(proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim, proshade_single xAngs, proshade_single yAngs, proshade_single zAngs, proshade_signed *&bounds, proshade_single extraSpace)
This function takes a set of bounds and adds a given number of Angstroms to them.
Definition: ProSHADE_mapManip.cpp:1181
ProSHADE_internal_data::ProSHADE_data::mapMovFromsChangeX
proshade_double mapMovFromsChangeX
When the map is translated, the xFrom and xTo values are changed. This variable holds how much they h...
Definition: ProSHADE_data.hpp:94
ProSHADE_settings::recommendedSymmetryType
std::string recommendedSymmetryType
The symmetry type that ProSHADE finds the best fitting for the structure. Possible values are "" for ...
Definition: ProSHADE_settings.hpp:131
ProSHADE_internal_data::ProSHADE_data::allocateRotatedSHMemory
void allocateRotatedSHMemory(void)
This function allocates the memory required for storing the rotated Spherical Harmonics coefficients.
Definition: ProSHADE_overlay.cpp:892
ProSHADE_internal_mapManip::determinePDBRanges
void determinePDBRanges(gemmi::Structure pdbFile, proshade_single *xFrom, proshade_single *xTo, proshade_single *yFrom, proshade_single *yTo, proshade_single *zFrom, proshade_single *zTo, bool firstModel)
Function for finding the PDB file ranges.
Definition: ProSHADE_mapManip.cpp:72
ProSHADE_internal_symmetry::findTetra3C2s
void findTetra3C2s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the 3 C2 symmetries with correct angles requir...
Definition: ProSHADE_symmetry.cpp:1076
ProSHADE_internal_data::ProSHADE_data::fileName
std::string fileName
This is the original file from which the data were obtained.
Definition: ProSHADE_data.hpp:52
ProSHADE_internal_data::ProSHADE_data::zFrom
proshade_signed zFrom
This is the starting index along the z axis.
Definition: ProSHADE_data.hpp:112
ProSHADE_internal_symmetry::detectOctahedralSymmetry
bool detectOctahedralSymmetry(std::vector< proshade_double * > *CSymList, proshade_double axErr, proshade_double minPeakHeight)
This function takes the list of C symmetries and decides whether basic requirements for octahhedral s...
Definition: ProSHADE_symmetry.cpp:1273
ProSHADE_settings::rotTrsJSONFile
std::string rotTrsJSONFile
The filename to which the rotation and translation operations are to be saved into.
Definition: ProSHADE_settings.hpp:146
ProSHADE_internal_data::ProSHADE_data::xDimIndices
proshade_unsign xDimIndices
This is the size of the map cell x dimension in indices.
Definition: ProSHADE_data.hpp:65
ProSHADE_internal_data::ProSHADE_data::getZDimSize
proshade_single getZDimSize(void)
This function allows access to the map size in angstroms along the Z axis.
Definition: ProSHADE_data.cpp:3919
ProSHADE_internal_mapManip::changePDBBFactors
void changePDBBFactors(gemmi::Structure *pdbFile, proshade_double newBFactorValue, bool firstModel)
Function for changing the PDB B-factor values to a specific single value.
Definition: ProSHADE_mapManip.cpp:446
ProSHADE_internal_data::ProSHADE_data::readInMAP
void readInMAP(ProSHADE_settings *settings, proshade_double *maskArr=nullptr, proshade_unsign maskXDim=0, proshade_unsign maskYDim=0, proshade_unsign maskZDim=0, proshade_double *weightsArr=nullptr, proshade_unsign weigXDim=0, proshade_unsign weigYDim=0, proshade_unsign weigZDim=0)
Function for reading map data using gemmi library.
Definition: ProSHADE_data.cpp:619
ProSHADE_internal_misc::sortSymInvFoldHlp
bool sortSymInvFoldHlp(const proshade_double *a, const proshade_double *b)
This function compares two arrays of two based on the first number, sorting highest first.
Definition: ProSHADE_misc.cpp:321
ProSHADE_internal_data::ProSHADE_data::zDimSizeOriginal
proshade_single zDimSizeOriginal
This is the size of the map cell z dimension in Angstroms.
Definition: ProSHADE_data.hpp:84
ProSHADE_internal_maths::vectorMeanAndSD
void vectorMeanAndSD(std::vector< proshade_double > *vec, proshade_double *&ret)
Function to get vector mean and standard deviation.
Definition: ProSHADE_maths.cpp:121
ProSHADE_internal_io::isFilePDB
bool isFilePDB(std::string fName)
Function determining if the input data type is PDB.
Definition: ProSHADE_io.cpp:32
ProSHADE_internal_spheres::ProSHADE_sphere::getLocalBandwidth
proshade_unsign getLocalBandwidth(void)
This function returns the local bandwidth.
Definition: ProSHADE_spheres.cpp:390
ProSHADE_settings::maxSymmetryFold
proshade_unsign maxSymmetryFold
The highest symmetry fold to search for.
Definition: ProSHADE_settings.hpp:136
ProSHADE_internal_data::ProSHADE_data::xGridIndices
proshade_unsign xGridIndices
As far as I know, this is identical to the xDimIndices.
Definition: ProSHADE_data.hpp:68
ProSHADE_internal_data::ProSHADE_data::translationMap
proshade_complex * translationMap
This is where the translation map will be held, if at all used.
Definition: ProSHADE_data.hpp:133
ProSHADE_internal_data::joinElementsFromDifferentGroups
std::vector< std::vector< proshade_double > > joinElementsFromDifferentGroups(std::vector< std::vector< proshade_double > > *first, std::vector< std::vector< proshade_double > > *second, proshade_double matrixTolerance, bool combine)
This function joins two group element lists using only unique elements.
Definition: ProSHADE_data.cpp:3092
ProSHADE_internal_data::ProSHADE_data::xAxisOrder
proshade_unsign xAxisOrder
This is the order of the x axis.
Definition: ProSHADE_data.hpp:71
ProSHADE_internal_symmetry::findIcos6C5s
void findIcos6C5s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the six C5 symmetries with given angles requir...
Definition: ProSHADE_symmetry.cpp:2032
ProSHADE_internal_data::ProSHADE_data::rotSphericalHarmonics
proshade_complex ** rotSphericalHarmonics
A set of rotated spherical harmonics values arrays for each sphere, used only if map rotation is requ...
Definition: ProSHADE_data.hpp:122
ProSHADE_settings::determineAllSHValues
void determineAllSHValues(proshade_unsign xDim, proshade_unsign yDim, proshade_single xDimAngs, proshade_single yDimAngs, proshade_single zDimAngs)
This function determines all the required values for spherical harmonics computation.
Definition: ProSHADE.cpp:1853
ProSHADE_internal_data::ProSHADE_data::sphericalHarmonics
proshade_complex ** sphericalHarmonics
A set of spherical harmonics values arrays for each sphere.
Definition: ProSHADE_data.hpp:121
ProSHADE_internal_symmetry::predictOctaAxes
void predictOctaAxes(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, proshade_double minPeakHeight)
This function predicts all octahedral point group symmetry axes from the cyclic point groups list.
Definition: ProSHADE_symmetry.cpp:2337
ProSHADE_internal_data::ProSHADE_data::interpolateMapFromSpheres
void interpolateMapFromSpheres(proshade_double *&densityMapRotated)
This function interpolates the density map from the sphere mapped data.
Definition: ProSHADE_overlay.cpp:1114
ProSHADE_internal_data::ProSHADE_data::cAngle
proshade_single cAngle
This is the angle c of the map cell in degrees.
Definition: ProSHADE_data.hpp:64
ProSHADE_internal_symmetry::predictTetraAxes
void predictTetraAxes(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, proshade_double minPeakHeight)
This function predicts all tetrahedral point group symmetry axes from the cyclic point groups list.
Definition: ProSHADE_symmetry.cpp:3558
ProSHADE_internal_data::ProSHADE_data::so3CoeffsInverse
proshade_complex * so3CoeffsInverse
The inverse coefficients obtained by inverse SO(3) Fourier Transform (SOFT) - i.e....
Definition: ProSHADE_data.hpp:130
ProSHADE_internal_data::ProSHADE_data::getXAxisOrigin
proshade_signed * getXAxisOrigin(void)
This function allows access to the map X axis origin value.
Definition: ProSHADE_data.cpp:4019
ProSHADE_internal_symmetry::addAxisUnlessSame
proshade_signed addAxisUnlessSame(proshade_unsign fold, proshade_double axX, proshade_double axY, proshade_double axZ, proshade_double axHeight, proshade_double averageFSC, std::vector< proshade_double * > *prosp, proshade_double axErr)
This function simply creates a new axis from information in aruments and tests if no such axis alread...
Definition: ProSHADE_symmetry.cpp:1657
ProSHADE_internal_data::ProSHADE_data::yCom
proshade_double yCom
The COM of the map after processing along the Y-axis.
Definition: ProSHADE_data.hpp:78
ProSHADE_settings::boundsExtraSpace
proshade_single boundsExtraSpace
The number of extra angstroms to be added to all re-boxing bounds just for safety.
Definition: ProSHADE_settings.hpp:93
ProSHADE_internal_spheres::ProSHADE_rotFun_sphere
This class contains all inputed data for the rotation function angle-axis converted spheres.
Definition: ProSHADE_maths.hpp:58
ProSHADE_exception
This class is the representation of ProSHADE exception.
Definition: ProSHADE_exceptions.hpp:37
ProSHADE_internal_symmetry::findPredictedAxesHeights
void findPredictedAxesHeights(std::vector< proshade_double * > *ret, ProSHADE_internal_data::ProSHADE_data *dataObj, ProSHADE_settings *settings)
This function finds the rotation function value for all axes supplied in the ret parameter.
Definition: ProSHADE_symmetry.cpp:3022
ProSHADE_settings::allDetectedDAxes
std::vector< std::vector< proshade_unsign > > allDetectedDAxes
The vector of all detected dihedral symmetry axes indices in allDetectedCAxes.
Definition: ProSHADE_settings.hpp:156
ProSHADE_settings::blurFactor
proshade_single blurFactor
This is the amount by which B-factors should be increased to create the blurred map for masking.
Definition: ProSHADE_settings.hpp:78
ProSHADE_internal_data::ProSHADE_data::saveDetectedSymmetries
void saveDetectedSymmetries(ProSHADE_settings *settings, std::vector< proshade_double * > *CSyms, std::vector< std::vector< proshade_double > > *allCs)
This function takes the results of point group searches and saves then into the output variables.
Definition: ProSHADE_data.cpp:2276
ProSHADE_settings::maskMap
bool maskMap
Should the map be masked from noise?
Definition: ProSHADE_settings.hpp:80
ProSHADE_settings::requestedSymmetryFold
proshade_unsign requestedSymmetryFold
The fold of the requested symmetry (only applicable to C and D symmetry types).
Definition: ProSHADE_settings.hpp:134
ProSHADE_settings::requestedSymmetryType
std::string requestedSymmetryType
The symmetry type requested by the user. Allowed values are C, D, T, O and I.
Definition: ProSHADE_settings.hpp:133
ProSHADE_internal_data::ProSHADE_data::allocateRRPMemory
void allocateRRPMemory()
This function allocates the required memory for the RRP matrices.
Definition: ProSHADE_distances.cpp:31
ProSHADE_internal_data::ProSHADE_data::getXDimSize
proshade_single getXDimSize(void)
This function allows access to the map size in angstroms along the X axis.
Definition: ProSHADE_data.cpp:3899
ProSHADE_internal_misc::addToUnsignVectorVector
void addToUnsignVectorVector(std::vector< std::vector< proshade_unsign > > *vecToAddTo, std::vector< proshade_unsign > elementToAdd)
Adds the element to the vector of vectors.
Definition: ProSHADE_misc.cpp:211
ProSHADE_internal_data::ProSHADE_data::getInternalMap
proshade_double *& getInternalMap(void)
This function allows access to the first map array value address.
Definition: ProSHADE_data.cpp:4049
ProSHADE_internal_data::ProSHADE_data::noSpheres
proshade_unsign noSpheres
The number of spheres with map projected onto them.
Definition: ProSHADE_data.hpp:119
ProSHADE_settings::removeNegativeDensity
bool removeNegativeDensity
Should the negative density be removed from input files?
Definition: ProSHADE_settings.hpp:47
ProSHADE_internal_data::ProSHADE_data::getYDimSize
proshade_single getYDimSize(void)
This function allows access to the map size in angstroms along the Y axis.
Definition: ProSHADE_data.cpp:3909
ProSHADE_internal_data::ProSHADE_data::inputOrder
proshade_unsign inputOrder
This value is the input order - it is useful to know for writing out files, so that they would not ov...
Definition: ProSHADE_data.hpp:140
ProSHADE_internal_mapManip::getMaskFromBlurr
void getMaskFromBlurr(proshade_double *&blurMap, proshade_double *&outMap, proshade_unsign xDimS, proshade_unsign yDimS, proshade_unsign zDimS, proshade_single noIQRs)
Function for computing mask from blurred map.
Definition: ProSHADE_mapManip.cpp:1074
ProSHADE_internal_data::ProSHADE_data::zDimSize
proshade_single zDimSize
This is the size of the map cell z dimension in Angstroms.
Definition: ProSHADE_data.hpp:61
ProSHADE_internal_data::ProSHADE_data::so3Coeffs
proshade_complex * so3Coeffs
The coefficients obtained by SO(3) Fourier Transform (SOFT), in this case derived from the E matrices...
Definition: ProSHADE_data.hpp:129
ProSHADE_settings::saveMask
bool saveMask
Should the mask be saved?
Definition: ProSHADE_settings.hpp:84
ProSHADE_settings::requestedResolution
proshade_single requestedResolution
The resolution to which the calculations are to be done.
Definition: ProSHADE_settings.hpp:50
ProSHADE_internal_distances::isBandWithinShell
bool isBandWithinShell(proshade_unsign bandInQuestion, proshade_unsign shellInQuestion, ProSHADE_internal_spheres::ProSHADE_sphere **spheres)
This function checks if a band is available for a given shell.
Definition: ProSHADE_distances.cpp:139
ProSHADE_internal_data::ProSHADE_data::mapCOMProcessChangeX
proshade_double mapCOMProcessChangeX
The change in X axis between the creation of the structure (originalMapXCom) and just before rotation...
Definition: ProSHADE_data.hpp:97
ProSHADE_settings::minSymPeak
proshade_double minSymPeak
Minimum average peak for symmetry axis to be considered as "real".
Definition: ProSHADE_settings.hpp:130
ProSHADE_internal_mapManip::findMAPCOMValues
void findMAPCOMValues(proshade_double *map, proshade_double *xCom, proshade_double *yCom, proshade_double *zCom, proshade_single xAngs, proshade_single yAngs, proshade_single zAngs, proshade_signed xFrom, proshade_signed xTo, proshade_signed yFrom, proshade_signed yTo, proshade_signed zFrom, proshade_signed zTo)
This function finds the Centre of Mass for a map.
Definition: ProSHADE_mapManip.cpp:240
ProSHADE_internal_mapManip::blurSharpenMap
void blurSharpenMap(proshade_double *&map, proshade_double *&maskedMap, proshade_unsign xDimS, proshade_unsign yDimS, proshade_unsign zDimS, proshade_single xAngs, proshade_single yAngs, proshade_single zAngs, proshade_single blurringFactor)
Function for blurring/sharpening maps.
Definition: ProSHADE_mapManip.cpp:974
ProSHADE_internal_data::ProSHADE_data::originalMapXCom
proshade_double originalMapXCom
The COM of the first map to be loaded/computed without any furhter changes being reflacted along the ...
Definition: ProSHADE_data.hpp:91
ProSHADE_settings::setDetectedSymmetry
void setDetectedSymmetry(proshade_double *sym)
Sets the final detected symmetry axes information.
Definition: ProSHADE.cpp:1553
ProSHADE_internal_io::applyMask
void applyMask(proshade_double *&map, std::string maskFile, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_signed verbose, proshade_signed messageShift, proshade_double *maskArray=nullptr, proshade_unsign maXInds=0, proshade_unsign maYInds=0, proshade_unsign maZInds=0)
This function reads and applies the mask to the map.
Definition: ProSHADE_io.cpp:295
ProSHADE_internal_data::ProSHADE_data::xDimIndicesOriginal
proshade_unsign xDimIndicesOriginal
This is the size of the map cell x dimension in indices.
Definition: ProSHADE_data.hpp:85
ProSHADE_internal_mapManip::moveMapByFourier
void moveMapByFourier(proshade_double *&map, proshade_single xMov, proshade_single yMov, proshade_single zMov, proshade_single xAngs, proshade_single yAngs, proshade_single zAngs, proshade_signed xDim, proshade_signed yDim, proshade_signed zDim)
Function for moving map back to original PDB location by using Fourier transformation.
Definition: ProSHADE_mapManip.cpp:813
ProSHADE_settings::progressiveSphereMapping
bool progressiveSphereMapping
If true, each shell will have its own angular resolution dependent on the actual number of map points...
Definition: ProSHADE_settings.hpp:107
ProSHADE_internal_mapManip::movePDBForMapCalc
void movePDBForMapCalc(gemmi::Structure *pdbFile, proshade_single xMov, proshade_single yMov, proshade_single zMov, bool firstModel)
Function for moving co-ordinate atoms to better suit theoretical map computation.
Definition: ProSHADE_mapManip.cpp:575
ProSHADE_settings::maxSphereDists
proshade_single maxSphereDists
The distance between spheres in spherical mapping for the largest sphere.
Definition: ProSHADE_settings.hpp:65
ProSHADE_internal_data::ProSHADE_data::maxShellBand
proshade_unsign maxShellBand
The maximum band for any shell of the object.
Definition: ProSHADE_data.hpp:123
ProSHADE_internal_data::ProSHADE_data::originalPdbRotCenY
proshade_double originalPdbRotCenY
The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map...
Definition: ProSHADE_data.hpp:103
ProSHADE_internal_data::ProSHADE_data::getSpherePositions
void getSpherePositions(ProSHADE_settings *settings)
This function determines the sphere positions (radii) for sphere mapping.
Definition: ProSHADE_data.cpp:1746
ProSHADE_internal_data::ProSHADE_data::invertMirrorMap
void invertMirrorMap(ProSHADE_settings *settings)
Function for inverting the map to its mirror image.
Definition: ProSHADE_data.cpp:1175
ProSHADE_internal_maths::getRotationMatrixFromEulerZXZAngles
void getRotationMatrixFromEulerZXZAngles(proshade_double eulerAlpha, proshade_double eulerBeta, proshade_double eulerGamma, proshade_double *matrix)
Function to find the rotation matrix from Euler angles (ZXZ convention).
Definition: ProSHADE_maths.cpp:1020
ProSHADE_internal_data::ProSHADE_data::getDihedralSymmetriesList
std::vector< proshade_double * > getDihedralSymmetriesList(ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
This function obtains a list of all D symmetries from already computed C symmetries list.
Definition: ProSHADE_symmetry.cpp:302
checkElementsFormGroup
bool checkElementsFormGroup(std::vector< std::vector< proshade_double > > *elements, proshade_double matrixTolerance)
This function checks if all group element products produce another group element.
Definition: ProSHADE_data.cpp:3051
ProSHADE_internal_data::ProSHADE_data::getMapCOMProcessChange
std::vector< proshade_double > getMapCOMProcessChange(void)
This function allows access to the translation caused by structure processing.
Definition: ProSHADE_data.cpp:4069
ProSHADE_internal_overlay::computeBeforeAfterZeroCounts
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 dimens...
Definition: ProSHADE_overlay.cpp:492
ProSHADE_internal_data::ProSHADE_data::saveRequestedSymmetryD
void saveRequestedSymmetryD(ProSHADE_settings *settings, std::vector< proshade_double * > *DSym, std::vector< proshade_double * > *axes, fftw_complex *mapData, fftw_complex *origCoeffs, fftw_complex *fCoeffs, fftw_plan *planForwardFourier, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **bindata, proshade_signed *binCounts, proshade_double *&fscByBin)
This function takes the D symmetries and searched for the requested symmetry.
Definition: ProSHADE_data.cpp:2876
ProSHADE_internal_data::ProSHADE_data::mapCOMProcessChangeZ
proshade_double mapCOMProcessChangeZ
The change in Z axis between the creation of the structure (originalMapZCom) and just before rotation...
Definition: ProSHADE_data.hpp:99
ProSHADE_settings::maskingThresholdIQRs
proshade_single maskingThresholdIQRs
Number of inter-quartile ranges from the median to be used for thresholding the blurred map for maski...
Definition: ProSHADE_settings.hpp:79
ProSHADE_settings::usePhase
bool usePhase
If true, the full data will be used, if false, Patterson maps will be used instead and phased data wi...
Definition: ProSHADE_settings.hpp:62
ProSHADE_internal_data::ProSHADE_data::xDimSizeOriginal
proshade_single xDimSizeOriginal
This is the size of the map cell x dimension in Angstroms.
Definition: ProSHADE_data.hpp:82
ProSHADE_settings::allDetectedTAxes
std::vector< proshade_unsign > allDetectedTAxes
The vector of all detected tetrahedral symmetry axes indices in allDetectedCAxes.
Definition: ProSHADE_settings.hpp:157
ProSHADE_internal_messages::printWarningMessage
void printWarningMessage(proshade_signed verbose, std::string message, std::string warnCode)
General stderr message printing (used for warnings).
Definition: ProSHADE_messages.cpp:102
ProSHADE_internal_io::figureDataType
InputType figureDataType(std::string fName)
Function determining input data type.
Definition: ProSHADE_io.cpp:923
ProSHADE_internal_mapManip::reSampleMapToResolutionTrilinear
void reSampleMapToResolutionTrilinear(proshade_double *&map, proshade_single resolution, proshade_unsign xDimS, proshade_unsign yDimS, proshade_unsign zDimS, proshade_single xAngs, proshade_single yAngs, proshade_single zAngs, proshade_single *&corrs)
This function re-samples a map to conform to given resolution using tri-linear interpolation.
Definition: ProSHADE_mapManip.cpp:1217
ProSHADE_internal_data::ProSHADE_data::zAxisOriginOriginal
proshade_signed zAxisOriginOriginal
This is the origin position along the z axis.
Definition: ProSHADE_data.hpp:90
ProSHADE_internal_spheres::ProSHADE_sphere
This class contains all inputed and derived data for a single sphere.
Definition: ProSHADE_spheres.hpp:49
ProSHADE_internal_spheres::ProSHADE_sphere::getRotatedMappedData
proshade_double getRotatedMappedData(proshade_unsign pos)
This function gets the rotated mapped data value for a particular position.
Definition: ProSHADE_spheres.cpp:627
ProSHADE_settings::maskFileName
std::string maskFileName
The filename to which mask should be saved.
Definition: ProSHADE_settings.hpp:85
ProSHADE_settings::allDetectedOAxes
std::vector< proshade_unsign > allDetectedOAxes
The vector of all detected octahedral symmetry axes indices in allDetectedCAxes.
Definition: ProSHADE_settings.hpp:158
ProSHADE_internal_overlay::freeTranslationFunctionMemory
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 comput...
Definition: ProSHADE_overlay.cpp:406
ProSHADE_internal_data::ProSHADE_data::eMatrices
proshade_complex *** eMatrices
The trace sigma and full rotation function c*conj(c) integral tables.
Definition: ProSHADE_data.hpp:127
ProSHADE_internal_data::ProSHADE_data::centreMapOnCOM
void centreMapOnCOM(ProSHADE_settings *settings)
This function shits the map so that its COM is in the centre of the map.
Definition: ProSHADE_data.cpp:1520
ProSHADE_internal_data::ProSHADE_data::getXFromPtr
proshade_signed * getXFromPtr(void)
This function allows access to the map start along the X axis.
Definition: ProSHADE_data.cpp:3959
ProSHADE_settings::verbose
proshade_signed verbose
Should the software report on the progress, or just be quiet? Value between -1 (nothing) and 4 (loud)
Definition: ProSHADE_settings.hpp:149
ProSHADE_internal_data::ProSHADE_data::yDimIndices
proshade_unsign yDimIndices
This is the size of the map cell y dimension in indices.
Definition: ProSHADE_data.hpp:66
ProSHADE_internal_data::ProSHADE_data::xAxisOriginOriginal
proshade_signed xAxisOriginOriginal
This is the origin position along the x axis.
Definition: ProSHADE_data.hpp:88
ProSHADE_settings::messageShift
proshade_signed messageShift
This value allows shifting the messages to create more readable log for sub-processes.
Definition: ProSHADE_settings.hpp:150
ProSHADE_internal_data::ProSHADE_data::yGridIndices
proshade_unsign yGridIndices
As far as I know, this is identical to the yDimIndices.
Definition: ProSHADE_data.hpp:69
ProSHADE_settings::changeMapResolutionTriLinear
bool changeMapResolutionTriLinear
Should maps be re-sampled to obtain the required resolution?
Definition: ProSHADE_settings.hpp:52
ProSHADE_internal_data::ProSHADE_data::zAxisOrigin
proshade_signed zAxisOrigin
This is the origin position along the z axis.
Definition: ProSHADE_data.hpp:76
ProSHADE_internal_misc::addToDoubleVector
void addToDoubleVector(std::vector< proshade_double > *vecToAddTo, proshade_double elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:77
ProSHADE_internal_data::ProSHADE_data::shiftToRotationCentre
void shiftToRotationCentre(ProSHADE_settings *settings)
Function for shifting map so that its rotation centre is at the centre of the box.
Definition: ProSHADE_data.cpp:1140
ProSHADE_internal_data::ProSHADE_data::setPDBMapValues
void setPDBMapValues(void)
Function for determining iterator start and stop positions.
Definition: ProSHADE_data.cpp:824
ProSHADE_internal_data::ProSHADE_data::findMapCOM
void findMapCOM(void)
This function finds the centre of mass of the internal map representation.
Definition: ProSHADE_data.cpp:3535
ProSHADE_internal_data::ProSHADE_data::yDimIndicesOriginal
proshade_unsign yDimIndicesOriginal
This is the size of the map cell y dimension in indices.
Definition: ProSHADE_data.hpp:86
ProSHADE_internal_data::ProSHADE_data::getXDim
proshade_unsign getXDim(void)
This function allows access to the map size in indices along the X axis.
Definition: ProSHADE_data.cpp:3929
ProSHADE_internal_mapManip::removeWaters
void removeWaters(gemmi::Structure *pdbFile, bool firstModel)
This function removed all waters from PDB input file.
Definition: ProSHADE_mapManip.cpp:506
ProSHADE_settings::useBiCubicInterpolationOnPeaks
bool useBiCubicInterpolationOnPeaks
This variable switch decides whether best symmetry is detected from peak indices, or whether bicubic ...
Definition: ProSHADE_settings.hpp:135
ProSHADE_internal_data::ProSHADE_data::originalPdbTransX
proshade_double originalPdbTransX
The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE inte...
Definition: ProSHADE_data.hpp:105
determinePeakThreshold
proshade_double determinePeakThreshold(std::vector< proshade_double > inArr, proshade_double noIQRsFromMedian)
This function takes a vector of values and determines the threshold for removing noise from it.
Definition: ProSHADE_symmetry.cpp:71
ProSHADE_internal_data::ProSHADE_data::zTo
proshade_signed zTo
This is the final index along the z axis.
Definition: ProSHADE_data.hpp:115
ProSHADE_internal_data::ProSHADE_data::computeFSC
proshade_double computeFSC(ProSHADE_settings *settings, std::vector< proshade_double * > *CSym, size_t symIndex, fftw_complex *mapData, fftw_complex *fCoeffs, fftw_complex *origCoeffs, fftw_plan *planForwardFourier, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **&bindata, proshade_signed *&binCounts, proshade_double *&fscByBin)
This function computes FSC for any given axis in the supplied CSym symmetry axes vector.
Definition: ProSHADE_data.cpp:2391
ProSHADE_internal_data::ProSHADE_data::xTo
proshade_signed xTo
This is the final index along the x axis.
Definition: ProSHADE_data.hpp:113
ProSHADE_internal_data::ProSHADE_data::writeMask
void writeMask(std::string fName, proshade_double *mask)
Function for writing out a mask in MRC MAP format.
Definition: ProSHADE_data.cpp:1038
ProSHADE_internal_data::ProSHADE_data::integrationWeight
proshade_double integrationWeight
The Pearson's c.c. type weighting for the integration.
Definition: ProSHADE_data.hpp:128
ProSHADE_settings::peakThresholdMin
proshade_double peakThresholdMin
The threshold for peak height above which axes are considered possible.
Definition: ProSHADE_settings.hpp:138
ProSHADE_internal_data::ProSHADE_data::xAxisOrigin
proshade_signed xAxisOrigin
This is the origin position along the x axis.
Definition: ProSHADE_data.hpp:74
ProSHADE_internal_data::ProSHADE_data::originalPdbTransY
proshade_double originalPdbTransY
The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE inte...
Definition: ProSHADE_data.hpp:106
ProSHADE_internal_wigner::computeWignerMatricesForRotation
void computeWignerMatricesForRotation(ProSHADE_settings *settings, ProSHADE_internal_data::ProSHADE_data *obj, proshade_double eulerAlpha, proshade_double eulerBeta, proshade_double eulerGamma)
This function computes the Wigner D matrices for a particular set of Euler angles.
Definition: ProSHADE_wignerMatrices.cpp:258
ProSHADE_internal_data::ProSHADE_data::rrpMatrices
proshade_double *** rrpMatrices
The energy levels descriptor shell correlation tables.
Definition: ProSHADE_data.hpp:126
ProSHADE_internal_data::ProSHADE_data::yTo
proshade_signed yTo
This is the final index along the y axis.
Definition: ProSHADE_data.hpp:114
ProSHADE_settings::forceP1
bool forceP1
Should the P1 spacegroup be forced on the input PDB files?
Definition: ProSHADE_settings.hpp:44
ProSHADE_internal_data::ProSHADE_data::xDimSize
proshade_single xDimSize
This is the size of the map cell x dimension in Angstroms.
Definition: ProSHADE_data.hpp:59
ProSHADE_internal_symmetry::findIcos10C3s
void findIcos10C3s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the ten C3 symmetries with correct angles requ...
Definition: ProSHADE_symmetry.cpp:2451
ProSHADE_internal_maths::computeDotProduct
proshade_double computeDotProduct(proshade_double *x1, proshade_double *y1, proshade_double *z1, proshade_double *x2, proshade_double *y2, proshade_double *z2)
Simple 3D vector dot product computation.
Definition: ProSHADE_maths.cpp:1788
ProSHADE_internal_data::ProSHADE_data::computeRotatedSH
void computeRotatedSH(void)
This function multiplies the objects spherical harmonics with the Wigner D matrices,...
Definition: ProSHADE_overlay.cpp:920
ProSHADE_internal_mapManip::findPDBCOMValues
void findPDBCOMValues(gemmi::Structure pdbFile, proshade_double *xCom, proshade_double *yCom, proshade_double *zCom, bool firstModel)
This function finds the Centre of Mass for the co-ordinate file.
Definition: ProSHADE_mapManip.cpp:157
ProSHADE_internal_data::ProSHADE_data::mapMovFromsChangeY
proshade_double mapMovFromsChangeY
When the map is translated, the yFrom and yTo values are changed. This variable holds how much they h...
Definition: ProSHADE_data.hpp:95
ProSHADE_internal_data::ProSHADE_data::yAxisOrigin
proshade_signed yAxisOrigin
This is the origin position along the y axis.
Definition: ProSHADE_data.hpp:75
ProSHADE_internal_peakSearch::getBestPeakEulerAngsNaive
void getBestPeakEulerAngsNaive(proshade_complex *map, proshade_unsign dim, proshade_double *eulA, proshade_double *eulB, proshade_double *eulG, ProSHADE_settings *settings)
This function finds the highest peaks optimised Euler angles using the "naive" approach.
Definition: ProSHADE_peakSearch.cpp:352
ProSHADE_internal_data::ProSHADE_data::saveRecommendedSymmetry
void saveRecommendedSymmetry(ProSHADE_settings *settings, std::vector< proshade_double * > *CSym, std::vector< proshade_double * > *DSym, std::vector< proshade_double * > *TSym, std::vector< proshade_double * > *OSym, std::vector< proshade_double * > *ISym, std::vector< proshade_double * > *axes, fftw_complex *mapData, fftw_complex *origCoeffs, fftw_complex *fCoeffs, fftw_plan *planForwardFourier, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **bindata, proshade_signed *binCounts, proshade_double *&fscByBin)
This function takes all the detected symmetry results and decides on which are to be recommended for ...
Definition: ProSHADE_data.cpp:2558
ProSHADE_internal_misc::deepCopyAxisToDblPtrVector
void deepCopyAxisToDblPtrVector(std::vector< proshade_double * > *dblPtrVec, proshade_double *axis)
Does a deep copy of a double array to a vector of double arrays.
Definition: ProSHADE_misc.cpp:335
ProSHADE_internal_data::ProSHADE_data::yAxisOrder
proshade_unsign yAxisOrder
This is the order of the y axis.
Definition: ProSHADE_data.hpp:72
ProSHADE_internal_data::ProSHADE_data::internalMap
proshade_double * internalMap
The internal map data representation, which may be amended as the run progresses.
Definition: ProSHADE_data.hpp:56
ProSHADE_internal_data::ProSHADE_data::writePdb
void writePdb(std::string fName, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true)
This function writes out the co-ordinates file with ProSHADE type rotation and translation applied.
Definition: ProSHADE_data.cpp:959
ProSHADE_internal_data::ProSHADE_data::zDimIndicesOriginal
proshade_unsign zDimIndicesOriginal
This is the size of the map cell z dimension in indices.
Definition: ProSHADE_data.hpp:87
ProSHADE_internal_maths::complexMultiplicationConjugRealOnly
proshade_double complexMultiplicationConjugRealOnly(proshade_double *r1, proshade_double *i1, proshade_double *r2, proshade_double *i2)
Function to conjuggate multiply two complex numbers and return the real part only.
Definition: ProSHADE_maths.cpp:103
ProSHADE_internal_data::ProSHADE_data::xFrom
proshade_signed xFrom
This is the starting index along the x axis.
Definition: ProSHADE_data.hpp:110
ProSHADE_internal_maths::getRotationMatrixFromAngleAxis
void getRotationMatrixFromAngleAxis(proshade_double *rotMat, proshade_double x, proshade_double y, proshade_double z, proshade_double ang)
This function converts the axis-angle representation to the rotation matrix representation.
Definition: ProSHADE_maths.cpp:1459
ProSHADE_internal_data::ProSHADE_data::writeMap
void writeMap(std::string fName, std::string title="Created by ProSHADE and written by GEMMI", int mode=2)
Function for writing out the internal structure representation in MRC MAP format.
Definition: ProSHADE_data.cpp:892
ProSHADE_internal_data::ProSHADE_data::getMaxBand
proshade_unsign getMaxBand(void)
This function returns the maximum band value for the object.
Definition: ProSHADE_data.cpp:3611
ProSHADE_internal_data::ProSHADE_data::shiftToBoxCentre
void shiftToBoxCentre(ProSHADE_settings *settings)
Function for shifting map so that its centre of box is at required position.
Definition: ProSHADE_data.cpp:1075
ProSHADE_settings::appliedMaskFileName
std::string appliedMaskFileName
The filename from which mask data will be read from.
Definition: ProSHADE_settings.hpp:86
ProSHADE_internal_misc::sortISymByPeak
bool sortISymByPeak(const std::vector< proshade_double * > a, const std::vector< proshade_double * > b)
This function compares two vectors of arrays based on the sum of the fifth column,...
Definition: ProSHADE_misc.cpp:279
ProSHADE_internal_data::ProSHADE_data::invertSHCoefficients
void invertSHCoefficients(void)
This function computes the shell mapped data from inverting the Spherical Harmonics coefficients.
Definition: ProSHADE_overlay.cpp:1021
ProSHADE_internal_symmetry::detectIcosahedralSymmetry
bool detectIcosahedralSymmetry(std::vector< proshade_double * > *CSymList, proshade_double axErr, proshade_double minPeakHeight)
This function takes the list of C symmetries and decides whether basic requirements for isosahedral s...
Definition: ProSHADE_symmetry.cpp:1971
ProSHADE_settings::coOrdsExtraSpace
proshade_single coOrdsExtraSpace
This number of Angstroms will be added before and any co-ordinates to make sure there is no atom dire...
Definition: ProSHADE_settings.hpp:104
ProSHADE_settings::normaliseMap
bool normaliseMap
Should the map be normalised to mean 0 sd 1?
Definition: ProSHADE_settings.hpp:72
ProSHADE_internal_data::ProSHADE_data::writeGemmi
void writeGemmi(std::string fName, gemmi::Structure gemmiStruct, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true)
This function writes out the gemmi::Structure object with ProSHADE type rotation and translation appl...
Definition: ProSHADE_data.cpp:996
ProSHADE_settings::addExtraSpace
proshade_single addExtraSpace
If this value is non-zero, this many angstroms of empty space will be added to the internal map.
Definition: ProSHADE_settings.hpp:103
ProSHADE_internal_data::ProSHADE_data::getYDim
proshade_unsign getYDim(void)
This function allows access to the map size in indices along the Y axis.
Definition: ProSHADE_data.cpp:3939
ProSHADE_internal_maths::computeFSC
proshade_double computeFSC(fftw_complex *fCoeffs1, fftw_complex *fCoeffs2, proshade_unsign xInds, proshade_unsign yInds, proshade_unsign zInds, proshade_signed noBins, proshade_signed *binIndexing, proshade_double **&binData, proshade_signed *&binCounts, proshade_double *&fscByBin)
This function computes the FSC.
Definition: ProSHADE_maths.cpp:3347
ProSHADE_internal_data::ProSHADE_data::maxCompBand
proshade_unsign maxCompBand
The largest comparison band - this variable tells how large arrays will be allocated for the comparis...
Definition: ProSHADE_data.hpp:132
ProSHADE_internal_maths::findHighestValueInMap
void findHighestValueInMap(fftw_complex *resIn, proshade_unsign xD, proshade_unsign yD, proshade_unsign zD, proshade_double *trsX, proshade_double *trsY, proshade_double *trsZ, proshade_double *mapPeak)
This function simply finds the highest value in fftw_complex map and returns its position and value.
Definition: ProSHADE_maths.cpp:3912
ProSHADE_internal_data::ProSHADE_data::maskMap
void maskMap(ProSHADE_settings *settings)
Function for computing the map mask using blurring and X IQRs from median.
Definition: ProSHADE_data.cpp:1276
ProSHADE_internal_mapManip::getNonZeroBounds
void getNonZeroBounds(proshade_double *map, proshade_signed xDim, proshade_signed yDim, proshade_signed zDim, proshade_signed *&ret)
Function for finding the map boundaries enclosing positive only values.
Definition: ProSHADE_mapManip.cpp:1124
ProSHADE_internal_data::ProSHADE_data::xCom
proshade_double xCom
The COM of the map after processing along the X-axis.
Definition: ProSHADE_data.hpp:77
ProSHADE_internal_maths::getAxisAngleFromRotationMatrix
void getAxisAngleFromRotationMatrix(proshade_double *rotMat, proshade_double *x, proshade_double *y, proshade_double *z, proshade_double *ang, proshade_signed verbose=1)
This function converts rotation matrix to the axis-angle representation.
Definition: ProSHADE_maths.cpp:1084
ProSHADE_settings::fscThreshold
proshade_double fscThreshold
The threshold for FSC value under which the axis is considered to be likely noise.
Definition: ProSHADE_settings.hpp:137
ProSHADE_internal_data::ProSHADE_data::readInGemmi
void readInGemmi(gemmi::Structure gemmiStruct, ProSHADE_settings *settings)
Function for reading co-ordinate data from Gemmi object.
Definition: ProSHADE_data.cpp:735
ProSHADE_internal_maths::binReciprocalSpaceReflections
void binReciprocalSpaceReflections(proshade_unsign xInds, proshade_unsign yInds, proshade_unsign zInds, proshade_signed *noBin, proshade_signed *&binIndexing)
This function does binning of the reciprocal space reflections.
Definition: ProSHADE_maths.cpp:3199
ProSHADE_internal_data::ProSHADE_data::originalPdbTransZ
proshade_double originalPdbTransZ
The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE inte...
Definition: ProSHADE_data.hpp:107
ProSHADE_internal_data::ProSHADE_data::getPredictedTetrahedralSymmetriesList
std::vector< proshade_double * > getPredictedTetrahedralSymmetriesList(ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
This function predicts a list of all T symmetry axes from the already computed C symmetries list.
Definition: ProSHADE_symmetry.cpp:3505
ProSHADE_internal_symmetry::findOcta4C3s
void findOcta4C3s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the four C3 symmetries with correct angles req...
Definition: ProSHADE_symmetry.cpp:1398
ProSHADE_internal_io::readInMapData
void readInMapData(gemmi::Ccp4< float > *gemmiMap, proshade_double *&map, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_unsign xAxOrder, proshade_unsign yAxOrder, proshade_unsign zAxOrder)
This function converts the gemmi Ccp4 object data to ProSHADE internal map representation.
Definition: ProSHADE_io.cpp:178
ProSHADE_internal_distances::computeEMatrices
void computeEMatrices(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function computes the complete E matrices and their weights between any two objects.
Definition: ProSHADE_distances.cpp:510
ProSHADE_internal_data::ProSHADE_data::getTranslationFnPointer
proshade_complex * getTranslationFnPointer(void)
This function allows access to the translation function through a pointer.
Definition: ProSHADE_data.cpp:4059
ProSHADE_settings::setRecommendedSymmetry
void setRecommendedSymmetry(std::string val)
Sets the ProSHADE detected symmetry type.
Definition: ProSHADE.cpp:1469
ProSHADE_internal_maths::combineFourierForTranslation
void combineFourierForTranslation(fftw_complex *tmpOut1, fftw_complex *tmpOut2, fftw_complex *&resOut, proshade_unsign xD, proshade_unsign yD, proshade_unsign zD)
This function combines Fourier coefficients of two structures in a way, so that inverse Fourier of th...
Definition: ProSHADE_maths.cpp:3865
ProSHADE_internal_data::ProSHADE_data::zCom
proshade_double zCom
The COM of the map after processing along the Z-axis.
Definition: ProSHADE_data.hpp:79
ProSHADE_internal_data::ProSHADE_data::spherePos
std::vector< proshade_single > spherePos
Vector of sphere radii from the centre of the map.
Definition: ProSHADE_data.hpp:118
ProSHADE_settings::invertMap
bool invertMap
Should the map be inverted? Only use this if you think you have the wrong hand in your map.
Definition: ProSHADE_settings.hpp:75
ProSHADE_internal_data::ProSHADE_data::getZDim
proshade_unsign getZDim(void)
This function allows access to the map size in indices along the Z axis.
Definition: ProSHADE_data.cpp:3949
ProSHADE_settings::centrePosition
std::vector< proshade_double > centrePosition
The position of the centre of the map in "real space" co-ordinates.
Definition: ProSHADE_settings.hpp:142
ProSHADE_internal_mapManip::removeMapPhase
void removeMapPhase(fftw_complex *&mapCoeffs, proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim)
This function removes the phase from reciprocal (frequency) map.
Definition: ProSHADE_mapManip.cpp:1681
ProSHADE_settings::boundsSimilarityThreshold
proshade_signed boundsSimilarityThreshold
Number of indices which can be added just to make sure same size in indices is achieved.
Definition: ProSHADE_settings.hpp:94
ProSHADE_internal_maths::findTopGroupSmooth
proshade_double findTopGroupSmooth(std::vector< proshade_double * > *CSym, size_t peakPos, proshade_double step, proshade_double sigma, proshade_signed windowSize, proshade_double maxLim=0.9)
This function finds a subgroup of axes with distinctly higher correlation value.
Definition: ProSHADE_maths.cpp:3743
ProSHADE_internal_overlay::computeAngularThreshold
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.
Definition: ProSHADE_overlay.cpp:1091
ProSHADE_internal_overlay::initialiseInverseSHComputation
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.
Definition: ProSHADE_overlay.cpp:975
ProSHADE_settings::changeMapResolution
bool changeMapResolution
Should maps be re-sampled to obtain the required resolution?
Definition: ProSHADE_settings.hpp:51
ProSHADE_internal_io::writeRotationTranslationJSON
void writeRotationTranslationJSON(proshade_double trsX1, proshade_double trsY1, proshade_double trsZ1, proshade_double eulA, proshade_double eulB, proshade_double eulG, proshade_double trsX2, proshade_double trsY2, proshade_double trsZ2, std::string fileName)
Function for writing out the optimal rotation and translation into a JSON file.
Definition: ProSHADE_io.cpp:965
ProSHADE_internal_data::ProSHADE_data::mapMovFromsChangeZ
proshade_double mapMovFromsChangeZ
When the map is translated, the zFrom and zTo values are changed. This variable holds how much they h...
Definition: ProSHADE_data.hpp:96
axesToGroupTypeSanityCheck
void axesToGroupTypeSanityCheck(proshade_unsign requiredAxes, proshade_unsign obtainedAxes, std::string groupType)
This function checks that the required and obtained numbers of axes are correct, printing error if th...
Definition: ProSHADE_data.cpp:3003
ProSHADE_internal_distances::computeInverseSOFTTransform
void computeInverseSOFTTransform(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function computes the inverse SO(3) transform.
Definition: ProSHADE_distances.cpp:854
ProSHADE_internal_spheres::ProSHADE_rotFun_spherePeakGroup
This class contains peak groups detected in the rotation function mapped spheres.
Definition: ProSHADE_spheres.hpp:129
ProSHADE_settings::overlayStructureName
std::string overlayStructureName
The filename to which the rotated and translated moving structure is to be saved.
Definition: ProSHADE_settings.hpp:145
ProSHADE_internal_maths::isAxisUnique
bool isAxisUnique(std::vector< proshade_double * > *CSymList, proshade_double *axis, proshade_double tolerance=0.1, bool improve=false)
This function checks if new axis is unique, or already detected.
Definition: ProSHADE_maths.cpp:2974
ProSHADE_internal_data::ProSHADE_data::getMapValue
proshade_double getMapValue(proshade_unsign pos)
This function returns the internal map representation value of a particular array position.
Definition: ProSHADE_data.cpp:3601
ProSHADE_internal_data::ProSHADE_data::getYToPtr
proshade_signed * getYToPtr(void)
This function allows access to the map last position along the Y axis.
Definition: ProSHADE_data.cpp:3999
ProSHADE_settings::moveToCOM
bool moveToCOM
Logical value stating whether the structure should be moved to have its Centre Of Mass (COM) in the m...
Definition: ProSHADE_settings.hpp:99
ProSHADE_settings::peakNeighbours
proshade_unsign peakNeighbours
Number of points in any direction that have to be lower than the considered index in order to conside...
Definition: ProSHADE_settings.hpp:119
ProSHADE_internal_data::ProSHADE_data::wignerMatrices
proshade_complex *** wignerMatrices
These matrices are computed for a particular rotation to be done in spherical harmonics.
Definition: ProSHADE_data.hpp:131
ProSHADE_internal_data::ProSHADE_data::fileType
ProSHADE_internal_io::InputType fileType
This is the type of the input file.
Definition: ProSHADE_data.hpp:53
ProSHADE_internal_data::ProSHADE_data::rotateMapRealSpace
std::vector< proshade_double > rotateMapRealSpace(proshade_double axX, proshade_double axY, proshade_double axZ, proshade_double axAng, proshade_double *&map)
This function rotates a map based on the given angle-axis rotation.
Definition: ProSHADE_overlay.cpp:632
ProSHADE_internal_data::ProSHADE_data::getZAxisOrigin
proshade_signed * getZAxisOrigin(void)
This function allows access to the map Z axis origin value.
Definition: ProSHADE_data.cpp:4039
ProSHADE_internal_io::writeOutMapHeader
void writeOutMapHeader(gemmi::Ccp4< float > *map, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_single xDim, proshade_single yDim, proshade_single zDim, proshade_single aAng, proshade_single bAng, proshade_single cAng, proshade_signed xFrom, proshade_signed yFrom, proshade_signed zFrom, proshade_signed xAxOrigin, proshade_signed yAxOrigin, proshade_signed zAxOrigin, proshade_unsign xAxOrder, proshade_unsign yAxOrder, proshade_unsign zAxOrder, proshade_unsign xGridInds, proshade_unsign yGridInds, proshade_unsign zGridInds, std::string title, int mode)
This function parses the CCP4 MAP file header as read in by gemmi.
Definition: ProSHADE_io.cpp:873
ProSHADE_internal_mapManip::myRound
proshade_signed myRound(proshade_double x)
Calls the appropriate version of round function depending on compiler version.
Definition: ProSHADE_mapManip.cpp:31
ProSHADE_internal_data::ProSHADE_data::yDimSizeOriginal
proshade_single yDimSizeOriginal
This is the size of the map cell y dimension in Angstroms.
Definition: ProSHADE_data.hpp:83
ProSHADE_internal_maths::compute3x3MatrixVectorMultiplication
proshade_double * compute3x3MatrixVectorMultiplication(proshade_double *mat, proshade_double x, proshade_double y, proshade_double z)
Function for computing a 3x3 matrix to 3x1 vector multiplication.
Definition: ProSHADE_maths.cpp:1898
ProSHADE_internal_data::ProSHADE_data::zAxisOrder
proshade_unsign zAxisOrder
This is the order of the z axis.
Definition: ProSHADE_data.hpp:73
ProSHADE_internal_mapManip::beautifyBoundaries
void beautifyBoundaries(proshade_signed *&bounds, proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim, proshade_signed boundsDiffThres)
Function for modifying boundaries to a mathematically more pleasant values.
Definition: ProSHADE_mapManip.cpp:1966
ProSHADE_internal_data::ProSHADE_data::reSampleMap
void reSampleMap(ProSHADE_settings *settings)
This function changes the internal map sampling to conform to particular resolution value.
Definition: ProSHADE_data.cpp:1440
ProSHADE_settings::boxCentre
std::vector< proshade_double > boxCentre
If box centre is to be in any other location, this variable will hold the real space location that sh...
Definition: ProSHADE_settings.hpp:100
ProSHADE_internal_mapManip::rotatePDBCoordinates
void rotatePDBCoordinates(gemmi::Structure *pdbFile, proshade_double euA, proshade_double euB, proshade_double euG, proshade_double xCom, proshade_double yCom, proshade_double zCom, bool firstModel)
Function for rotating the PDB file co-ordinates by Euler angles.
Definition: ProSHADE_mapManip.cpp:298
ProSHADE_internal_symmetry::findOcta6C2s
void findOcta6C2s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the six C2 symmetries with correct angles requ...
Definition: ProSHADE_symmetry.cpp:1481
ProSHADE_internal_mapManip::generateMapFromPDB
void generateMapFromPDB(gemmi::Structure pdbFile, proshade_double *&map, proshade_single requestedResolution, proshade_single xCell, proshade_single yCell, proshade_single zCell, proshade_signed *xTo, proshade_signed *yTo, proshade_signed *zTo, bool forceP1, bool firstModel)
This function generates a theoretical map from co-ordinate input files.
Definition: ProSHADE_mapManip.cpp:646
ProSHADE_internal_misc::checkMemoryAllocation
void checkMemoryAllocation(chVar checkVar, std::string fileP, unsigned int lineP, std::string funcP, std::string infoP="This error may occurs when ProSHADE requests memory to be\n : allocated to it and this operation fails. This could\n : happen when not enough memory is available, either due to\n : other processes using a lot of memory, or when the machine\n : does not have sufficient memory available. Re-run to see\n : if this problem persists.")
Checks if memory was allocated properly.
Definition: ProSHADE_misc.hpp:68
ProSHADE_internal_data::ProSHADE_data::getXToPtr
proshade_signed * getXToPtr(void)
This function allows access to the map last position along the X axis.
Definition: ProSHADE_data.cpp:3989
ProSHADE_internal_data::ProSHADE_data::getYFromPtr
proshade_signed * getYFromPtr(void)
This function allows access to the map start along the Y axis.
Definition: ProSHADE_data.cpp:3969
ProSHADE_internal_mapManip::translatePDBCoordinates
void translatePDBCoordinates(gemmi::Structure *pdbFile, proshade_double transX, proshade_double transY, proshade_double transZ, bool firstModel)
Function for translating the PDB file co-ordinates by given distances in Angstroms.
Definition: ProSHADE_mapManip.cpp:383
ProSHADE_internal_data::ProSHADE_data::mapCOMProcessChangeY
proshade_double mapCOMProcessChangeY
The change in Y axis between the creation of the structure (originalMapYCom) and just before rotation...
Definition: ProSHADE_data.hpp:98
ProSHADE_internal_data::ProSHADE_data::bAngle
proshade_single bAngle
This is the angle b of the map cell in degrees.
Definition: ProSHADE_data.hpp:63
ProSHADE_internal_maths::getEulerZXZFromSOFTPosition
void getEulerZXZFromSOFTPosition(proshade_signed band, proshade_signed x, proshade_signed y, proshade_signed z, proshade_double *eulerAlpha, proshade_double *eulerBeta, proshade_double *eulerGamma)
Function to find Euler angles (ZXZ convention) from index position in the inverse SOFT map.
Definition: ProSHADE_maths.cpp:963
ProSHADE_internal_data::ProSHADE_data::yAxisOriginOriginal
proshade_signed yAxisOriginOriginal
This is the origin position along the y axis.
Definition: ProSHADE_data.hpp:89
ProSHADE_internal_symmetry::saveDSymmetry
void saveDSymmetry(std::vector< proshade_double * > *ret, std::vector< proshade_double * > *CSymList, proshade_unsign axisOne, proshade_unsign axisTwo)
This function saves a detected dihedral symmetry to the dihedral symmetries list.
Definition: ProSHADE_symmetry.cpp:383
ProSHADE_internal_symmetry::findOcta3C4s
void findOcta3C4s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the 3 C4 symmetries with perpendicular angles ...
Definition: ProSHADE_symmetry.cpp:1331
ProSHADE_internal_data::ProSHADE_data::aAngle
proshade_single aAngle
This is the angle a of the map cell in degrees.
Definition: ProSHADE_data.hpp:62
ProSHADE_internal_misc::addToDoubleVectorVector
void addToDoubleVectorVector(std::vector< std::vector< proshade_double > > *vecToAddTo, std::vector< proshade_double > elementToAdd)
Adds the element to the vector of vectors.
Definition: ProSHADE_misc.cpp:233
ProSHADE_internal_data::ProSHADE_data::figureIndexStartStop
void figureIndexStartStop(void)
Function for determining iterator start and stop positions.
Definition: ProSHADE_data.cpp:870
ProSHADE_internal_data::ProSHADE_data::isEmpty
bool isEmpty
This variable stated whether the class contains any information.
Definition: ProSHADE_data.hpp:139
ProSHADE_internal_overlay::allocateTranslationFunctionMemory
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 compu...
Definition: ProSHADE_overlay.cpp:367
ProSHADE_internal_data::ProSHADE_data::getPredictedOctahedralSymmetriesList
std::vector< proshade_double * > getPredictedOctahedralSymmetriesList(ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
This function predicts a list of all O symmetry axes from the already computed C symmetries list.
Definition: ProSHADE_symmetry.cpp:1927
ProSHADE_internal_symmetry::findTetra4C3s
void findTetra4C3s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the 4 C3 symmetries with correct angles requir...
Definition: ProSHADE_symmetry.cpp:539
ProSHADE_internal_data::ProSHADE_data::getInvSO3Coeffs
proshade_complex * getInvSO3Coeffs(void)
This function allows access to the inverse SO(3) coefficients array.
Definition: ProSHADE_data.cpp:3847
ProSHADE_settings::allDetectedIAxes
std::vector< proshade_unsign > allDetectedIAxes
The vector of all detected icosahedral symmetry axes indices in allDetectedCAxes.
Definition: ProSHADE_settings.hpp:159
ProSHADE_settings::forceBounds
proshade_signed * forceBounds
These will be the boundaries to be forced upon the map.
Definition: ProSHADE_settings.hpp:96
ProSHADE_settings::fourierWeightsFileName
std::string fourierWeightsFileName
The filename from which Fourier weights data will be read from.
Definition: ProSHADE_settings.hpp:89
ProSHADE_settings::detectedSymmetry
std::vector< proshade_double * > detectedSymmetry
The vector of detected symmetry axes.
Definition: ProSHADE_settings.hpp:154
ProSHADE_internal_data::ProSHADE_data::yFrom
proshade_signed yFrom
This is the starting index along the y axis.
Definition: ProSHADE_data.hpp:111
ProSHADE_settings::recommendedSymmetryFold
proshade_unsign recommendedSymmetryFold
The fold of the recommended symmetry C or D type, 0 otherwise.
Definition: ProSHADE_settings.hpp:132
ProSHADE_internal_misc::addToUnsignVector
void addToUnsignVector(std::vector< proshade_unsign > *vecToAddTo, proshade_unsign elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:99
ProSHADE_internal_mapManip::reSampleMapToResolutionFourier
void reSampleMapToResolutionFourier(proshade_double *&map, proshade_single resolution, proshade_unsign xDimS, proshade_unsign yDimS, proshade_unsign zDimS, proshade_single xAngs, proshade_single yAngs, proshade_single zAngs, proshade_single *&corrs)
This function re-samples a map to conform to given resolution using Fourier.
Definition: ProSHADE_mapManip.cpp:1427
ProSHADE_internal_mapManip::copyMapByBounds
void copyMapByBounds(proshade_signed xFrom, proshade_signed xTo, proshade_signed yFrom, proshade_signed yTo, proshade_signed zFrom, proshade_signed zTo, proshade_signed origXFrom, proshade_signed origYFrom, proshade_signed origZFrom, proshade_unsign yDimIndices, proshade_unsign zDimIndices, proshade_unsign origXDimIndices, proshade_unsign origYDimIndices, proshade_unsign origZDimIndices, proshade_double *&newMap, proshade_double *origMap)
This function copies an old map to a new map with different boundaries.
Definition: ProSHADE_mapManip.cpp:2132
ProSHADE_internal_data::ProSHADE_data::getPredictedIcosahedralSymmetriesList
std::vector< std::vector< proshade_double * > > getPredictedIcosahedralSymmetriesList(ProSHADE_settings *settings, std::vector< proshade_double * > *CSymList)
This function predicts a list of all I symmetry axes from the already computed C symmetries list.
Definition: ProSHADE_symmetry.cpp:1880
ProSHADE_internal_data::ProSHADE_data::getYAxisOrigin
proshade_signed * getYAxisOrigin(void)
This function allows access to the map Y axis origin value.
Definition: ProSHADE_data.cpp:4029
ProSHADE_internal_data::ProSHADE_data::getCyclicSymmetriesListFromAngleAxis
std::vector< proshade_double * > getCyclicSymmetriesListFromAngleAxis(ProSHADE_settings *settings)
This function obtains a list of all C symmetries from the angle-axis space mapped rotation function v...
Definition: ProSHADE_symmetry.cpp:2770
ProSHADE_internal_data::ProSHADE_data::originalPdbRotCenZ
proshade_double originalPdbRotCenZ
The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map...
Definition: ProSHADE_data.hpp:104
ProSHADE_internal_overlay::computeTranslationsFromPeak
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...
Definition: ProSHADE_overlay.cpp:220
ProSHADE_internal_overlay::paddMapWithZeroes
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 n...
Definition: ProSHADE_overlay.cpp:521
ProSHADE_internal_misc::addToSingleVector
void addToSingleVector(std::vector< proshade_single > *vecToAddTo, proshade_single elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:55
ProSHADE_settings::firstModelOnly
bool firstModelOnly
Shoud only the first PDB model be used, or should all models be used?
Definition: ProSHADE_settings.hpp:46
ProSHADE_internal_symmetry::findIcos15C2s
void findIcos15C2s(std::vector< proshade_double * > *CSymList, std::vector< proshade_double * > *ret, proshade_double axErr, ProSHADE_internal_data::ProSHADE_data *dataObj, proshade_signed verbose, proshade_signed messageShift, proshade_double minPeakHeight)
This function takes the list of C symmetries and finds the fifteen C3 symmetries with correct angles ...
Definition: ProSHADE_symmetry.cpp:2524
sortProSHADESymmetryByFSC
bool sortProSHADESymmetryByFSC(proshade_double *a, proshade_double *b)
This function allows using std::sort to sort vectors of ProSHADE symmetry format.
Definition: ProSHADE_data.cpp:1887
ProSHADE_settings::axisErrTolerance
proshade_double axisErrTolerance
Allowed error on vector axis in in dot product ( acos ( 1 - axErr ) is the allowed difference in radi...
Definition: ProSHADE_settings.hpp:128
ProSHADE_settings::useSameBounds
bool useSameBounds
Switch to say that the same boundaries as used for the first should be used for all input maps.
Definition: ProSHADE_settings.hpp:95
ProSHADE_internal_data::ProSHADE_data::zDimIndices
proshade_unsign zDimIndices
This is the size of the map cell z dimension in indices.
Definition: ProSHADE_data.hpp:67
ProSHADE_internal_data::computeGroupElementsForGroup
std::vector< std::vector< proshade_double > > computeGroupElementsForGroup(proshade_double xAx, proshade_double yAx, proshade_double zAx, proshade_signed fold)
This function computes the group elements as rotation matrices (except for the identity element) for ...
Definition: ProSHADE_data.cpp:2939
ProSHADE_settings::pdbBFactorNewVal
proshade_double pdbBFactorNewVal
Change all PDB B-factors to this value (for smooth maps).
Definition: ProSHADE_settings.hpp:55
ProSHADE_internal_spheres::ProSHADE_sphere::allocateRotatedMap
void allocateRotatedMap(void)
This function allocates the rotated map memory.
Definition: ProSHADE_spheres.cpp:596
ProSHADE_internal_data::ProSHADE_data::zGridIndices
proshade_unsign zGridIndices
As far as I know, this is identical to the zDimIndices.
Definition: ProSHADE_data.hpp:70
ProSHADE_settings::setRecommendedFold
void setRecommendedFold(proshade_unsign val)
Sets the ProSHADE detected symmetry fold.
Definition: ProSHADE.cpp:1492
ProSHADE_internal_distances::generateSO3CoeffsFromEMatrices
void generateSO3CoeffsFromEMatrices(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function converts the E matrices to SO(3) coefficients.
Definition: ProSHADE_distances.cpp:701
ProSHADE_internal_io::applyWeights
void applyWeights(proshade_double *&map, std::string weightsFile, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_signed verbose, proshade_signed messageShift, proshade_double *weightsArray=nullptr, proshade_unsign waXInds=0, proshade_unsign waYInds=0, proshade_unsign waZInds=0)
This function reads and applies the Fourier weights to the map.
Definition: ProSHADE_io.cpp:566
ProSHADE_settings::setVariablesLeftOnAuto
void setVariablesLeftOnAuto(void)
Function to determine general values that the user left on auto-determination.
Definition: ProSHADE.cpp:503
ProSHADE_settings::removeWaters
bool removeWaters
Should all waters be removed from input PDB files?
Definition: ProSHADE_settings.hpp:45
ProSHADE_internal_data::ProSHADE_data::spheres
ProSHADE_internal_spheres::ProSHADE_sphere ** spheres
The set of concentric spheres to which the intermal density map has been projected.
Definition: ProSHADE_data.hpp:120
ProSHADE_internal_data::ProSHADE_data::normaliseMap
void normaliseMap(ProSHADE_settings *settings)
Function for normalising the map values to mean 0 and sd 1..
Definition: ProSHADE_data.cpp:1229
ProSHADE_internal_data::ProSHADE_data::findRequestedCSymmetryFromAngleAxis
std::vector< proshade_double * > findRequestedCSymmetryFromAngleAxis(ProSHADE_settings *settings, proshade_unsign fold, proshade_double *peakThres)
This function searches the angle-axis representation of the rotation function for a cyclic point grou...
Definition: ProSHADE_symmetry.cpp:2909
ProSHADE_internal_maths::findAllPrimes
std::vector< proshade_unsign > findAllPrimes(proshade_unsign upTo)
This function finds all prime numbers up to the supplied limit.
Definition: ProSHADE_maths.cpp:3058
ProSHADE_internal_data::ProSHADE_data::originalPdbRotCenX
proshade_double originalPdbRotCenX
The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map...
Definition: ProSHADE_data.hpp:102
ProSHADE_internal_data::ProSHADE_data::originalMapZCom
proshade_double originalMapZCom
The COM of the first map to be loaded/computed without any furhter changes being reflacted along the ...
Definition: ProSHADE_data.hpp:93
ProSHADE_internal_messages::printProgressMessage
void printProgressMessage(proshade_signed verbose, proshade_signed messageLevel, std::string message, proshade_signed messageShift=0)
General stdout message printing.
Definition: ProSHADE_messages.cpp:71
ProSHADE_internal_data::ProSHADE_data::yDimSize
proshade_single yDimSize
This is the size of the map cell y dimension in Angstroms.
Definition: ProSHADE_data.hpp:60
ProSHADE_settings::setResolution
void setResolution(proshade_single resolution)
Sets the requested resolution in the appropriate variable.
Definition: ProSHADE.cpp:549
ProSHADE_settings::allDetectedCAxes
std::vector< std::vector< proshade_double > > allDetectedCAxes
The vector of all detected cyclic symmetry axes.
Definition: ProSHADE_settings.hpp:155
ProSHADE_internal_data::ProSHADE_data::removePhaseInormation
void removePhaseInormation(ProSHADE_settings *settings)
This function removes phase from the map, effectively converting it to Patterson map.
Definition: ProSHADE_data.cpp:3657
ProSHADE_internal_mapManip::moveMapByIndices
void moveMapByIndices(proshade_single *xMov, proshade_single *yMov, proshade_single *zMov, proshade_single xAngs, proshade_single yAngs, proshade_single zAngs, proshade_signed *xFrom, proshade_signed *xTo, proshade_signed *yFrom, proshade_signed *yTo, proshade_signed *zFrom, proshade_signed *zTo, proshade_signed *xOrigin, proshade_signed *yOrigin, proshade_signed *zOrigin)
Function for moving map back to original PDB location by changing the indices.
Definition: ProSHADE_mapManip.cpp:765
ProSHADE_internal_io::readInMapHeader
void readInMapHeader(gemmi::Ccp4< float > *map, proshade_unsign *xDimInds, proshade_unsign *yDimInds, proshade_unsign *zDimInds, proshade_single *xDim, proshade_single *yDim, proshade_single *zDim, proshade_single *aAng, proshade_single *bAng, proshade_single *cAng, proshade_signed *xFrom, proshade_signed *yFrom, proshade_signed *zFrom, proshade_signed *xAxOrigin, proshade_signed *yAxOrigin, proshade_signed *zAxOrigin, proshade_unsign *xAxOrder, proshade_unsign *yAxOrder, proshade_unsign *zAxOrder, proshade_unsign *xGridInds, proshade_unsign *yGridInds, proshade_unsign *zGridInds)
This function parses the CCP4 MAP file header as read in by gemmi.
Definition: ProSHADE_io.cpp:109
ProSHADE_settings::fastISearch
bool fastISearch
Should FSC be computed for all possible I matches, or just for the best one according to FR?
Definition: ProSHADE_settings.hpp:139
ProSHADE_internal_symmetry::predictIcosAxes
void predictIcosAxes(std::vector< proshade_double * > *CSymList, std::vector< std::vector< proshade_double * > > *ret, proshade_double axErr, proshade_double minPeakHeight)
This function predicts all possible icosahedral point groups symmetry axes from the cyclic point grou...
Definition: ProSHADE_symmetry.cpp:2154
ProSHADE_internal_data::ProSHADE_data::getAllGroupElements
std::vector< std::vector< proshade_double > > getAllGroupElements(ProSHADE_settings *settings, std::vector< proshade_unsign > axesList, std::string groupType="", proshade_double matrixTolerance=0.05)
This function returns the group elements as rotation matrices of any defined point group.
Definition: ProSHADE_data.cpp:3151
ProSHADE_internal_data::ProSHADE_data::addExtraSpace
void addExtraSpace(ProSHADE_settings *settings)
This function increases the size of the map so that it can add empty space around it.
Definition: ProSHADE_data.cpp:1585
ProSHADE_internal_symmetry::detectTetrahedralSymmetry
bool detectTetrahedralSymmetry(std::vector< proshade_double * > *CSymList, proshade_double axErr, proshade_double minPeakHeight)
This function takes the list of C symmetries and decides whether basic requirements for tetrahedral s...
Definition: ProSHADE_symmetry.cpp:488
ProSHADE_internal_misc::sortSymHlpInv
bool sortSymHlpInv(const proshade_double *a, const proshade_double *b)
This function compares two arrays of two based on the fifth number, sorting highest first.
Definition: ProSHADE_misc.cpp:266
ProSHADE_internal_misc::addToStringVector
void addToStringVector(std::vector< std::string > *vecToAddTo, std::string elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:33
ProSHADE_internal_sphericalHarmonics::computeSphericalHarmonics
void computeSphericalHarmonics(proshade_unsign band, proshade_double *sphereMappedData, proshade_complex *&shArray)
This function computes the spherical harmonics of a aingle shell, saving them in supplied pointer.
Definition: ProSHADE_sphericalHarmonics.cpp:394
ProSHADE_internal_data::ProSHADE_data::readInPDB
void readInPDB(ProSHADE_settings *settings)
Function for reading pdb data.
Definition: ProSHADE_data.cpp:700
ProSHADE_internal_spheres::ProSHADE_sphere::setRotatedMappedData
void setRotatedMappedData(proshade_unsign pos, proshade_double value)
This function sets the rotated mapped data value to the given position.
Definition: ProSHADE_spheres.cpp:613
ProSHADE_internal_data::ProSHADE_data::prepareFSCFourierMemory
void prepareFSCFourierMemory(fftw_complex *&mapData, fftw_complex *&origCoeffs, fftw_complex *&fCoeffs, proshade_signed *&binIndexing, proshade_signed *noBins, proshade_double **&bindata, proshade_signed *&binCounts, fftw_plan *planForwardFourier, proshade_double *&fscByBin)
This function allocates the memory and makes all preparations required for FSC computation.
Definition: ProSHADE_data.cpp:2320
ProSHADE_internal_data::ProSHADE_data::getZFromPtr
proshade_signed * getZFromPtr(void)
This function allows access to the map start along the Z axis.
Definition: ProSHADE_data.cpp:3979
ProSHADE_internal_data::ProSHADE_data::getZToPtr
proshade_signed * getZToPtr(void)
This function allows access to the map last position along the Z axis.
Definition: ProSHADE_data.cpp:4009