ProSHADE  0.7.6.0 (JUL 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)
 This function initialises the basic ProSHADE_data variables and reads in a single structure. 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, bool firstModel=true)
 This function writes out the PDB formatted file coresponding to the structure so that its COM is at specific position. 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 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 * > getCyclicSymmetriesList (ProSHADE_settings *settings)
 This function obtains a list of all C symmetries from already computed self-rotation map. 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 detectSymmetryInStructure (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 and saves the results in the settings object. 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...
 
proshade_double findTopGroupSmooth (std::vector< proshade_double * > *CSym, size_t peakPos, proshade_double step, proshade_double sigma, proshade_signed windowSize)
 This function finds the distinct group of axes with highest peak heights. 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)
 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)
 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)
 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)
 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)
 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...
 
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, proshade_double eulA, proshade_double eulB, proshade_double eulG)
 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...
 
void 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...
 
void 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 computePdbRotationCentre (void)
 This function computes the optimal rotation centre for co-ordinates. More...
 
void computeOptimalTranslation (proshade_double eulA, proshade_double eulB, proshade_double eulG, proshade_single trsX, proshade_single trsY, proshade_single trsZ)
 This function computes and saves the optimal translation vector from the already determined translation function results. 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)
 Function for reading map data using gemmi library. More...
 
void readInPDB (ProSHADE_settings *settings)
 Function for reading pdb data. 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 1503 of file ProSHADE_data.cpp.

1504 {
1505  //================================================ Report function start
1506  std::stringstream hlpSS;
1507  hlpSS << "Adding extra " << settings->addExtraSpace << " angstroms.";
1508  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, hlpSS.str() );
1509 
1510  //================================================ Figure how much indices need to change
1511  proshade_unsign xAddIndices = static_cast< proshade_unsign > ( ProSHADE_internal_mapManip::myRound ( settings->addExtraSpace / this->xDimSize / static_cast<proshade_single> ( this->xDimIndices ) ) );
1512  proshade_unsign yAddIndices = static_cast< proshade_unsign > ( ProSHADE_internal_mapManip::myRound ( settings->addExtraSpace / this->yDimSize / static_cast<proshade_single> ( this->yDimIndices ) ) );
1513  proshade_unsign zAddIndices = static_cast< proshade_unsign > ( ProSHADE_internal_mapManip::myRound ( settings->addExtraSpace / this->zDimSize / static_cast<proshade_single> ( this->zDimIndices ) ) );
1514 
1515  //================================================ Update internal data variables
1516  this->xDimSize += 2 * static_cast<proshade_single> ( xAddIndices ) * this->xDimSize / static_cast<proshade_single> ( this->xDimIndices );
1517  this->yDimSize += 2 * static_cast<proshade_single> ( yAddIndices ) * this->yDimSize / static_cast<proshade_single> ( this->yDimIndices );
1518  this->zDimSize += 2 * static_cast<proshade_single> ( zAddIndices ) * this->zDimSize / static_cast<proshade_single> ( this->zDimIndices );
1519 
1520  this->xDimIndices += 2 * xAddIndices;
1521  this->yDimIndices += 2 * yAddIndices;
1522  this->zDimIndices += 2 * zAddIndices;
1523 
1524  this->xGridIndices = this->xDimIndices;
1525  this->yGridIndices = this->yDimIndices;
1526  this->zGridIndices = this->zDimIndices;
1527 
1528  this->xAxisOrigin -= xAddIndices;
1529  this->yAxisOrigin -= yAddIndices;
1530  this->zAxisOrigin -= zAddIndices;
1531 
1532  this->xFrom -= xAddIndices;
1533  this->yFrom -= yAddIndices;
1534  this->zFrom -= zAddIndices;
1535 
1536  this->xTo += xAddIndices;
1537  this->yTo += yAddIndices;
1538  this->zTo += zAddIndices;
1539 
1540  //================================================ Allocate new map
1541  proshade_double* newMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1542  ProSHADE_internal_misc::checkMemoryAllocation ( newMap, __FILE__, __LINE__, __func__ );
1543 
1544  //================================================ Set new map to zeroes
1545  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1546  {
1547  newMap[iter] = 0.0;
1548  }
1549 
1550  //================================================ Update the map
1551  proshade_unsign newMapIndex, oldMapIndex;
1552  for ( proshade_unsign xIt = 0; xIt < (this->xDimIndices - xAddIndices); xIt++ )
1553  {
1554  //============================================ Check if point is applicable
1555  if ( xIt < xAddIndices ) { continue; }
1556 
1557  for ( proshade_unsign yIt = 0; yIt < (this->yDimIndices - yAddIndices); yIt++ )
1558  {
1559  //======================================== Check if point is applicable
1560  if ( yIt < yAddIndices ) { continue; }
1561 
1562  for ( proshade_unsign zIt = 0; zIt < (this->zDimIndices - zAddIndices); zIt++ )
1563  {
1564  //==================================== Check if point is applicable
1565  if ( zIt < zAddIndices ) { continue; }
1566 
1567  //==================================== Var init
1568  newMapIndex = zIt + this->zDimIndices * ( yIt + this->yDimIndices * xIt );
1569  oldMapIndex = (zIt - zAddIndices) + (this->zDimIndices - ( 2 * zAddIndices ) ) * ( (yIt - yAddIndices) + (this->yDimIndices - ( 2 * yAddIndices ) ) * (xIt - xAddIndices) );
1570 
1571  newMap[newMapIndex] = this->internalMap[oldMapIndex];
1572  }
1573  }
1574  }
1575 
1576  //================================================ Copy new to old
1577  delete[] this->internalMap;
1578 
1579  this->internalMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1580  ProSHADE_internal_misc::checkMemoryAllocation ( this->internalMap, __FILE__, __LINE__, __func__ );
1581 
1582  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1583  {
1584  this->internalMap[iter] = newMap[iter];
1585  }
1586 
1587  //================================================ Release memory
1588  delete[] newMap;
1589 
1590  //================================================ Report function completion
1591  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Extra space added." );
1592 
1593  //================================================ Done
1594  return ;
1595 
1596 }

◆ 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 1438 of file ProSHADE_data.cpp.

1439 {
1440  //================================================ Report function start
1441  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Centering map onto its COM." );
1442 
1443  //================================================ Initialise local variables
1444  proshade_double xCOM = 0.0;
1445  proshade_double yCOM = 0.0;
1446  proshade_double zCOM = 0.0;
1447 
1448  //================================================ Find the COM location
1449  ProSHADE_internal_mapManip::findMAPCOMValues ( this->internalMap, &xCOM, &yCOM, &zCOM,
1450  this->xDimSize, this->yDimSize, this->xDimSize, this->xFrom,
1451  this->xTo, this->yFrom, this->yTo, this->zFrom, this->zTo );
1452 
1453  //================================================ Find the sampling rates
1454  proshade_single xSampRate = static_cast< proshade_single > ( this->xDimSize ) / static_cast< proshade_single > ( this->xTo - this->xFrom );
1455  proshade_single ySampRate = static_cast< proshade_single > ( this->yDimSize ) / static_cast< proshade_single > ( this->yTo - this->yFrom );
1456  proshade_single zSampRate = static_cast< proshade_single > ( this->zDimSize ) / static_cast< proshade_single > ( this->zTo - this->zFrom );
1457 
1458  //================================================ Convert to position in indices starting from 0
1459  xCOM /= static_cast< proshade_double > ( xSampRate );
1460  yCOM /= static_cast< proshade_double > ( ySampRate );
1461  zCOM /= static_cast< proshade_double > ( zSampRate );
1462 
1463  xCOM -= static_cast< proshade_double > ( this->xFrom );
1464  yCOM -= static_cast< proshade_double > ( this->yFrom );
1465  zCOM -= static_cast< proshade_double > ( this->zFrom );
1466 
1467  //================================================ Find distance from COM to map centre in Angstroms
1468  proshade_double xDist = ( ( static_cast<proshade_double> ( this->xDimIndices ) / 2.0 ) - xCOM ) * static_cast<proshade_double> ( this->xDimSize ) / static_cast<proshade_double> ( this->xDimIndices );
1469  proshade_double yDist = ( ( static_cast<proshade_double> ( this->yDimIndices ) / 2.0 ) - yCOM ) * static_cast<proshade_double> ( this->yDimSize ) / static_cast<proshade_double> ( this->yDimIndices );
1470  proshade_double zDist = ( ( static_cast<proshade_double> ( this->zDimIndices ) / 2.0 ) - zCOM ) * static_cast<proshade_double> ( this->zDimSize ) / static_cast<proshade_double> ( this->zDimIndices );
1471 
1472  //================================================ Move the map within the box
1474  static_cast< proshade_single > ( xDist ),
1475  static_cast< proshade_single > ( yDist ),
1476  static_cast< proshade_single > ( zDist ),
1477  this->xDimSize, this->yDimSize, this->zDimSize,
1478  static_cast< proshade_signed > ( this->xDimIndices ),
1479  static_cast< proshade_signed > ( this->yDimIndices ),
1480  static_cast< proshade_signed > ( this->zDimIndices ) );
1481 
1482  //================================================ Note the change due to centering
1483  this->mapCOMProcessChangeX -= xDist;
1484  this->mapCOMProcessChangeY -= yDist;
1485  this->mapCOMProcessChangeZ -= zDist;
1486 
1487  //================================================ Report function completion
1488  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Map centered." );
1489 
1490  //================================================ Done
1491  return ;
1492 
1493 }

◆ 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 
)

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.
[out]fscThe FSC value found for the first (smallest) rotated map along the symmetry axis and the original map.

Definition at line 2541 of file ProSHADE_data.cpp.

2542 {
2543  //================================================ Ignore if already computed
2544  const FloatingPoint< proshade_double > lhs1 ( sym[6] ), rhs1 ( -1.0 );
2545  if ( !lhs1.AlmostEquals ( rhs1 ) ) { return ( sym[6] ); }
2546 
2547  //================================================ Report progress
2548  std::stringstream ss2;
2549  ss2 << "Computing FSC for symmetry C" << sym[0] << " ( " << sym[1] << " ; " << sym[2] << " ; " << sym[3] << " ) with peak height " << sym[5];
2550  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss2.str() );
2551 
2552  //================================================ Initialise local variables
2553  proshade_double *rotMap;
2554 
2555  //================================================ For each rotation along the axis
2556  proshade_double averageFSC = 0.0;
2557  for ( proshade_double rotIter = 1.0; rotIter < sym[0]; rotIter += 1.0 )
2558  {
2559  //============================================ Get rotated map by the smallest fold angle along the symmetry axis
2560  this->rotateMapRealSpace ( sym[1], sym[2], sym[3], ( ( 2.0 * M_PI ) / sym[0] ) * rotIter, rotMap );
2561 
2562  //============================================ Get Fourier for the rotated map
2563  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; }
2564  fftw_execute ( *planForwardFourier );
2565 
2566  //============================================ Clean FSC computation memory
2567  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; } }
2568  for ( size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { binCounts[binIt] = 0; }
2569 
2570  //============================================ Compute FSC
2571  averageFSC += ProSHADE_internal_maths::computeFSC ( origCoeffs, fCoeffs, this->xDimIndices, this->yDimIndices, this->zDimIndices, noBins, binIndexing, bindata, binCounts );
2572 
2573  //============================================ Release memory
2574  delete[] rotMap;
2575  }
2576 
2577  //================================================ Convert sum to average
2578  averageFSC /= ( sym[0] - 1.0 );
2579 
2580  //================================================ Save result to the axis
2581  sym[6] = averageFSC;
2582 
2583  //================================================ Report progress
2584  std::stringstream ss3;
2585  ss3 << "FSC value is " << averageFSC << " .";
2586  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 5, ss3.str() );
2587 
2588  //================================================ Done
2589  return ( averageFSC );
2590 
2591 }

◆ 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 
)

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.
[out]fscThe FSC value found for the first (smallest) rotated map along the symmetry axis and the original map.

Definition at line 2456 of file ProSHADE_data.cpp.

2457 {
2458  //================================================ Sanity check
2459  if ( symIndex >= CSym->size() )
2460  {
2461  std::cerr << "The supplied symmetry axes vector does not contain element number " << symIndex << ". Returning FSC 0.0." << std::endl;
2462  return ( -2.0 );
2463  }
2464 
2465  //================================================ Ignore if already computed
2466  const FloatingPoint< proshade_double > lhs1 ( CSym->at(symIndex)[6] ), rhs1 ( -1.0 );
2467  if ( !lhs1.AlmostEquals ( rhs1 ) ) { return ( CSym->at(symIndex)[6] ); }
2468 
2469  //================================================ Report progress
2470  std::stringstream ss2;
2471  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];
2472  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss2.str() );
2473 
2474  //================================================ Initialise local variables
2475  proshade_double *rotMap;
2476 
2477  //================================================ For each rotation along the axis
2478  proshade_double averageFSC = 0.0;
2479  for ( proshade_double rotIter = 1.0; rotIter < CSym->at(symIndex)[0]; rotIter += 1.0 )
2480  {
2481  //============================================ Get rotated map by the smallest fold angle along the symmetry axis
2482  this->rotateMapRealSpace ( CSym->at(symIndex)[1], CSym->at(symIndex)[2], CSym->at(symIndex)[3], ( ( 2.0 * M_PI ) / CSym->at(symIndex)[0] ) * rotIter, rotMap );
2483 
2484  //============================================ Get Fourier for the rotated map
2485  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; }
2486  fftw_execute ( *planForwardFourier );
2487 
2488  //============================================ Clean FSC computation memory
2489  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; } }
2490  for ( size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { binCounts[binIt] = 0; }
2491 
2492  //============================================ Compute FSC
2493  averageFSC += ProSHADE_internal_maths::computeFSC ( origCoeffs, fCoeffs, this->xDimIndices, this->yDimIndices, this->zDimIndices, noBins, binIndexing, bindata, binCounts );
2494 
2495  //============================================ Release memory
2496  delete[] rotMap;
2497  }
2498 
2499  //================================================ Convert sum to average
2500  averageFSC /= ( CSym->at(symIndex)[0] - 1.0 );
2501 
2502  //================================================ Save result to the axis
2503  CSym->at(symIndex)[6] = averageFSC;
2504 
2505  //================================================ Report progress
2506  std::stringstream ss3;
2507  ss3 << "FSC value is " << averageFSC << " .";
2508  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 5, ss3.str() );
2509 
2510  //================================================ Done
2511  return ( averageFSC );
2512 
2513 }

◆ computeOptimalTranslation()

void ProSHADE_internal_data::ProSHADE_data::computeOptimalTranslation ( proshade_double  eulA,
proshade_double  eulB,
proshade_double  eulG,
proshade_single  trsX,
proshade_single  trsY,
proshade_single  trsZ 
)

This function computes and saves the optimal translation vector from the already determined translation function results.

This function simply saves the determined optimal translation to the appropriate variable and does a simple modification to take into account any modifications that ProSHADE may have done to the internal map.

Parameters
[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]transXThe translation to be done along the X-axis in Angstroms.
[in]transYThe translation to be done along the Y-axis in Angstroms.
[in]transZThe translation to be done along the Z-axis in Angstroms.
Warning
This function will be called automatically by the getOptimalTranslation() function, so unless directAccess is being used, the user should not need to use this function.

Definition at line 109 of file ProSHADE_overlay.cpp.

110 {
111  //================================================ Reset class variables
112  this->originalPdbTransX = 0.0;
113  this->originalPdbTransY = 0.0;
114  this->originalPdbTransZ = 0.0;
115 
116  //================================================ Correctly apply any map modifications that ProSHADE may have done to the map to make sure map matches co-ordinates.
117  if ( ( eulA != 0.0 ) || ( eulB != 0.0 ) || ( eulG != 0.0 ) )
118  {
119  //============================================ If rotation is to be done, then ProSHADE processing map changes are already dealt with
120  ;
121  }
122  else
123  {
124  //============================================ In not, then they need to be added
128  }
129 
130  //================================================ Save the values
131  this->originalPdbTransX += static_cast< proshade_double > ( trsX );
132  this->originalPdbTransY += static_cast< proshade_double > ( trsY );
133  this->originalPdbTransZ += static_cast< proshade_double > ( trsZ );
134 
135  //================================================ Done
136  return ;
137 
138 }

◆ computePdbRotationCentre()

void ProSHADE_internal_data::ProSHADE_data::computePdbRotationCentre ( void  )

This function computes the optimal rotation centre for co-ordinates.

This function computes the "visualisation world" (or co-ordinates space) position of the point about which the map was rotated, taking into account the internal ProSHADE map manipulations and other factors. By rotating the co-ordinates about this point, their position and orientation will be the same as the map position before translation function is computed.

Warning
This function will be called automatically by the getOptimalTranslation() function, so unless directAccess is being used, the user should not need to use this function.

Definition at line 68 of file ProSHADE_overlay.cpp.

69 {
70  //================================================ First. determine the sampling rates (value to multiply indices with to get Angstroms)
71  proshade_double xSamplRate = static_cast<proshade_double> ( this->xDimSizeOriginal / static_cast< proshade_single > ( this->xDimIndicesOriginal ) );
72  proshade_double ySamplRate = static_cast<proshade_double> ( this->yDimSizeOriginal / static_cast< proshade_single > ( this->yDimIndicesOriginal ) );
73  proshade_double zSamplRate = static_cast<proshade_double> ( this->zDimSizeOriginal / static_cast< proshade_single > ( this->zDimIndicesOriginal ) );
74 
75  //================================================ Compute the rotation centre for the co-ordinates
76  proshade_double xRotPos = ( static_cast<proshade_double> ( this->xFrom ) - this->mapMovFromsChangeX ) * xSamplRate + // Corner X position in Angstroms
77  ( ( ( static_cast<proshade_double> ( this->xTo ) - static_cast<proshade_double> ( this->xFrom ) ) / 2.0 ) * xSamplRate ); // Half of box X size
78 
79  proshade_double yRotPos = ( static_cast<proshade_double> ( this->yFrom ) - this->mapMovFromsChangeY ) * ySamplRate + // Corner Y position in Angstroms
80  ( ( ( static_cast<proshade_double> ( this->yTo ) - static_cast<proshade_double> ( this->yFrom ) ) / 2.0 ) * ySamplRate ); // Half of box Y size
81 
82  proshade_double zRotPos = ( static_cast<proshade_double> ( this->zFrom ) - this->mapMovFromsChangeZ ) * zSamplRate + // Corner Z position in Angstroms
83  ( ( ( static_cast<proshade_double> ( this->zTo ) - static_cast<proshade_double> ( this->zFrom ) ) / 2.0 ) * zSamplRate ); // Half of box Z size
84 
85  //============================================ Modify by change during ProSHADE map processing
86  this->originalPdbRotCenX = xRotPos - ( this->mapCOMProcessChangeX / 2.0 );
87  this->originalPdbRotCenY = yRotPos - ( this->mapCOMProcessChangeY / 2.0 );
88  this->originalPdbRotCenZ = zRotPos - ( this->mapCOMProcessChangeZ / 2.0 );
89 
90  //================================================ Done
91  return ;
92 
93 }

◆ 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." );
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." );
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 );
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." );
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 1756 of file ProSHADE_data.cpp.

1757 {
1758  //================================================ Report progress
1759  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting spherical harmonics decomposition." );
1760 
1761  //================================================ Initialise memory
1762  this->sphericalHarmonics = new proshade_complex* [this->noSpheres];
1763  ProSHADE_internal_misc::checkMemoryAllocation ( this->sphericalHarmonics, __FILE__, __LINE__, __func__ );
1764  for ( proshade_unsign iter = 0; iter < this->noSpheres; iter++ )
1765  {
1766  this->sphericalHarmonics[iter] = new proshade_complex [(this->spheres[iter]->getLocalBandwidth() * 2) * (this->spheres[iter]->getLocalBandwidth() * 2)];
1767  ProSHADE_internal_misc::checkMemoryAllocation ( this->sphericalHarmonics[iter], __FILE__, __LINE__, __func__ );
1768  }
1769 
1770  //================================================ Compute the spherical harmonics
1771  for ( proshade_unsign iter = 0; iter < this->noSpheres; iter++ )
1772  {
1773  //============================================ Report progress
1774  std::stringstream ss;
1775  ss << "Now decomposing sphere " << iter << ". " << "( Band is: " << this->spheres[iter]->getLocalBandwidth() << ").";
1776  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss.str() );
1777 
1778  //============================================ Compute
1779  ProSHADE_internal_sphericalHarmonics::computeSphericalHarmonics ( this->spheres[iter]->getLocalBandwidth(), this->spheres[iter]->getMappedData(), this->sphericalHarmonics[iter] );
1780  }
1781 
1782  //================================================ Report completion
1783  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Spherical harmonics decomposition complete." );
1784 
1785  //======================================== Done
1786  return ;
1787 
1788 }

◆ 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 398 of file ProSHADE_overlay.cpp.

399 {
400  //================================================ Do this using Fourier!
401  fftw_complex *tmpIn1 = nullptr, *tmpOut1 = nullptr, *tmpIn2 = nullptr, *tmpOut2 = nullptr, *resOut = nullptr;
402  fftw_plan forwardFourierObj1, forwardFourierObj2, inverseFourierCombo;
403  proshade_unsign dimMult = staticStructure->getXDim() * staticStructure->getYDim() * staticStructure->getZDim();
404  ProSHADE_internal_overlay::allocateTranslationFunctionMemory ( tmpIn1, tmpOut1, tmpIn2, tmpOut2, this->translationMap, resOut, forwardFourierObj1, forwardFourierObj2, inverseFourierCombo, staticStructure->getXDim(), staticStructure->getYDim(), staticStructure->getZDim() );
405 
406  //================================================ Fill in input data
407  for ( proshade_unsign iter = 0; iter < dimMult; iter++ ) { tmpIn1[iter][0] = staticStructure->getMapValue ( iter ); tmpIn1[iter][1] = 0.0; }
408  for ( proshade_unsign iter = 0; iter < dimMult; iter++ ) { tmpIn2[iter][0] = this->getMapValue ( iter ); tmpIn2[iter][1] = 0.0; }
409 
410  //================================================ Calculate Fourier
411  fftw_execute ( forwardFourierObj1 );
412  fftw_execute ( forwardFourierObj2 );
413 
414  //================================================ Combine Fourier coeffs and invert
415  ProSHADE_internal_overlay::combineFourierForTranslation ( tmpOut1, tmpOut2, resOut, staticStructure->getXDim(), staticStructure->getYDim(), staticStructure->getZDim() );
416  fftw_execute ( inverseFourierCombo );
417 
418  //================================================ Free memory
419  ProSHADE_internal_overlay::freeTranslationFunctionMemory ( tmpIn1, tmpOut1, tmpIn2, tmpOut2, resOut, forwardFourierObj1, forwardFourierObj2, inverseFourierCombo );
420 
421  //================================================ Done
422  return ;
423 
424 }

◆ 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 120 of file ProSHADE_symmetry.cpp.

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

◆ 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 1300 of file ProSHADE_data.cpp.

1301 {
1302  //================================================ Report function start
1303  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Creating new structure according to the new bounds." );
1304 
1305  //================================================ Fill in basic info
1306  newStr->fileName = "N/A";
1307  newStr->fileType = ProSHADE_internal_io::MAP;
1308 
1309  //================================================ Fill in new structure values
1310  newStr->xDimIndices = static_cast< proshade_unsign > ( newBounds[1] ) - static_cast< proshade_unsign > ( newBounds[0] ) + 1;
1311  newStr->yDimIndices = static_cast< proshade_unsign > ( newBounds[3] ) - static_cast< proshade_unsign > ( newBounds[2] ) + 1;
1312  newStr->zDimIndices = static_cast< proshade_unsign > ( newBounds[5] ) - static_cast< proshade_unsign > ( newBounds[4] ) + 1;
1313 
1314  newStr->aAngle = this->aAngle;
1315  newStr->bAngle = this->aAngle;
1316  newStr->cAngle = this->aAngle;
1317 
1318  newStr->xDimSize = static_cast<proshade_single> ( newStr->xDimIndices ) * ( this->xDimSize / static_cast<proshade_single> ( this->xDimIndices ) );
1319  newStr->yDimSize = static_cast<proshade_single> ( newStr->yDimIndices ) * ( this->yDimSize / static_cast<proshade_single> ( this->yDimIndices ) );
1320  newStr->zDimSize = static_cast<proshade_single> ( newStr->zDimIndices ) * ( this->zDimSize / static_cast<proshade_single> ( this->zDimIndices ) );
1321 
1322  newStr->xGridIndices = newStr->xDimIndices;
1323  newStr->yGridIndices = newStr->yDimIndices;
1324  newStr->zGridIndices = newStr->zDimIndices;
1325 
1326  newStr->xAxisOrder = this->xAxisOrder;
1327  newStr->yAxisOrder = this->yAxisOrder;
1328  newStr->zAxisOrder = this->zAxisOrder;
1329 
1330  newStr->xAxisOrigin = this->xAxisOrigin + newBounds[0];
1331  newStr->yAxisOrigin = this->yAxisOrigin + newBounds[2];
1332  newStr->zAxisOrigin = this->zAxisOrigin + newBounds[4];
1333 
1334  newStr->xFrom = this->xFrom + newBounds[0];
1335  newStr->yFrom = this->yFrom + newBounds[2];
1336  newStr->zFrom = this->zFrom + newBounds[4];
1337 
1338  newStr->xTo = this->xTo - ( static_cast< proshade_signed > ( this->xDimIndices - 1 ) - newBounds[1] );
1339  newStr->yTo = this->yTo - ( static_cast< proshade_signed > ( this->yDimIndices - 1 ) - newBounds[3] );
1340  newStr->zTo = this->zTo - ( static_cast< proshade_signed > ( this->zDimIndices - 1 ) - newBounds[5] );
1341 
1342  //================================================ Allocate new structure map
1343  newStr->internalMap = new proshade_double[newStr->xDimIndices * newStr->yDimIndices * newStr->zDimIndices];
1344  ProSHADE_internal_misc::checkMemoryAllocation ( newStr->internalMap, __FILE__, __LINE__, __func__ );
1345 
1346  //================================================ Copy the map
1347  ProSHADE_internal_mapManip::copyMapByBounds ( newStr->xFrom, newStr->xTo, newStr->yFrom, newStr->yTo, newStr->zFrom, newStr->zTo,
1348  this->xFrom, this->yFrom, this->zFrom, newStr->yDimIndices, newStr->zDimIndices,
1349  this->xDimIndices, this->yDimIndices, this->zDimIndices, newStr->internalMap, this->internalMap );
1350 
1351  //================================================ Report function completion
1352  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "New structure created." );
1353 
1354  //================================================ Done
1355  return ;
1356 
1357 }

◆ 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 3466 of file ProSHADE_data.cpp.

3467 {
3468  //================================================ Sanity check
3469  if ( saveTo != nullptr )
3470  {
3471  ProSHADE_internal_messages::printWarningMessage ( verbose, "!!! ProSHADE WARNING !!! The deep copy pointer is not set to NULL. Cannot proceed and returning unmodified pointer.", "WB00040" );
3472  return ;
3473  }
3474 
3475  //================================================ Allocate the memory
3476  saveTo = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
3477 
3478  //================================================ Check memory allocation
3479  ProSHADE_internal_misc::checkMemoryAllocation ( saveTo, __FILE__, __LINE__, __func__ );
3480 
3481  //================================================ Copy internal map to the new pointer
3482  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
3483  {
3484  saveTo[iter] = this->internalMap[iter];
3485  }
3486 
3487  //================================================ Done
3488  return ;
3489 
3490 }

◆ 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 1934 of file ProSHADE_data.cpp.

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

◆ detectSymmetryInStructure()

void ProSHADE_internal_data::ProSHADE_data::detectSymmetryInStructure ( 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 and saves the results in the settings object.

This function is the symmetry detection starting point. It decides whether a specific symmetry is being sought after, or whether a general symmetry search is required. Consequently, it calls the appropriate functions and ends up with saving the resulting predictions into the settings object supplied. It also saves all the detected symmetry groups to the settings object for further processing and programmatical access.

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 1801 of file ProSHADE_data.cpp.

1802 {
1803  //================================================ Prepare FSC computation memory and variables
1804  fftw_complex *mapData, *origCoeffs, *fCoeffs;
1805  fftw_plan planForwardFourier;
1806  proshade_double **bindata;
1807  proshade_signed *binIndexing, *binCounts, noBins;
1808  this->prepareFSCFourierMemory ( mapData, origCoeffs, fCoeffs, binIndexing, &noBins, bindata, binCounts, &planForwardFourier );
1809 
1810  //================================================ Initialise variables
1811  std::vector< proshade_double* > CSyms = this->getCyclicSymmetriesList ( settings );
1812 
1813  //================================================ Was any particular symmetry requested?
1814  if ( settings->requestedSymmetryType == "" )
1815  {
1816  //============================================ Run the symmetry detection functions for C, D, T, O and I symmetries
1817  std::vector< proshade_double* > DSyms = this->getDihedralSymmetriesList ( settings, &CSyms );
1818  std::vector< proshade_double* > ISyms = this->getIcosahedralSymmetriesList ( settings, &CSyms );
1819  std::vector< proshade_double* > OSyms; std::vector< proshade_double* > TSyms;
1820  if ( ISyms.size() < 31 ) { OSyms = this->getOctahedralSymmetriesList ( settings, &CSyms ); if ( OSyms.size() < 13 ) { TSyms = this->getTetrahedralSymmetriesList ( settings, &CSyms ); } }
1821 
1822  //============================================ Decide on recommended symmetry
1823  this->saveRecommendedSymmetry ( settings, &CSyms, &DSyms, &TSyms, &OSyms, &ISyms, axes, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts );
1824  }
1825 
1826  if ( settings->requestedSymmetryType == "C" )
1827  {
1828  //============================================ Run only the C symmetry detection and search for requested fold
1829  this->saveRequestedSymmetryC ( settings, &CSyms, axes );
1830  }
1831 
1832  if ( settings->requestedSymmetryType == "D" )
1833  {
1834  //============================================ Run only the D symmetry detection and search for requested fold
1835  std::vector< proshade_double* > DSyms = this->getDihedralSymmetriesList ( settings, &CSyms );
1836  this->saveRequestedSymmetryD ( settings, &DSyms, axes, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts );
1837  }
1838 
1839  if ( settings->requestedSymmetryType == "T" )
1840  {
1841  //============================================ Run only the T symmetry detection and search for requested fold
1842  std::vector< proshade_double* > TSyms = this->getTetrahedralSymmetriesList ( settings, &CSyms );
1843  settings->setRecommendedFold ( 0 );
1844  if ( TSyms.size() == 7 ) { settings->setRecommendedSymmetry ( "T" ); for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( TSyms.size() ); it++ ) { settings->setDetectedSymmetry ( TSyms.at(it) ); ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, TSyms.at(it) ); } }
1845  else { settings->setRecommendedSymmetry ( "" ); }
1846  }
1847 
1848  if ( settings->requestedSymmetryType == "O" )
1849  {
1850  //============================================ Run only the O symmetry detection and search for requested fold
1851  std::vector< proshade_double* > OSyms = this->getOctahedralSymmetriesList ( settings, &CSyms );
1852  settings->setRecommendedFold ( 0 );
1853  if ( OSyms.size() == 13 ) { settings->setRecommendedSymmetry ( "O" ); for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( OSyms.size() ); it++ ) { settings->setDetectedSymmetry ( OSyms.at(it) ); ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, OSyms.at(it) ); } }
1854  else { settings->setRecommendedSymmetry ( "" ); }
1855  }
1856 
1857  if ( settings->requestedSymmetryType == "I" )
1858  {
1859  //============================================ Run only the T symmetry detection and search for requested fold
1860  std::vector< proshade_double* > ISyms = this->getIcosahedralSymmetriesList ( settings, &CSyms );
1861  settings->setRecommendedFold ( 0 );
1862  if ( ISyms.size() == 31 ) { settings->setRecommendedSymmetry ( "I" ); for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( ISyms.size() ); it++ ) { settings->setDetectedSymmetry ( ISyms.at(it) ); ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, ISyms.at(it) ); } }
1863  else { settings->setRecommendedSymmetry ( "" ); }
1864  }
1865 
1866  if ( ( settings->requestedSymmetryType != "" ) && ( settings->requestedSymmetryType != "C" ) && ( settings->requestedSymmetryType != "D" ) && ( settings->requestedSymmetryType != "T" ) && ( settings->requestedSymmetryType != "O" ) && ( settings->requestedSymmetryType != "I" ) )
1867  {
1868  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." );
1869  }
1870 
1871  //================================================ Save C symmetries to argument and if different from settings, to the settings as well
1872  bool isArgSameAsSettings = true;
1873  for ( proshade_unsign cIt = 0; cIt < static_cast<proshade_unsign> ( CSyms.size() ); cIt++ )
1874  {
1875  std::vector< proshade_double > nextSym;
1876  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms.at(cIt)[0] );
1877  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms.at(cIt)[1] );
1878  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms.at(cIt)[2] );
1879  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms.at(cIt)[3] );
1880  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms.at(cIt)[4] );
1881  ProSHADE_internal_misc::addToDoubleVector ( &nextSym, CSyms.at(cIt)[5] );
1883 
1884  if ( ( cIt == 0 ) && ( settings->allDetectedCAxes.size() == 0 ) ) { isArgSameAsSettings = false; }
1885  if ( !isArgSameAsSettings ) { ProSHADE_internal_misc::addToDoubleVectorVector ( &settings->allDetectedCAxes, nextSym ); }
1886 
1887  nextSym.clear ( );
1888  }
1889 
1890  //================================================ Release memory
1891  for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( CSyms.size() ); it++ ) { delete[] CSyms.at(it); }
1892 
1893  //================================================ Release memory after FSC computation
1894  delete[] mapData;
1895  delete[] origCoeffs;
1896  delete[] fCoeffs;
1897  fftw_destroy_plan ( planForwardFourier );
1898  delete[] binIndexing;
1899  for (size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { delete[] bindata[binIt]; }
1900  delete[] bindata;
1901  delete[] binCounts;
1902 
1903  //================================================ Done
1904  return ;
1905 
1906 }

◆ 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 926 of file ProSHADE_data.cpp.

927 {
928  //================================================ Set ends to origin + size - 1
929  this->xTo = this->xFrom + static_cast< proshade_signed > ( this->xDimIndices ) - 1;
930  this->yTo = this->yFrom + static_cast< proshade_signed > ( this->yDimIndices ) - 1;
931  this->zTo = this->zFrom + static_cast< proshade_signed > ( this->zDimIndices ) - 1;
932 
933  //================================================ Done
934  return ;
935 
936 }

◆ 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 3554 of file ProSHADE_data.cpp.

3555 {
3556  //================================================ Initialise variables
3557  this->xCom = 0.0;
3558  this->yCom = 0.0;
3559  this->zCom = 0.0;
3560  proshade_double totNonZeroPoints = 0.0;
3561  proshade_signed mapIt = 0;
3562 
3563  //================================================ Compute COM from 0 ; 0 ; 0
3564  for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->xDimIndices ); xIt++ )
3565  {
3566  for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->yDimIndices ); yIt++ )
3567  {
3568  for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->zDimIndices ); zIt++ )
3569  {
3570  //==================================== Find map index
3571  mapIt = zIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( yIt + static_cast< proshade_signed > ( this->yDimIndices ) * xIt );
3572 
3573  //==================================== Use only positive density
3574  if ( this->internalMap[mapIt] <= 0.0 ) { continue; }
3575 
3576  //==================================== Compute Index COM
3577  this->xCom += this->internalMap[mapIt] * static_cast<proshade_double> ( xIt + this->xFrom );
3578  this->yCom += this->internalMap[mapIt] * static_cast<proshade_double> ( yIt + this->yFrom );
3579  this->zCom += this->internalMap[mapIt] * static_cast<proshade_double> ( zIt + this->zFrom );
3580  totNonZeroPoints += this->internalMap[mapIt];
3581  }
3582  }
3583  }
3584 
3585  this->xCom /= totNonZeroPoints;
3586  this->yCom /= totNonZeroPoints;
3587  this->zCom /= totNonZeroPoints;
3588 
3589  //================================================ Convert to real world
3590  this->xCom = static_cast< proshade_double > ( ( static_cast< proshade_single > ( this->xFrom ) * ( this->xDimSizeOriginal / static_cast< proshade_single > ( this->xDimIndicesOriginal ) ) ) +
3591  ( ( static_cast< proshade_single > ( this->xCom ) - static_cast< proshade_single > ( this->xFrom ) ) *
3592  ( static_cast< proshade_single > ( this->xDimSizeOriginal ) / static_cast< proshade_single > ( this->xDimIndicesOriginal ) ) ) );
3593  this->yCom = static_cast< proshade_double > ( ( static_cast< proshade_single > ( this->yFrom ) * ( this->yDimSizeOriginal / static_cast< proshade_single > ( this->yDimIndicesOriginal ) ) ) +
3594  ( ( static_cast< proshade_single > ( this->yCom ) - static_cast< proshade_single > ( this->yFrom ) ) *
3595  ( static_cast< proshade_single > ( this->yDimSizeOriginal ) / static_cast< proshade_single > ( this->yDimIndicesOriginal ) ) ) );
3596  this->zCom = static_cast< proshade_double > ( ( static_cast< proshade_single > ( this->zFrom ) * ( this->zDimSizeOriginal / static_cast< proshade_single > ( this->zDimIndicesOriginal ) ) ) +
3597  ( ( static_cast< proshade_single > ( this->zCom ) - static_cast< proshade_single > ( this->zFrom ) ) *
3598  ( static_cast< proshade_single > ( this->zDimSizeOriginal ) / static_cast< proshade_single > ( this->zDimIndicesOriginal ) ) ) );
3599 
3600  //================================================ Done
3601  return ;
3602 
3603 }

◆ 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 3895 of file ProSHADE_symmetry.cpp.

3896 {
3897  //================================================ Initialise variables
3898  proshade_double soughtAngle;
3899  std::vector< proshade_double > allPeakHeights;
3900  std::vector< ProSHADE_internal_spheres::ProSHADE_rotFun_spherePeakGroup* > peakGroups;
3901  std::vector< proshade_double* > ret;
3902  bool newPeak;
3903 
3904  //================================================ Make sure we have a clean start
3905  this->sphereMappedRotFun.clear();
3906 
3907  //================================================ Convert rotation function to only the required angle-axis space spheres and find all peaks
3908  for ( proshade_double angIt = 1.0; angIt < static_cast<proshade_double> ( fold ); angIt += 1.0 )
3909  {
3910  //============================================ Figure the angles to form the symmetry
3911  soughtAngle = angIt * ( 2.0 * M_PI / static_cast<proshade_double> ( fold ) );
3912 
3913  //============================================ Create the angle-axis sphere with correct radius (angle)
3914  this->sphereMappedRotFun.emplace_back ( new ProSHADE_internal_spheres::ProSHADE_rotFun_sphere ( soughtAngle,
3915  M_PI / static_cast< proshade_double > ( this->maxShellBand ),
3916  this->maxShellBand * 2,
3917  soughtAngle,
3918  static_cast<proshade_unsign> ( angIt - 1.0 ) ) );
3919 
3920  //=========================================== Interpolate rotation function onto the sphere
3921  this->sphereMappedRotFun.at(static_cast<proshade_unsign> ( angIt - 1.0 ))->interpolateSphereValues ( this->getInvSO3Coeffs ( ) );
3922 
3923  //============================================ Find all peaks for this sphere
3924  this->sphereMappedRotFun.at(static_cast<proshade_unsign> ( angIt - 1.0 ))->findAllPeaks ( static_cast< proshade_signed > ( settings->peakNeighbours ), &allPeakHeights );
3925  }
3926 
3927  //============================================ Report progress
3928  std::stringstream hlpSS;
3929  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.";
3930  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, hlpSS.str() );
3931 
3932  //================================================ Determine the threshold for significant peaks
3933  *peakThres = std::max ( settings->minSymPeak, determinePeakThreshold ( allPeakHeights, settings->noIQRsFromMedianNaivePeak ) );
3934 
3935  //============================================ Report progress
3936  std::stringstream hlpSS2;
3937  hlpSS2 << "Determined peak threshold " << *peakThres << ".";
3938  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, hlpSS2.str() );
3939 
3940  //================================================ Remove small peaks
3941  for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); shIt++ )
3942  {
3943  this->sphereMappedRotFun.at(shIt)->removeSmallPeaks ( *peakThres );
3944  }
3945 
3946  //================================================ Group peaks
3947  for ( proshade_unsign sphIt = 0; sphIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); sphIt++ )
3948  {
3949  //============================================ For each peak
3950  for ( proshade_unsign pkIt = 0; pkIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.at(sphIt)->getPeaks().size() ); pkIt++ )
3951  {
3952  //======================================== Check if peak belongs to an already detected peak group
3953  newPeak = true;
3954  for ( proshade_unsign pkGrpIt = 0; pkGrpIt < static_cast<proshade_unsign> ( peakGroups.size() ); pkGrpIt++ )
3955  {
3956  if ( peakGroups.at(pkGrpIt)->checkIfPeakBelongs ( static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).first ),
3957  static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).second ),
3958  sphIt, settings->axisErrTolerance, settings->verbose ) ) { newPeak = false; break; }
3959  }
3960 
3961  //======================================== If already added, go to next one
3962  if ( !newPeak ) { continue; }
3963 
3964  //======================================== If not, create a new group with this peak
3965  peakGroups.emplace_back ( new ProSHADE_internal_spheres::ProSHADE_rotFun_spherePeakGroup ( static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).first ),
3966  static_cast< proshade_double > ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).second ),
3967  sphIt,
3968  this->sphereMappedRotFun.at(sphIt)->getAngularDim() ) );
3969  }
3970  }
3971 
3972  //================================================ For each peak group, look for the requested fold
3973  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( peakGroups.size() ); grIt++ )
3974  {
3975  //============================================ Report progress
3976  std::stringstream hlpSS3;
3977  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 ";
3978  for ( proshade_unsign sphIt = 0; sphIt < static_cast<proshade_unsign> ( peakGroups.at(grIt)->getSpherePositions().size() ); sphIt++ ) { hlpSS3 << peakGroups.at(grIt)->getSpherePositions().at(sphIt) << " ; "; }
3979  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 5, hlpSS3.str() );
3980 
3981  //============================================ Find point groups in the peak group
3982  peakGroups.at(grIt)->findCyclicPointGroupsGivenFold ( this->sphereMappedRotFun, &ret, settings->useBiCubicInterpolationOnPeaks, fold, settings->verbose );
3983 
3984  //============================================ Release the memory
3985  delete peakGroups.at(grIt);
3986  }
3987 
3988  //================================================ Sort ret by peak height
3989  std::sort ( ret.begin(), ret.end(), sortProSHADESymmetryByPeak );
3990 
3991  //================================================ Done
3992  return ( ret );
3993 
3994 }

◆ findTopGroupSmooth()

proshade_double ProSHADE_internal_data::ProSHADE_data::findTopGroupSmooth ( std::vector< proshade_double * > *  CSym,
size_t  peakPos,
proshade_double  step,
proshade_double  sigma,
proshade_signed  windowSize 
)

This function finds the distinct group of axes with highest peak heights.

This function starts by getting a vector of all peak heights detected in all C symmetries detected in the structure. It then proceeds to convert this vector into a histogram, which it then smoothens using Gaussian convolution according to the input parameters. Finally, it searches for peaks in the smoothened histogram function and reports the minimal value that average peak height must be in order for the axis to be considered part of this top group.

Parameters
[in]CSymA vector of pointers to double arrays, each array being a single Cyclic symmetry entry.
[in]stepThe granulosity of the interval <0,1> using which the search should be done.
[in]sigmaThe variance of the Gaussian used to smoothen the peak height histogram.
[in]windowSizeThe width of the window over which smoothening is done.
[out]thresholdThe minimum peak height that an axis needs to have to be considered a member of the distinct top group.

Definition at line 2332 of file ProSHADE_data.cpp.

2333 {
2334  //================================================ Initialise local variables
2335  proshade_double threshold = 0.0;
2336  proshade_signed totSize = static_cast< proshade_signed > ( ( 1.0 / step ) + 1 );
2337  std::vector< std::pair < proshade_double, proshade_unsign > > vals;
2338  std::vector< proshade_double > hist ( static_cast< unsigned long int > ( totSize ), 0.0 );
2339  proshade_unsign histPos = 0;
2340 
2341  //================================================ Make sure window size is odd
2342  if ( windowSize % 2 == 0 ) { windowSize += 1; }
2343 
2344  //================================================ Get vector of pairs of peak heights and indices in CSym array
2345  for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( CSym->size() ); symIt++ ) { vals.emplace_back ( std::pair < proshade_double, proshade_unsign > ( CSym->at(symIt)[peakPos], symIt ) ); }
2346 
2347  //================================================ Convert all found heights to histogram from 0.0 to 1.0 by step
2348  for ( proshade_double it = 0.0; it <= 1.0; it = it + step )
2349  {
2350  for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( vals.size() ); symIt++ )
2351  {
2352  //======================================== Is this height in the range?
2353  if ( ( vals.at(symIt).first > it ) && ( vals.at(symIt).first <= ( it + step ) ) ) { hist.at(histPos) += 1.0; }
2354  }
2355 
2356  //============================================ Update counter and continue
2357  histPos += 1;
2358  }
2359 
2360  //================================================ Smoothen the distribution
2361  std::vector< proshade_double > smoothened = ProSHADE_internal_maths::smoothen1D ( step, windowSize, sigma, hist );
2362 
2363  //================================================ Find peaks in smoothened data
2364  std::vector< proshade_signed > peaks = ProSHADE_internal_peakSearch::findPeaks1D ( smoothened );
2365 
2366  //================================================ Take best peaks surroundings and produce a new set of "high" axes
2367  proshade_signed bestHistPos;
2368  if ( peaks.size() > 0 ) { bestHistPos = peaks.at(peaks.size()-1) + ( ( windowSize - 1 ) / 2 ); }
2369  else { bestHistPos = 0.0; }
2370 
2371  threshold = ( static_cast< proshade_double > ( bestHistPos ) * step ) - ( static_cast< proshade_double > ( windowSize ) * step );
2372 
2373  //================================================ Done
2374  return ( threshold );
2375 
2376 }

◆ getAllGroupElements()

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 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 second parameter, where these need to be detected by ProSHADE first and then their index in the ProSHADE cyclic group detected list can be given here.

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 isses 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 3199 of file ProSHADE_data.cpp.

3200 {
3201  //================================================ Initialise variables
3202  std::vector<std::vector< proshade_double > > ret;
3203 
3204  //================================================ Select which symmetry type are we computing for
3205  if ( groupType == "C" )
3206  {
3207  //============================================ Sanity check
3208  axesToGroupTypeSanityCheck ( 1, static_cast< proshade_unsign > ( axesList.size() ), groupType );
3209 
3210  //============================================ Generate elements
3211  ret = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(0)).at(1),
3212  settings->allDetectedCAxes.at(axesList.at(0)).at(2),
3213  settings->allDetectedCAxes.at(axesList.at(0)).at(3),
3214  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(0)).at(0) ) );
3215 
3216  //============================================ Check the element to form a group
3217  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3218  else
3219  {
3220  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." );
3221  }
3222  }
3223  else if ( groupType == "D" )
3224  {
3225  //============================================ Sanity check
3226  axesToGroupTypeSanityCheck ( 2, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3227 
3228  //============================================ Generate elements for both axes
3229  std::vector<std::vector< proshade_double > > first = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(0)).at(1),
3230  settings->allDetectedCAxes.at(axesList.at(0)).at(2),
3231  settings->allDetectedCAxes.at(axesList.at(0)).at(3),
3232  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(0)).at(0) ) );
3233  std::vector<std::vector< proshade_double > > second = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(1)).at(1),
3234  settings->allDetectedCAxes.at(axesList.at(1)).at(2),
3235  settings->allDetectedCAxes.at(axesList.at(1)).at(3),
3236  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(1)).at(0) ) );
3237 
3238  //============================================ Join the element lists
3239  ret = joinElementsFromDifferentGroups ( &first, &second, matrixTolerance, true );
3240 
3241  //============================================ Check the element to form a group
3242  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3243  else
3244  {
3245  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." );
3246  }
3247  }
3248  else if ( groupType == "T" )
3249  {
3250  //============================================ Sanity check
3251  axesToGroupTypeSanityCheck ( 7, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3252 
3253  //============================================ Generate elements for all four C3 axes first
3254  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3255  {
3256  //======================================== If this is a C3 axis
3257  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3258  if ( lhs1.AlmostEquals ( rhs1 ) )
3259  {
3260  //==================================== Generate the elements
3261  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3262  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3263  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3264  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3265 
3266  //==================================== Join the elements to any already found
3267  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3268  }
3269  }
3270 
3271  //============================================ Generate elements for all three C2 axes second
3272  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3273  {
3274  //======================================== If this is a C3 axis
3275  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3276  if ( lhs1.AlmostEquals ( rhs1 ) )
3277  {
3278  //==================================== Generate the elements
3279  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3280  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3281  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3282  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3283 
3284  //==================================== Join the elements to any already found
3285  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3286  }
3287  }
3288 
3289  //============================================ Check the element to form a group
3290  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3291  else
3292  {
3293  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." );
3294  }
3295  }
3296  else if ( groupType == "O" )
3297  {
3298  //============================================ Sanity check
3299  axesToGroupTypeSanityCheck ( 13, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3300 
3301  //============================================ Generate elements for all three C4 axes first
3302  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3303  {
3304  //======================================== If this is a C3 axis
3305  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 4.0 );
3306  if ( lhs1.AlmostEquals ( rhs1 ) )
3307  {
3308  //==================================== Generate the elements
3309  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3310  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3311  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3312  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3313 
3314  //==================================== Join the elements to any already found
3315  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3316  }
3317  }
3318 
3319  //============================================ Generate elements for all four C3 axes first
3320  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3321  {
3322  //======================================== If this is a C3 axis
3323  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3324  if ( lhs1.AlmostEquals ( rhs1 ) )
3325  {
3326  //==================================== Generate the elements
3327  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3328  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3329  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3330  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3331 
3332  //==================================== Join the elements to any already found
3333  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3334  }
3335  }
3336 
3337  //============================================ Generate elements for all six C2 axes next
3338  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3339  {
3340  //======================================== If this is a C3 axis
3341  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3342  if ( lhs1.AlmostEquals ( rhs1 ) )
3343  {
3344  //==================================== Generate the elements
3345  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3346  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3347  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3348  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3349 
3350  //==================================== Join the elements to any already found
3351  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3352  }
3353  }
3354 
3355  //============================================ Check the element to form a group
3356  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3357  else
3358  {
3359  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." );
3360  }
3361  }
3362  else if ( groupType == "I" )
3363  {
3364  //============================================ Sanity check
3365  axesToGroupTypeSanityCheck ( 31, static_cast<proshade_unsign> ( axesList.size() ), groupType );
3366 
3367  //============================================ Generate elements for all six C5 axes first
3368  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3369  {
3370  //======================================== If this is a C5 axis
3371  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 5.0 );
3372  if ( lhs1.AlmostEquals ( rhs1 ) )
3373  {
3374  //==================================== Generate the elements
3375  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3376  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3377  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3378  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3379 
3380  //==================================== Join the elements to any already found
3381  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3382  }
3383  }
3384 
3385  //============================================ Generate elements for all ten C3 axes next
3386  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3387  {
3388  //======================================== If this is a C3 axis
3389  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3390  if ( lhs1.AlmostEquals ( rhs1 ) )
3391  {
3392  //==================================== Generate the elements
3393  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3394  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3395  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3396  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3397 
3398  //==================================== Join the elements to any already found
3399  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3400  }
3401  }
3402 
3403  //============================================ Generate elements for all fifteen C2 axes lastly
3404  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3405  {
3406  //======================================== If this is a C3 axis
3407  const FloatingPoint< proshade_double > lhs1 ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3408  if ( lhs1.AlmostEquals ( rhs1 ) )
3409  {
3410  //==================================== Generate the elements
3411  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3412  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3413  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3414  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3415 
3416  //==================================== Join the elements to any already found
3417  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, false );
3418  }
3419  }
3420 
3421  //============================================ Check the element to form a group
3422  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3423  else
3424  {
3425  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." );
3426  }
3427  }
3428  else if ( groupType == "X" )
3429  {
3430  //============================================ User forced no checking for unspecified symmetry
3431  for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3432  {
3433  //======================================== Compute group elements
3434  std::vector<std::vector< proshade_double > > els = computeGroupElementsForGroup ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(1),
3435  settings->allDetectedCAxes.at(axesList.at(grIt)).at(2),
3436  settings->allDetectedCAxes.at(axesList.at(grIt)).at(3),
3437  static_cast< proshade_signed > ( settings->allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3438 
3439  //======================================== Join the elements to any already found
3440  ret = joinElementsFromDifferentGroups ( &els, &ret, matrixTolerance, true );
3441  }
3442 
3443  //============================================ Check the element to form a group
3444  if ( checkElementsFormGroup ( &ret, matrixTolerance ) ) { return ( ret ); }
3445  else
3446  {
3447  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." );
3448  }
3449  }
3450  else
3451  {
3452  std::stringstream hlpSS;
3453  hlpSS << "Unknown symmetry type: >" << groupType << "<";
3454  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." );
3455  }
3456 
3457 }

◆ 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 3780 of file ProSHADE_data.cpp.

3781 {
3782  //================================================ Done
3783  return ( this->spheres[shell]->getShellRadius() );
3784 
3785 }

◆ 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 1472 of file ProSHADE_overlay.cpp.

1473 {
1474  //================================================ Initialise local variables
1475  std::vector < proshade_double > ret;
1476  proshade_double eulA, eulB, eulG;
1477 
1478  //================================================ Get inverse SO(3) map top peak Euler angle values
1480  this->getMaxBand() * 2,
1481  &eulA, &eulB, &eulG, settings );
1482 
1483  //================================================ Re-format to vector
1487 
1488  //================================================ Done
1489  return ( ret );
1490 
1491 }

◆ getBestTranslationMapPeaksAngstrom()

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

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 311 of file ProSHADE_overlay.cpp.

312 {
313  //================================================ Initialise local variables
314  std::vector< proshade_double > ret;
315  proshade_double mapPeak = 0.0;
316  proshade_double trsX = 0.0, trsY = 0.0, trsZ = 0.0;
318  staticStructure->getXDim(),
319  staticStructure->getYDim(),
320  staticStructure->getZDim(),
321  &trsX,
322  &trsY,
323  &trsZ,
324  &mapPeak );
325 
326  //================================================ Dont translate over half
327  if ( trsX > ( static_cast< proshade_double > ( staticStructure->getXDim() ) / 2.0 ) ) { trsX = trsX - static_cast< proshade_double > ( this->getXDim() ); }
328  if ( trsY > ( static_cast< proshade_double > ( staticStructure->getYDim() ) / 2.0 ) ) { trsY = trsY - static_cast< proshade_double > ( this->getYDim() ); }
329  if ( trsZ > ( static_cast< proshade_double > ( staticStructure->getZDim() ) / 2.0 ) ) { trsZ = trsZ - static_cast< proshade_double > ( this->getZDim() ); }
330 
331  //================================================ Move map
332  proshade_single xCor = static_cast< proshade_single > ( static_cast< proshade_double > ( staticStructure->xFrom - this->xFrom ) *
333  ( static_cast< proshade_double > ( staticStructure->getXDimSize() ) /
334  static_cast< proshade_double > ( staticStructure->getXDim() ) ) );
335  proshade_single yCor = static_cast< proshade_single > ( static_cast< proshade_double > ( staticStructure->yFrom - this->yFrom ) *
336  ( static_cast< proshade_double > ( staticStructure->getYDimSize() ) /
337  static_cast< proshade_double > ( staticStructure->getYDim() ) ) );
338  proshade_single zCor = static_cast< proshade_single > ( static_cast< proshade_double > ( staticStructure->zFrom - this->zFrom ) *
339  ( static_cast< proshade_double > ( staticStructure->getZDimSize() ) /
340  static_cast< proshade_double > ( staticStructure->getZDim() ) ) );
341  proshade_single xMov = static_cast< proshade_single > ( staticStructure->mapCOMProcessChangeX - static_cast< proshade_double > ( xCor ) -
342  ( trsX * static_cast<proshade_double> ( staticStructure->getXDimSize() ) /
343  static_cast<proshade_double> ( staticStructure->getXDim() ) ) );
344  proshade_single yMov = static_cast< proshade_single > ( staticStructure->mapCOMProcessChangeY - static_cast< proshade_double > ( yCor ) -
345  ( trsY * static_cast<proshade_double> ( staticStructure->getYDimSize() ) /
346  static_cast<proshade_double> ( staticStructure->getYDim() ) ) );
347  proshade_single zMov = static_cast< proshade_single > ( staticStructure->mapCOMProcessChangeZ - static_cast< proshade_double > ( zCor ) -
348  ( trsZ * static_cast<proshade_double> ( staticStructure->getZDimSize() ) /
349  static_cast<proshade_double> ( staticStructure->getZDim() ) ) );
350  proshade_single modXMov = xMov;
351  proshade_single modYMov = yMov;
352  proshade_single modZMov = zMov;
353 
354  //================================================ Save results as vector
355  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast<proshade_double> ( -xMov ) );
356  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast<proshade_double> ( -yMov ) );
357  ProSHADE_internal_misc::addToDoubleVector ( &ret, static_cast<proshade_double> ( -zMov ) );
358 
359  //================================================ Save original from variables for PDB output
360  this->mapMovFromsChangeX = static_cast<proshade_double> ( this->xFrom );
361  this->mapMovFromsChangeY = static_cast<proshade_double> ( this->yFrom );
362  this->mapMovFromsChangeZ = static_cast<proshade_double> ( this->zFrom );
363 
364  //================================================ Move the map
365  ProSHADE_internal_mapManip::moveMapByIndices ( &modXMov, &modYMov, &modZMov, this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
366  this->getXFromPtr(), this->getXToPtr(),
367  this->getYFromPtr(), this->getYToPtr(),
368  this->getZFromPtr(), this->getZToPtr(),
369  this->getXAxisOrigin(), this->getYAxisOrigin(), this->getZAxisOrigin() );
370 
371  ProSHADE_internal_mapManip::moveMapByFourier ( this->getInternalMap(), modXMov, modYMov, modZMov,
372  this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
373  static_cast< proshade_signed > ( this->getXDim() ), static_cast< proshade_signed > ( this->getYDim() ), static_cast< proshade_signed > ( this->getZDim() ) );
374 
375  //================================================ Keep only the change in from and to variables
376  this->mapMovFromsChangeX = static_cast<proshade_double> ( this->xFrom ) - this->mapMovFromsChangeX;
377  this->mapMovFromsChangeY = static_cast<proshade_double> ( this->yFrom ) - this->mapMovFromsChangeY;
378  this->mapMovFromsChangeZ = static_cast<proshade_double> ( this->zFrom ) - this->mapMovFromsChangeZ;
379 
380  //================================================ Compute the optimal rotation centre for co-ordinates
381  this->computePdbRotationCentre ( );
382  this->computeOptimalTranslation ( eulA, eulB, eulG, -xMov, -yMov, -zMov );
383 
384  //================================================ Done
385  return ( ret );
386 
387 }

◆ 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 3879 of file ProSHADE_data.cpp.

3880 {
3881  //================================================ Done
3882  return ( this->maxCompBand );
3883 
3884 }

◆ getCyclicSymmetriesList()

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

This function obtains a list of all C symmetries from already computed self-rotation map.

This function starts by finding all peaks in the self-rotation map, which are outliers in terms of height. It then proceeds to group these by the height, searching for C symmetries in each peak height group (thus making sure symmetries with higher peak heights are found first). The symmetry detection proceeds by detecting possible C symmetry folds and searching whether the all peaks are present to support the prospective C symmetry. If only few are missing, it will even search for the missing peaks. Finally, the function returns all detected symmetries in the order of decreasing average peak height.

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

Definition at line 198 of file ProSHADE_symmetry.cpp.

199 {
200  //================================================ Initialise variables
201  std::vector< proshade_double* > ret;
202 
203  //================================================ Report progress
204  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting C symmetry detection." );
205 
206  //================================================ Get list of peaks in the self-rotation map
207  std::vector< proshade_double* > allPeaks = ProSHADE_internal_peakSearch::getAllPeaksNaive ( this->getInvSO3Coeffs (), this->getMaxBand() * 2,
208  static_cast< proshade_signed > ( settings->peakNeighbours ),
209  settings->noIQRsFromMedianNaivePeak );
210 
211  //================================================ Convert peaks to angle-axis
212  std::vector< proshade_double* > peaksAA = ProSHADE_internal_symmetry::getPeaksAngleAxisPositions ( allPeaks, settings->verbose );
213 
214  //================================================ Sort peaks by height groups
215  std::vector< proshade_double > peakGroupsBoundaries = ProSHADE_internal_symmetry::findPeaksByHeightBoundaries ( peaksAA, settings->smoothingFactor );
216 
217  //================================================ Get symmetry per group
218  std::vector< std::vector< proshade_unsign > > detectedCSymmetries;
219  for ( proshade_signed iter = static_cast< proshade_signed > ( peakGroupsBoundaries.size() - 1 ); iter >= 0; iter-- )
220  {
221  //============================================ Get peaks group peaks only
222  std::vector< proshade_double* > symPeaks;
223  for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( peaksAA.size() ); it++ )
224  {
225  if ( peaksAA.at(it)[4] > peakGroupsBoundaries.at( static_cast< size_t > ( iter ) ) ) { ProSHADE_internal_misc::addToDblPtrVector ( &symPeaks, peaksAA.at(it) ); }
226  }
227 
228  //============================================ Search for symmetry in these peaks
229  detectedCSymmetries = ProSHADE_internal_symmetry::findPeaksCSymmetry ( &symPeaks, settings->verbose,
230  this->getMaxBand(),
231  settings->symMissPeakThres,
232  settings->axisErrTolerance,
233  settings->axisErrToleranceDefault,
234  this );
235 
236  //============================================ Print detected symmetries
237  for ( proshade_unsign detIt = 0; detIt < static_cast<proshade_unsign> ( detectedCSymmetries.size() ); detIt++ ) { ProSHADE_internal_symmetry::printSymmetryGroup ( detectedCSymmetries.at(detIt), symPeaks, settings->verbose ); }
238 
239  //============================================ Save detected
240  ProSHADE_internal_symmetry::saveAllCSymmetries ( detectedCSymmetries, symPeaks, &ret, settings->axisErrTolerance );
241  }
242 
243  //================================================ Release memory
244  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( peaksAA.size() ); iter++ ) { delete[] allPeaks.at(iter); delete[] peaksAA.at(iter); }
245 
246  //================================================ Report completion
247  ProSHADE_internal_symmetry::printSymmetryCompletion ( static_cast<proshade_unsign>( ret.size() ), settings->verbose );
248 
249  //================================================ Done
250  return ( ret );
251 
252 }

◆ 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 3756 of file ProSHADE_symmetry.cpp.

3757 {
3758  //================================================ Initialise variables
3759  std::vector< proshade_unsign > primes = ProSHADE_internal_maths::findAllPrimes ( settings->maxSymmetryFold );
3760  std::vector< proshade_double* > ret, tmpHolder;
3761  std::vector< proshade_unsign > testedFolds;
3762  proshade_double symThres;
3763  proshade_unsign foldToTest;
3764  bool foldDone, anyNewSyms = true;
3765 
3766  //================================================ For each found prime number in the limit
3767  for ( proshade_unsign prIt = 0; prIt < static_cast< proshade_unsign > ( primes.size() ); prIt++ )
3768  {
3769  //============================================ Report progress
3770  std::stringstream hlpSS;
3771  hlpSS << "Searching for prime fold symmetry C" << primes.at(prIt) << ".";
3772  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str() );
3773 
3774  //============================================ Get all symmetries for this prime fold
3775  std::vector< proshade_double* > prSyms = this->findRequestedCSymmetryFromAngleAxis ( settings, primes.at(prIt), &symThres );
3776 
3777  //============================================ Save the detected C symmetries
3778  for ( size_t axIt = 0; axIt < prSyms.size(); axIt++ )
3779  {
3780  //======================================== Is this symmetry passing the threshold?
3781  if ( prSyms.at(axIt)[5] >= symThres )
3782  {
3783  //==================================== Add this symmetry to final list
3784  if ( ProSHADE_internal_maths::isAxisUnique ( &ret, prSyms.at(axIt), settings->axisErrTolerance, true ) )
3785  {
3786  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &ret, prSyms.at(axIt) );
3787  }
3788  }
3789 
3790  //======================================== Release memory
3791  delete[] prSyms.at(axIt);
3792  }
3793  }
3794 
3795  //================================================ Was anything found?
3796  if ( ret.size() < 1 ) { return ( ret ); }
3797 
3798  //================================================ Check for prime symmetry fold multiples
3799  while ( anyNewSyms )
3800  {
3801  //============================================ Initialise new iteration
3802  anyNewSyms = false;
3803 
3804  //============================================ For each passing symmetry, look if there are any combinations of symmetries that would contain it
3805  for ( proshade_unsign axIt1 = 0; axIt1 < static_cast< proshade_unsign > ( ret.size() ); axIt1++ )
3806  {
3807  for ( proshade_unsign axIt2 = 0; axIt2 < static_cast< proshade_unsign > ( ret.size() ); axIt2++ )
3808  {
3809  //==================================== Initialise iteration
3810  foldToTest = static_cast< proshade_unsign > ( ret.at(axIt1)[0] * ret.at(axIt2)[0] );
3811  if ( foldToTest > settings->maxSymmetryFold ) { continue; }
3812 
3813  //==================================== Was this fold tested already?
3814  foldDone = false;
3815  for ( proshade_unsign fIt = 0; fIt < static_cast< proshade_unsign > ( testedFolds.size() ); fIt++ ) { if ( testedFolds.at(fIt) == foldToTest ) { foldDone = true; break; } }
3816  if ( foldDone ) { continue; }
3817  else { ProSHADE_internal_misc::addToUnsignVector ( &testedFolds, foldToTest ); }
3818 
3819  //==================================== Report progress
3820  std::stringstream hlpSS2;
3821  hlpSS2 << "Searching for fold combination of detected folds " << ret.at(axIt1)[0] << " and " << ret.at(axIt2)[0] << ", i.e. C" << foldToTest << ".";
3822  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS2.str() );
3823 
3824  //==================================== Get all symmetries for this fold
3825  std::vector< proshade_double* > prSyms = this->findRequestedCSymmetryFromAngleAxis ( settings, foldToTest, &symThres );
3826 
3827  //==================================== For each detected group with the required fold
3828  for ( size_t newAxIt = 0; newAxIt < prSyms.size(); newAxIt++ )
3829  {
3830  if ( prSyms.at(newAxIt)[5] >= symThres )
3831  {
3832  //================================ Add to detected axes
3833  if ( ProSHADE_internal_maths::isAxisUnique ( &ret, prSyms.at(newAxIt), settings->axisErrTolerance, true ) )
3834  {
3835  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &tmpHolder, prSyms.at(newAxIt) );
3836  }
3837  }
3838 
3839  //==================================== Release memory
3840  delete[] prSyms.at(newAxIt);
3841  }
3842  }
3843  }
3844 
3845  //============================================ Add newly found groups and repeat if need be
3846  if ( tmpHolder.size() > 0 )
3847  {
3848  for ( proshade_unsign tmpIt = 0; tmpIt < static_cast< proshade_unsign > ( tmpHolder.size() ); tmpIt++ )
3849  {
3850  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( &ret, tmpHolder.at(tmpIt) );
3851  delete[] tmpHolder.at(tmpIt);
3852  }
3853 
3854  anyNewSyms = true;
3855  tmpHolder.clear ( );
3856  }
3857  }
3858 
3859  //================================================ Sort the vector
3860  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymHlpInv );
3861 
3862  //================================================ Done
3863  return ( ret );
3864 }

◆ 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 1299 of file ProSHADE_symmetry.cpp.

1300 {
1301  //================================================ Initialise variables
1302  std::vector< proshade_double* > ret;
1303  proshade_double dotProduct;
1304 
1305  //================================================ Report progress
1306  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting D symmetry detection." );
1307 
1308  //================================================If not enough axes, just end here
1309  if ( CSymList->size() < 2 ) { return ( ret ); }
1310 
1311  //================================================ For each unique pair of axes
1312  for ( proshade_unsign ax1 = 0; ax1 < static_cast<proshade_unsign> ( CSymList->size() ); ax1++ )
1313  {
1314  //============================================ Ignore small axes
1315  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(ax1)[5] ), rhs1 ( -999.9 );
1316  if ( ( CSymList->at(ax1)[5] < settings->minSymPeak ) && !( lhs1.AlmostEquals ( rhs1 ) ) ) { continue; }
1317 
1318  for ( proshade_unsign ax2 = 1; ax2 < static_cast<proshade_unsign> ( CSymList->size() ); ax2++ )
1319  {
1320  //======================================= Use unique pairs only
1321  if ( ax1 >= ax2 ) { continue; }
1322 
1323  //======================================== Ignore small axes
1324  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(ax2)[5] ), rhs2 ( -999.9 );
1325  if ( ( CSymList->at(ax2)[5] < settings->minSymPeak ) && !( lhs2.AlmostEquals ( rhs2 ) ) ) { continue; }
1326 
1327  //======================================= Compute the dot product
1328  dotProduct = ProSHADE_internal_maths::computeDotProduct ( &CSymList->at(ax1)[1], &CSymList->at(ax1)[2],
1329  &CSymList->at(ax1)[3], &CSymList->at(ax2)[1],
1330  &CSymList->at(ax2)[2], &CSymList->at(ax2)[3] );
1331 
1332  //======================================== If close to zero, these two axes are perpendicular
1333  if ( std::abs( dotProduct ) < settings->axisErrTolerance )
1334  {
1335  //==================================== Save
1336  if ( CSymList->at(ax1)[0] >= CSymList->at(ax2)[0] )
1337  {
1338  ProSHADE_internal_symmetry::saveDSymmetry ( &ret, CSymList, ax1, ax2 );
1339 
1340  std::vector< proshade_unsign > DSymInd;
1344 
1345  }
1346  else
1347  {
1348  ProSHADE_internal_symmetry::saveDSymmetry ( &ret, CSymList, ax2, ax1 );
1349 
1350  std::vector< proshade_unsign > DSymInd;
1354  }
1355  }
1356  }
1357  }
1358 
1359  //================================================ Report progress
1360  std::stringstream hlpSS;
1361  hlpSS << "Detected " << ret.size() << " D symmetries.";
1362  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, hlpSS.str() );
1363 
1364  //================================================ Done
1365  return ( ret );
1366 
1367 }

◆ 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 3827 of file ProSHADE_data.cpp.

3828 {
3829  //================================================ Done
3830  return ( this->eMatrices[band] );
3831 
3832 }

◆ 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 3842 of file ProSHADE_data.cpp.

3843 {
3844  //================================================ Set pointer
3845  *valueReal = this->eMatrices[band][order1][order2][0];
3846  *valueImag = this->eMatrices[band][order1][order2][1];
3847 
3848  //================================================ Done
3849  return ;
3850 
3851 }

◆ 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 2799 of file ProSHADE_symmetry.cpp.

2800 {
2801  //================================================ Initialise variables
2802  std::vector< proshade_double* > ret;
2803 
2804  //================================================ Report progress
2805  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting I symmetry detection." );
2806 
2807  //================================================ Are the basic requirements for icosahedral symmetry met?
2809  {
2810  //============================================ Search for all the symmetry axes
2811  ProSHADE_internal_symmetry::findIcos6C5s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
2812  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 ); }
2813 
2814  ProSHADE_internal_symmetry::findIcos10C3s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
2815  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 ); }
2816 
2817  ProSHADE_internal_symmetry::findIcos15C2s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
2818  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 ); }
2819  else
2820  {
2821  //======================================== Sort ret by fold
2822  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymInvFoldHlp );
2823 
2824  //======================================== Save indices
2825  for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
2826  {
2827  for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
2828  {
2829  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(csIt)[0] ), rhs1 ( ret.at(retIt)[0] );
2830  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(csIt)[1] ), rhs2 ( ret.at(retIt)[1] );
2831  const FloatingPoint< proshade_double > lhs3 ( CSymList->at(csIt)[2] ), rhs3 ( ret.at(retIt)[2] );
2832  const FloatingPoint< proshade_double > lhs4 ( CSymList->at(csIt)[3] ), rhs4 ( ret.at(retIt)[3] );
2833  const FloatingPoint< proshade_double > lhs5 ( CSymList->at(csIt)[4] ), rhs5 ( ret.at(retIt)[4] );
2834  const FloatingPoint< proshade_double > lhs6 ( CSymList->at(csIt)[5] ), rhs6 ( ret.at(retIt)[5] );
2835  if ( lhs1.AlmostEquals ( rhs1 ) &&
2836  lhs2.AlmostEquals ( rhs2 ) &&
2837  lhs3.AlmostEquals ( rhs3 ) &&
2838  lhs4.AlmostEquals ( rhs4 ) &&
2839  lhs5.AlmostEquals ( rhs5 ) &&
2840  lhs6.AlmostEquals ( rhs6 ) )
2841  {
2843  }
2844  }
2845  }
2846  }
2847  }
2848 
2849  //================================================ Report progress
2850  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "I symmetry detection complete." );
2851 
2852  //================================================ Done
2853  return ( ret );
2854 
2855 }

◆ 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 4218 of file ProSHADE_data.cpp.

4219 {
4220  //================================================ Save the data into the output array
4221  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4222  {
4223  eMatsLMImag[iter] = static_cast<double> ( this->eMatrices[band][order1][iter][1] );
4224  }
4225 
4226  //================================================ Done
4227  return ;
4228 
4229 }

◆ 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 4305 of file ProSHADE_data.cpp.

4306 {
4307  //================================================ Save the data into the output array
4308  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4309  {
4310  rotFunImag[iter] = static_cast<double> ( this->so3CoeffsInverse[iter][1] );
4311  }
4312 
4313  //================================================ Done
4314  return ;
4315 
4316 }

◆ 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 4254 of file ProSHADE_data.cpp.

4255 {
4256  //================================================ Save the data into the output array
4257  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4258  {
4259  so3CoefsImag[iter] = static_cast<double> ( this->so3Coeffs[iter][1] );
4260  }
4261 
4262  //================================================ Done
4263  return ;
4264 
4265 }

◆ 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 3767 of file ProSHADE_data.cpp.

3768 {
3769  //================================================ Done
3770  return ( &this->sphericalHarmonics[shell][seanindex ( static_cast< int > ( order ) - static_cast< int > ( band ),
3771  static_cast< int > ( band ),
3772  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ) )][1] );
3773 
3774 }

◆ 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 4341 of file ProSHADE_data.cpp.

4342 {
4343  //================================================ Save the data into the output array
4344  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4345  {
4346  trsFunImag[iter] = static_cast<double> ( this->translationMap[iter][1] );
4347  }
4348 
4349  //================================================ Done
4350  return ;
4351 
4352 }

◆ 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 3791 of file ProSHADE_data.cpp.

3792 {
3793  //================================================ Done
3794  return ( this->integrationWeight );
3795 
3796 }

◆ 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 4059 of file ProSHADE_data.cpp.

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

◆ 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 3857 of file ProSHADE_data.cpp.

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

◆ 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 4079 of file ProSHADE_data.cpp.

4080 {
4081  //================================================ Initialise local variables
4082  std::vector< proshade_double > ret;
4083 
4084  //================================================ Save the values
4088 
4089  //================================================ Return the requested value
4090  return ( ret );
4091 }

◆ 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 3620 of file ProSHADE_data.cpp.

3621 {
3622  //================================================ Return the value
3623  return ( this->internalMap[pos] );
3624 }

◆ 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 3630 of file ProSHADE_data.cpp.

3631 {
3632  //================================================ Return the value
3633  return ( this->maxShellBand );
3634 }

◆ 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 3609 of file ProSHADE_data.cpp.

3610 {
3611  //================================================ Return the value
3612  return ( this->noSpheres );
3613 }

◆ 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 4417 of file ProSHADE_data.cpp.

4418 {
4419  //================================================ Return the value
4420  return ( static_cast<proshade_unsign> ( settings->detectedSymmetry.size() ) );
4421 }

◆ 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 2199 of file ProSHADE_symmetry.cpp.

2200 {
2201  //================================================ Initialise variables
2202  std::vector< proshade_double* > ret;
2203 
2204  //================================================ Report progress
2205  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting O symmetry detection." );
2206 
2207  //================================================ Are the basic requirements for tetrahedral symmetry met?
2208  if ( ProSHADE_internal_symmetry::detectOctahedralSymmetry ( CSymList, settings->axisErrTolerance, settings->minSymPeak ) )
2209  {
2210  //============================================ Search for all the symmetry axes
2211  ProSHADE_internal_symmetry::findOcta3C4s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
2212  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 ); }
2213 
2214  ProSHADE_internal_symmetry::findOcta4C3s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
2215  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 ); }
2216 
2217  ProSHADE_internal_symmetry::findOcta6C2s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
2218  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 ); }
2219  else
2220  {
2221  for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
2222  {
2223  for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
2224  {
2225  //======================================== Sort ret by fold
2226  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymInvFoldHlp );
2227 
2228  //======================================== Save indices
2229  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(csIt)[0] ), rhs1 ( ret.at(retIt)[0] );
2230  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(csIt)[1] ), rhs2 ( ret.at(retIt)[1] );
2231  const FloatingPoint< proshade_double > lhs3 ( CSymList->at(csIt)[2] ), rhs3 ( ret.at(retIt)[2] );
2232  const FloatingPoint< proshade_double > lhs4 ( CSymList->at(csIt)[3] ), rhs4 ( ret.at(retIt)[3] );
2233  const FloatingPoint< proshade_double > lhs5 ( CSymList->at(csIt)[4] ), rhs5 ( ret.at(retIt)[4] );
2234  const FloatingPoint< proshade_double > lhs6 ( CSymList->at(csIt)[5] ), rhs6 ( ret.at(retIt)[5] );
2235  if ( lhs1.AlmostEquals ( rhs1 ) &&
2236  lhs2.AlmostEquals ( rhs2 ) &&
2237  lhs3.AlmostEquals ( rhs3 ) &&
2238  lhs4.AlmostEquals ( rhs4 ) &&
2239  lhs5.AlmostEquals ( rhs5 ) &&
2240  lhs6.AlmostEquals ( rhs6 ) )
2241  {
2243  }
2244  }
2245  }
2246  }
2247  }
2248 
2249  //================================================ Report progress
2250  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "O symmetry detection complete." );
2251 
2252  //================================================ Done
2253  return ( ret );
2254 
2255 }

◆ 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." );
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." );
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 2871 of file ProSHADE_symmetry.cpp.

2872 {
2873  //================================================ Initialise variables
2874  std::vector< std::vector< proshade_double* > > ret;
2875 
2876  //================================================ Report progress
2877  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting I symmetry prediction." );
2878 
2879  //================================================ Are the basic requirements for icosahedral symmetry met?
2881  {
2882  //============================================ Generate the rest of the axes
2883  ProSHADE_internal_symmetry::predictIcosAxes ( CSymList, &ret, settings->axisErrTolerance, settings->minSymPeak );
2884 
2885  //============================================ For each possible axes pair
2886  for ( size_t pIt = 0; pIt < ret.size(); pIt++ )
2887  {
2888  //======================================== Get heights for the predicted axes
2889  ProSHADE_internal_symmetry::findPredictedAxesHeights ( &(ret.at(pIt)), this, settings );
2890  }
2891  }
2892 
2893 
2894  //================================================ Report progress
2895  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "I symmetry prediction complete." );
2896 
2897  //================================================ Done
2898  return ( ret );
2899 
2900 }

◆ 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 2916 of file ProSHADE_symmetry.cpp.

2917 {
2918  //================================================ Initialise variables
2919  std::vector< proshade_double* > ret;
2920 
2921  //================================================ Report progress
2922  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting O symmetry prediction." );
2923 
2924  //================================================ Are the basic requirements for icosahedral symmetry met?
2925  if ( ProSHADE_internal_symmetry::detectOctahedralSymmetry ( CSymList, settings->axisErrTolerance, settings->minSymPeak ) )
2926  {
2927  //============================================ Generate the rest of the axes
2928  ProSHADE_internal_symmetry::predictOctaAxes ( CSymList, &ret, settings->axisErrTolerance, settings->minSymPeak );
2929 
2930  //============================================ Get heights for the predicted axes
2932 
2933  //============================================ Add predicted axes to detected C axes list and also to the settings Icosahedral symmetry list
2934  for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ret.size() ); retIt++ )
2935  {
2936  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 );
2937  ProSHADE_internal_misc::addToUnsignVector ( &settings->allDetectedOAxes, static_cast < proshade_unsign > ( matchedPos ) );
2938  }
2939  }
2940 
2941  //================================================ Report progress
2942  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "O symmetry prediction complete." );
2943 
2944  //================================================ Done
2945  return ( ret );
2946 
2947 }

◆ 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 4253 of file ProSHADE_symmetry.cpp.

4254 {
4255  //================================================ Initialise variables
4256  std::vector< proshade_double* > ret;
4257 
4258  //================================================ Report progress
4259  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting T symmetry prediction." );
4260 
4261  //================================================ Are the basic requirements for icosahedral symmetry met?
4263  {
4264  //============================================ Generate the rest of the axes
4265  ProSHADE_internal_symmetry::predictTetraAxes ( CSymList, &ret, settings->axisErrTolerance, settings->minSymPeak );
4266 
4267  //============================================ Get heights for the predicted axes
4269 
4270  //============================================ Add predicted axes to detected C axes list and also to the settings Icosahedral symmetry list
4271  for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ret.size() ); retIt++ )
4272  {
4273  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 );
4274  ProSHADE_internal_misc::addToUnsignVector ( &settings->allDetectedTAxes, static_cast < proshade_unsign > ( matchedPos ) );
4275  }
4276  }
4277 
4278  //================================================ Report progress
4279  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "T symmetry prediction complete." );
4280 
4281  //================================================ Done
4282  return ( ret );
4283 
4284 }

◆ 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 4198 of file ProSHADE_data.cpp.

4199 {
4200  //================================================ Save the data into the output array
4201  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4202  {
4203  eMatsLMReal[iter] = static_cast<double> ( this->eMatrices[band][order1][iter][0] );
4204  }
4205 
4206  //================================================ Done
4207  return ;
4208 
4209 }

◆ 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 4287 of file ProSHADE_data.cpp.

4288 {
4289  //================================================ Save the data into the output array
4290  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4291  {
4292  rotFunReal[iter] = static_cast<double> ( this->so3CoeffsInverse[iter][0] );
4293  }
4294 
4295  //================================================ Done
4296  return ;
4297 
4298 }

◆ 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 4236 of file ProSHADE_data.cpp.

4237 {
4238  //================================================ Save the data into the output array
4239  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4240  {
4241  so3CoefsReal[iter] = static_cast<double> ( this->so3Coeffs[iter][0] );
4242  }
4243 
4244  //================================================ Done
4245  return ;
4246 
4247 }

◆ 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 3754 of file ProSHADE_data.cpp.

3755 {
3756  //================================================ Done
3757  return ( &this->sphericalHarmonics[shell][seanindex ( static_cast< int > ( order ) - static_cast< int > ( band ),
3758  static_cast< int > ( band ),
3759  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ) )][0] );
3760 
3761 }

◆ 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 4323 of file ProSHADE_data.cpp.

4324 {
4325  //================================================ Save the data into the output array
4326  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4327  {
4328  trsFunReal[iter] = static_cast<double> ( this->translationMap[iter][0] );
4329  }
4330 
4331  //================================================ Done
4332  return ;
4333 
4334 }

◆ 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 1242 of file ProSHADE_data.cpp.

1243 {
1244  //================================================ Report function start
1245  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Finding new boundaries." );
1246 
1247  //================================================ If same bounds as first one are required, test if possible and return these instead
1248  if ( settings->useSameBounds && ( this->inputOrder != 0 ) )
1249  {
1250  for ( proshade_unsign iter = 0; iter < 6; iter++ ) { ret[iter] = settings->forceBounds[iter]; }
1251  }
1252  //================================================ In this case, bounds need to be found de novo
1253  else
1254  {
1255  //============================================ Find the non-zero bounds
1257  static_cast< proshade_signed > ( this->xDimIndices ),
1258  static_cast< proshade_signed > ( this->yDimIndices ),
1259  static_cast< proshade_signed > ( this->zDimIndices ),
1260  ret );
1261 
1262  //============================================ Add the extra space
1264  this->xDimSize, this->yDimSize, this->zDimSize, ret, settings->boundsExtraSpace );
1265 
1266  //============================================ Beautify boundaries
1268 
1269  //============================================ Report function results
1270  std::stringstream ssHlp;
1271  ssHlp << "New boundaries are: " << ret[1] - ret[0] + 1 << " x " << ret[3] - ret[2] + 1 << " x " << ret[5] - ret[4] + 1;
1272  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, ssHlp.str() );
1273 
1274  //============================================ If need be, save boundaries to be used for all other structure
1275  if ( settings->useSameBounds && ( this->inputOrder == 0 ) )
1276  {
1277  for ( proshade_unsign iter = 0; iter < 6; iter++ ) { settings->forceBounds[iter] = ret[iter]; }
1278  }
1279  }
1280 
1281  //================================================ Report function completion
1282  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "New boundaries determined." );
1283 
1284  //================================================ Done
1285  return ;
1286 
1287 }

◆ 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 4405 of file ProSHADE_data.cpp.

4406 {
4407  //================================================ Return the value
4408  return ( settings->recommendedSymmetryFold );
4409 
4410 }

◆ 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 4394 of file ProSHADE_data.cpp.

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

◆ 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 4362 of file ProSHADE_data.cpp.

4363 {
4364  //================================================ Get Euler angles
4365  proshade_double eA, eB, eG;
4366  ProSHADE_internal_maths::getEulerZXZFromSOFTPosition ( static_cast< int > ( this->getMaxBand() ), aI, bI, gI, &eA, &eB, &eG );
4367 
4368  //================================================ Prepare internal rotation matrix memory
4369  proshade_double* rMat = nullptr;
4370  rMat = new proshade_double[9];
4371  ProSHADE_internal_misc::checkMemoryAllocation ( rMat, __FILE__, __LINE__, __func__ );
4372 
4373  //================================================ Convert to rotation matrix
4375 
4376  //================================================ Copy to output
4377  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4378  {
4379  rotMat[iter] = static_cast<double> ( rMat[iter] );
4380  }
4381 
4382  //================================================ Release internal memory
4383  delete[] rMat;
4384 
4385  //================================================ Done
4386  return ;
4387 
4388 }

◆ 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 3640 of file ProSHADE_data.cpp.

3641 {
3642  //================================================ Return the value
3643  return ( this->rrpMatrices[band][sh1][sh2] );
3644 }

◆ 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 3803 of file ProSHADE_data.cpp.

3804 {
3805  //================================================ Done
3806  return ( this->spheres[shell]->getLocalBandwidth ( ) );
3807 
3808 }

◆ 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 3868 of file ProSHADE_data.cpp.

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

◆ 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 1655 of file ProSHADE_data.cpp.

1656 {
1657  //================================================ Check the current settings value is set to auto
1658  if ( this->spherePos.size() != 0 )
1659  {
1660  std::stringstream hlpSS;
1661  hlpSS << "The sphere distances were determined as " << this->spherePos.at(0);
1662  for ( proshade_unsign iter = 1; iter < static_cast<proshade_unsign> ( this->spherePos.size() ); iter++ ) { hlpSS << "; " << this->spherePos.at(iter); }
1663  hlpSS << " Angstroms.";
1664  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str() );
1665  return ;
1666  }
1667 
1668  //================================================ Find maximum diagonal
1669  proshade_unsign maxDim = static_cast< proshade_unsign > ( std::max ( this->xDimSize, std::max ( this->yDimSize, this->zDimSize ) ) );
1670  proshade_unsign minDim = static_cast< proshade_unsign > ( std::min ( this->xDimSize, std::min ( this->yDimSize, this->zDimSize ) ) );
1671  proshade_unsign midDim = static_cast< proshade_unsign > ( 0 );
1672  if ( ( this->xDimSize < static_cast< proshade_single > ( maxDim ) ) && ( this->xDimSize > static_cast< proshade_single > ( minDim ) ) ) { midDim = static_cast< proshade_unsign > ( this->xDimSize ); }
1673  else if ( ( this->yDimSize < static_cast< proshade_single > ( maxDim ) ) && ( this->yDimSize > static_cast< proshade_single > ( minDim ) ) ) { midDim = static_cast< proshade_unsign > ( this->yDimSize ); }
1674  else { midDim = static_cast< proshade_unsign > ( this->zDimSize ); }
1675 
1676  proshade_single maxDiag = static_cast< proshade_single > ( std::sqrt ( std::pow ( static_cast<proshade_single> ( maxDim ), 2.0 ) +
1677  std::pow ( static_cast<proshade_single> ( midDim ), 2.0 ) ) );
1678 
1679  //================================================ Set between the points
1680  for ( proshade_single iter = 0.5f; ( iter * settings->maxSphereDists ) < ( maxDiag / 2.0f ); iter += 1.0f )
1681  {
1682  ProSHADE_internal_misc::addToSingleVector ( &this->spherePos, ( iter * settings->maxSphereDists ) );
1683  }
1684 
1685  //================================================ Save the number of spheres
1686  this->noSpheres = static_cast<proshade_unsign> ( this->spherePos.size() );
1687 
1688  //================================================ Report progress
1689  std::stringstream hlpSS;
1690  hlpSS << "The sphere distances were determined as " << this->spherePos.at(0);
1691  for ( proshade_unsign iter = 1; iter < static_cast<proshade_unsign> ( this->spherePos.size() ); iter++ ) { hlpSS << "; " << this->spherePos.at(iter); }
1692  hlpSS << " Angstroms.";
1693  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, hlpSS.str() );
1694 
1695  //================================================ Done
1696  return ;
1697 
1698 }

◆ 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 3815 of file ProSHADE_data.cpp.

3816 {
3817  //================================================ Done
3818  return ( this->spherePos.at(shell) );
3819 
3820 }

◆ 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 4429 of file ProSHADE_data.cpp.

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

◆ 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 1419 of file ProSHADE_symmetry.cpp.

1420 {
1421  //================================================ Initialise variables
1422  std::vector< proshade_double* > ret;
1423 
1424  //================================================ Report progress
1425  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting T symmetry detection." );
1426 
1427  //================================================ Are the basic requirements for tetrahedral symmetry met?
1429  {
1430  //============================================ Search for all the symmetry axes
1431  ProSHADE_internal_symmetry::findTetra4C3s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
1432  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 ); }
1433 
1434  ProSHADE_internal_symmetry::findTetra3C2s ( CSymList, &ret, settings->axisErrTolerance, this, settings->verbose, settings->minSymPeak );
1435  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 ); }
1436  else
1437  {
1438  for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
1439  {
1440  for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
1441  {
1442  //======================================== Sort ret by fold
1443  std::sort ( ret.begin(), ret.end(), ProSHADE_internal_misc::sortSymInvFoldHlp );
1444 
1445  //======================================== Save indices
1446  const FloatingPoint< proshade_double > lhs1 ( CSymList->at(csIt)[0] ), rhs1 ( ret.at(retIt)[0] );
1447  const FloatingPoint< proshade_double > lhs2 ( CSymList->at(csIt)[1] ), rhs2 ( ret.at(retIt)[1] );
1448  const FloatingPoint< proshade_double > lhs3 ( CSymList->at(csIt)[2] ), rhs3 ( ret.at(retIt)[2] );
1449  const FloatingPoint< proshade_double > lhs4 ( CSymList->at(csIt)[3] ), rhs4 ( ret.at(retIt)[3] );
1450  const FloatingPoint< proshade_double > lhs5 ( CSymList->at(csIt)[4] ), rhs5 ( ret.at(retIt)[4] );
1451  const FloatingPoint< proshade_double > lhs6 ( CSymList->at(csIt)[5] ), rhs6 ( ret.at(retIt)[5] );
1452  if ( ( lhs1.AlmostEquals ( rhs1 ) ) &&
1453  ( lhs2.AlmostEquals ( rhs2 ) ) &&
1454  ( lhs3.AlmostEquals ( rhs3 ) ) &&
1455  ( lhs4.AlmostEquals ( rhs4 ) ) &&
1456  ( lhs5.AlmostEquals ( rhs5 ) ) &&
1457  ( lhs6.AlmostEquals ( rhs6 ) ) )
1458  {
1460  }
1461  }
1462  }
1463  }
1464  }
1465 
1466  //================================================ Report progress
1467  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "T symmetry detection complete." );
1468 
1469  //================================================ Done
1470  return ( ret );
1471 
1472 }

◆ 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 4069 of file ProSHADE_data.cpp.

4070 {
4071  //================================================ Return the requested value
4072  return ( this->translationMap );
4073 }

◆ 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 3894 of file ProSHADE_data.cpp.

3895 {
3896  //================================================ Set pointer
3897  *valueReal = this->wignerMatrices[band][order1][order2][0];
3898  *valueImag = this->wignerMatrices[band][order1][order2][1];
3899 
3900  //================================================ Done
3901  return ;
3902 
3903 }

◆ 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 4029 of file ProSHADE_data.cpp.

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

◆ 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 3939 of file ProSHADE_data.cpp.

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

◆ 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 3909 of file ProSHADE_data.cpp.

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

◆ 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 3969 of file ProSHADE_data.cpp.

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

◆ 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 3999 of file ProSHADE_data.cpp.

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

◆ 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 4039 of file ProSHADE_data.cpp.

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

◆ 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 3949 of file ProSHADE_data.cpp.

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

◆ 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 3919 of file ProSHADE_data.cpp.

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

◆ 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 3979 of file ProSHADE_data.cpp.

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

◆ 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 4009 of file ProSHADE_data.cpp.

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

◆ 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 4049 of file ProSHADE_data.cpp.

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

◆ 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 3959 of file ProSHADE_data.cpp.

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

◆ 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 3929 of file ProSHADE_data.cpp.

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

◆ 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 3989 of file ProSHADE_data.cpp.

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

◆ 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 4019 of file ProSHADE_data.cpp.

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

◆ 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 1286 of file ProSHADE_overlay.cpp.

1287 {
1288  //================================================ Initialise variables
1289  proshade_double rad = 0.0, lon = 0.0, lat = 0.0, newU = 0.0, newV = 0.0, newW = 0.0;
1290  proshade_unsign lowerLonL = 0, upperLonL = 0, lowerLonU = 0, upperLonU = 0, lowerLatL = 0, upperLatL = 0, lowerLatU = 0, upperLatU = 0, lowerShell = 0, upperShell = 0;
1291  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;
1292  proshade_double lowerShellValue = 0.0, upperShellValue = 0.0;
1293  proshade_double xSamplingRate = static_cast<proshade_double> ( this->xDimSize ) / static_cast<proshade_double> ( this->xDimIndices );
1294  proshade_double ySamplingRate = static_cast<proshade_double> ( this->yDimSize ) / static_cast<proshade_double> ( this->yDimIndices );
1295  proshade_double zSamplingRate = static_cast<proshade_double> ( this->zDimSize ) / static_cast<proshade_double> ( this->zDimIndices );
1296  proshade_signed arrPos;
1297  std::vector<proshade_double> lonCOU, latCOU, lonCOL, latCOL;
1298 
1299  for ( proshade_signed uIt = 0; uIt < static_cast<proshade_signed> (this->xDimIndices); uIt++ )
1300  {
1301  for ( proshade_signed vIt = 0; vIt < static_cast<proshade_signed> (this->yDimIndices); vIt++ )
1302  {
1303  for ( proshade_signed wIt = 0; wIt < static_cast<proshade_signed> (this->zDimIndices); wIt++ )
1304  {
1305  //==================================== Convert to centered coords
1306  newU = static_cast<proshade_double> ( uIt - ( static_cast<proshade_signed> (this->xDimIndices) / 2 ) );
1307  newV = static_cast<proshade_double> ( vIt - ( static_cast<proshade_signed> (this->yDimIndices) / 2 ) );
1308  newW = static_cast<proshade_double> ( wIt - ( static_cast<proshade_signed> (this->zDimIndices) / 2 ) );
1309 
1310  //==================================== Deal with 0 ; 0 ; 0
1311  if ( ( newU == 0.0 ) && ( newV == 0.0 ) && ( newW == 0.0 ) )
1312  {
1313  arrPos = wIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( vIt + static_cast< proshade_signed > ( this->yDimIndices ) * uIt );
1314  densityMapRotated[arrPos] = this->internalMap[arrPos];
1315  continue;
1316  }
1317 
1318  //==================================== Convert to spherical coords
1319  rad = sqrt ( pow( ( newU * xSamplingRate ), 2.0 ) +
1320  pow( ( newV * ySamplingRate ), 2.0 ) +
1321  pow( ( newW * zSamplingRate ), 2.0 ) );
1322  lon = atan2 ( ( newV * ySamplingRate ), ( newU * xSamplingRate ) );
1323  lat = asin ( ( newW * zSamplingRate ) / rad );
1324 
1325  //==================================== Deal with nan's
1326  if ( rad != rad ) { rad = 0.0; }
1327  if ( lon != lon ) { lon = 0.0; }
1328  if ( lat != lat ) { lat = 0.0; }
1329 
1330  //==================================== Find shells above and below
1331  lowerShell = 0;
1332  upperShell = 0;
1333  for ( proshade_unsign iter = 0; iter < (this->noSpheres-1); iter++ )
1334  {
1335  if ( ( static_cast< proshade_double > ( this->spherePos.at(iter) ) <= rad ) && ( static_cast< proshade_double > ( this->spherePos.at(iter+1) ) > rad ) )
1336  {
1337  lowerShell = iter;
1338  upperShell = iter+1;
1339  break;
1340  }
1341  }
1342 
1343  if ( upperShell == 0 )
1344  {
1345  arrPos = wIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( vIt + static_cast< proshade_signed > ( this->yDimIndices ) * uIt );
1346  densityMapRotated[arrPos] = 0.0;
1347  continue;
1348  }
1349 
1350  //==================================== Get the longitude and lattitude cut-offs for this shell resolution
1351  lonCOL.clear(); latCOL.clear(); lonCOU.clear(); latCOU.clear();
1352  ProSHADE_internal_overlay::computeAngularThreshold ( &lonCOL, &latCOL, this->spheres[lowerShell]->getLocalAngRes() );
1353  ProSHADE_internal_overlay::computeAngularThreshold ( &lonCOU, &latCOU, this->spheres[upperShell]->getLocalAngRes() );
1354 
1355  //==================================== Find the angle cutoffs around the point
1356  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( lonCOL.size() ); iter++ )
1357  {
1358  if ( iter == ( static_cast<proshade_unsign> ( lonCOL.size() ) - 1 ) )
1359  {
1360  lowerLonL = 0;
1361  upperLonL = 1;
1362  break;
1363  }
1364  if ( ( std::floor(10000. * lonCOL.at(iter)) <= std::floor(10000. * lon) ) && ( std::floor(10000. * lonCOL.at(iter+1)) > std::floor(10000. * lon) ) )
1365  {
1366  lowerLonL = iter;
1367  upperLonL = iter+1;
1368  break;
1369  }
1370  }
1371  if ( upperLonL == this->spheres[lowerShell]->getLocalAngRes() ) { upperLonL = 0; }
1372 
1373  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( lonCOU.size() ); iter++ )
1374  {
1375  if ( iter == ( static_cast<proshade_unsign> ( lonCOU.size() ) - 1 ) )
1376  {
1377  lowerLonU = 0;
1378  upperLonU = 1;
1379  break;
1380  }
1381  if ( ( std::floor(10000. * lonCOU.at(iter)) <= std::floor(10000. * lon) ) && ( std::floor(10000. * lonCOU.at(iter+1)) > std::floor(10000. * lon) ) )
1382  {
1383  lowerLonU = iter;
1384  upperLonU = iter+1;
1385  break;
1386  }
1387  }
1388  if ( upperLonU == this->spheres[upperShell]->getLocalAngRes() ) { upperLonU = 0; }
1389 
1390  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( latCOL.size() ); iter++ )
1391  {
1392  if ( iter == ( static_cast<proshade_unsign> ( latCOL.size() ) - 1 ) )
1393  {
1394  lowerLatL = 0;
1395  upperLatL = 1;
1396  break;
1397  }
1398  if ( ( std::floor(10000. * latCOL.at(iter)) <= std::floor(10000. * lat) ) && ( std::floor(10000. * latCOL.at(iter+1)) > std::floor(10000. * lat) ) )
1399  {
1400  lowerLatL = iter;
1401  upperLatL = iter+1;
1402  break;
1403  }
1404  }
1405  if ( upperLatL == this->spheres[lowerShell]->getLocalAngRes() ) { upperLatL = 0; }
1406 
1407  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( latCOU.size() ); iter++ )
1408  {
1409  if ( iter == ( static_cast<proshade_unsign> ( latCOU.size() ) - 1 ) )
1410  {
1411  lowerLatU = 0;
1412  upperLatU = 1;
1413  break;
1414  }
1415  if ( ( std::floor(10000. * latCOU.at(iter)) <= std::floor(10000. * lat) ) && ( std::floor(10000. * latCOU.at(iter+1)) > std::floor(10000. * lat) ) )
1416  {
1417  lowerLatU = iter;
1418  upperLatU = iter+1;
1419  break;
1420  }
1421  }
1422  if ( upperLatU == this->spheres[upperShell]->getLocalAngRes() ) { upperLatU = 0; }
1423 
1424  //==================================== Interpolate lower shell
1425  x00 = this->spheres[lowerShell]->getRotatedMappedData ( lowerLatL * this->spheres[lowerShell]->getLocalAngRes() + lowerLonL );
1426  x01 = this->spheres[lowerShell]->getRotatedMappedData ( lowerLatL * this->spheres[lowerShell]->getLocalAngRes() + upperLonL );
1427  x10 = this->spheres[lowerShell]->getRotatedMappedData ( upperLatL * this->spheres[lowerShell]->getLocalAngRes() + lowerLonL );
1428  x11 = this->spheres[lowerShell]->getRotatedMappedData ( upperLatL * this->spheres[lowerShell]->getLocalAngRes() + upperLonL );
1429 
1430  distLLon = std::abs ( lon - lonCOL.at(lowerLonL) ) / ( std::abs( lon - lonCOL.at(lowerLonL) ) + std::abs( lon - lonCOL.at(upperLonL) ) );
1431  valLLon = ( ( 1.0 - distLLon ) * x00 ) + ( distLLon * x01 );
1432  valULon = ( ( 1.0 - distLLon ) * x10 ) + ( distLLon * x11 );
1433 
1434  distLLat = std::abs ( lat - latCOL.at(lowerLatL) ) / ( std::abs( lat - latCOL.at(lowerLatL) ) + std::abs( lat - latCOL.at(upperLatL) ) );
1435  lowerShellValue = ( ( 1.0 - distLLat ) * valLLon ) + ( distLLat * valULon );
1436 
1437  //==================================== Interpolate upper shell
1438  x00 = this->spheres[upperShell]->getRotatedMappedData ( lowerLatU * this->spheres[upperShell]->getLocalAngRes() + lowerLonU );
1439  x01 = this->spheres[upperShell]->getRotatedMappedData ( lowerLatU * this->spheres[upperShell]->getLocalAngRes() + upperLonU );
1440  x10 = this->spheres[upperShell]->getRotatedMappedData ( upperLatU * this->spheres[upperShell]->getLocalAngRes() + lowerLonU );
1441  x11 = this->spheres[upperShell]->getRotatedMappedData ( upperLatU * this->spheres[upperShell]->getLocalAngRes() + upperLonU );
1442 
1443  distLLon = std::abs ( lon - lonCOU.at(lowerLonU) ) / ( std::abs( lon - lonCOU.at(lowerLonU) ) + std::abs( lon - lonCOU.at(upperLonU) ) );
1444  valLLon = ( ( 1.0 - distLLon ) * x00 ) + ( distLLon * x01 );
1445  valULon = ( ( 1.0 - distLLon ) * x10 ) + ( distLLon * x11 );
1446 
1447  distLLat = std::abs ( lat - latCOU.at(lowerLatU) ) / ( std::abs( lat - latCOU.at(lowerLatU) ) + std::abs( lat - latCOU.at(upperLatU) ) );
1448  upperShellValue = ( ( 1.0 - distLLat ) * valLLon ) + ( distLLat * valULon );
1449 
1450  //==================================== Interpolate between shells
1451  distLRad = std::abs ( rad - static_cast< proshade_double > ( this->spherePos.at(lowerShell) ) ) / ( std::abs( rad - static_cast< proshade_double > ( this->spherePos.at(lowerShell) ) ) +
1452  std::abs( rad - static_cast< proshade_double > ( this->spherePos.at(upperShell) ) ) );
1453 
1454  arrPos = wIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( vIt + static_cast< proshade_signed > ( this->yDimIndices ) * uIt );
1455  densityMapRotated[arrPos] = ( ( 1.0 - distLRad ) * lowerShellValue ) + ( distLRad * upperShellValue );
1456  }
1457 
1458  }
1459 
1460  }
1461 
1462  //================================================ Done
1463  return ;
1464 
1465 }

◆ 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 1101 of file ProSHADE_data.cpp.

1102 {
1103  //================================================ Report function start
1104  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map inversion." );
1105 
1106  //================================================ Initialise variables
1107  proshade_signed arrayPos, invPos;
1108 
1109  //================================================ Create helper map
1110  proshade_double* hlpMap = new proshade_double [this->xDimIndices * this->yDimIndices * this->zDimIndices];
1111  ProSHADE_internal_misc::checkMemoryAllocation ( hlpMap, __FILE__, __LINE__, __func__ );
1112 
1113  //================================================ Save map values to the helper map
1114  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1115  {
1116  hlpMap[iter] = this->internalMap[iter];
1117  }
1118 
1119  //================================================ Invert the values
1120  for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->xDimIndices ); xIt++ )
1121  {
1122  for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->yDimIndices ); yIt++ )
1123  {
1124  for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->zDimIndices ); zIt++ )
1125  {
1126  //==================================== Var init
1127  arrayPos = zIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( yIt + static_cast< proshade_signed > ( this->yDimIndices ) * xIt );
1128  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 ) );
1129 
1130  //==================================== And save
1131  this->internalMap[invPos] = hlpMap[arrayPos];
1132  }
1133  }
1134  }
1135 
1136  //================================================ Release memory
1137  delete[] hlpMap;
1138 
1139  //================================================ Report function completion
1140  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Map inversion completed." );
1141 
1142  //================================================ Done
1143  return ;
1144 
1145 }

◆ 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 1193 of file ProSHADE_overlay.cpp.

1194 {
1195  //================================================ Initialise local variables
1196  double *sigR = nullptr, *sigI = nullptr, *rcoeffs = nullptr, *icoeffs = nullptr, *weights = nullptr, *workspace = nullptr;
1197  fftw_plan idctPlan, ifftPlan;
1198 
1199  //================================================ For each shell
1200  for ( int shell = 0; shell < static_cast<int> ( this->noSpheres ); shell++ )
1201  {
1202  //=========================================== Initialise internal variables
1203  proshade_unsign oneDim = this->spheres[shell]->getLocalBandwidth() * 2;
1204 
1205  //=========================================== Allocate memory
1206  ProSHADE_internal_overlay::initialiseInverseSHComputation ( this->spheres[shell]->getLocalBandwidth(), sigR, sigI, rcoeffs, icoeffs, weights, workspace, idctPlan, ifftPlan );
1207 
1208  //=========================================== Compute weights for the transform using the appropriate shell related band
1209  makeweights ( static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ), weights );
1210 
1211  //============================================ Allocate rotated shell mapped data memory
1212  this->spheres[shell]->allocateRotatedMap ( );
1213 
1214  //============================================ Load SH coeffs to arrays
1215  for ( unsigned int iter = 0; iter < static_cast<unsigned int> ( oneDim * oneDim ); iter++ )
1216  {
1217  rcoeffs[iter] = this->rotSphericalHarmonics[shell][iter][0];
1218  icoeffs[iter] = this->rotSphericalHarmonics[shell][iter][1];
1219  sigR[iter] = 0.0;
1220  sigI[iter] = 0.0;
1221  }
1222 
1223  //============================================ Get inverse spherical harmonics transform for the shell
1224  InvFST_semi_fly ( rcoeffs,
1225  icoeffs,
1226  sigR,
1227  sigI,
1228  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ),
1229  workspace,
1230  0,
1231  static_cast< int > ( this->spheres[shell]->getLocalBandwidth() ),
1232  &idctPlan,
1233  &ifftPlan );
1234 
1235  //=========================================== Copy the results to the rotated shells array
1236  for ( unsigned int iter = 0; iter < static_cast<unsigned int> ( oneDim * oneDim ); iter++ )
1237  {
1238  this->spheres[shell]->setRotatedMappedData ( iter, sigR[iter] );
1239  }
1240 
1241  //=========================================== Release the plans
1242  fftw_destroy_plan ( idctPlan );
1243  fftw_destroy_plan ( ifftPlan );
1244 
1245  //=========================================== Release the memory
1246  delete[] sigR;
1247  delete[] rcoeffs;
1248  delete[] weights;
1249  delete[] workspace;
1250  }
1251 
1252  //================================================ Done
1253  return ;
1254 
1255 }

◆ 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 1712 of file ProSHADE_data.cpp.

1713 {
1714  //================================================ Report progress
1715  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting sphere mapping procedure." );
1716 
1717  //================================================ Determine spherical harmonics variables
1718  settings->determineAllSHValues ( this->xDimIndices, this->yDimIndices,
1719  this->xDimSize, this->yDimSize, this->zDimSize );
1720  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Sphere settings determined." );
1721 
1722  //================================================ Find number of spheres supported
1723  this->getSpherePositions ( settings );
1724  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Sphere positions obtained." );
1725 
1726  //================================================ Create sphere objects and map the density
1728  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->spherePos.size() ); iter++ )
1729  {
1730  std::stringstream ss;
1731  ss << "Now mapping sphere " << iter << " .";
1732  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, ss.str() );
1733 
1735  this->xDimSize, this->yDimSize, this->zDimSize, iter,
1736  &this->spherePos, settings->progressiveSphereMapping, settings->maxBandwidth,
1737  this->internalMap, &this->maxShellBand );
1738  }
1739 
1740  //================================================ Report completion
1741  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Sphere mapping procedure completed." );
1742 
1743  //================================================ Done
1744  return ;
1745 
1746 }

◆ 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 1202 of file ProSHADE_data.cpp.

1203 {
1204  //================================================ Report function start
1205  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Computing mask." );
1206 
1207  //================================================ Initialise the blurred map
1208  proshade_double* blurredMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1209  ProSHADE_internal_misc::checkMemoryAllocation ( blurredMap, __FILE__, __LINE__, __func__ );
1210 
1211  //================================================ Compute blurred map
1213  this->xDimSize, this->yDimSize, this->zDimSize, settings->blurFactor );
1214 
1215  //================================================ Compute mask from blurred map and save it into the original map
1217 
1218  //================================================ Print the mask if need be
1219  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 ); } }
1220 
1221  //================================================ Release memory
1222  delete[] blurredMap;
1223 
1224  //================================================ Report function completion
1225  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Mask computed." );
1226 
1227  //================================================ Done
1228  return ;
1229 
1230 }

◆ 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 4146 of file ProSHADE_data.cpp.

4147 {
4148  //================================================ Mutate
4149  this->eMatrices[band][order1][order2][0] /= normF;
4150  this->eMatrices[band][order1][order2][1] /= normF;
4151 
4152  //================================================ Done
4153  return ;
4154 
4155 }

◆ 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 1155 of file ProSHADE_data.cpp.

1156 {
1157  //================================================ Report function start
1158  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map normalisation." );
1159 
1160  //================================================ Initialise vector of map values
1161  std::vector<proshade_double> mapVals ( this->xDimIndices * this->yDimIndices * this->zDimIndices, 0.0 );
1162 
1163  //================================================ Get all map values
1164  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1165  {
1166  mapVals.at(iter) = this->internalMap[iter];
1167  }
1168 
1169  //================================================ Get mean and sd
1170  proshade_double* meanSD = new proshade_double[2];
1171  ProSHADE_internal_maths::vectorMeanAndSD ( &mapVals, meanSD );
1172 
1173  //================================================ Normalise the values
1174  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1175  {
1176  this->internalMap[iter] = ( this->internalMap[iter] - meanSD[0] ) / meanSD[1];
1177  }
1178 
1179  //================================================ Clear the vector
1180  mapVals.clear ( );
1181 
1182  //================================================ Release memory
1183  delete[] meanSD;
1184 
1185  //================================================ Report function completion
1186  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Map normalisation completed." );
1187 
1188  //================================================ Done
1189  return ;
1190 
1191 }

◆ 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 
)

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.

Definition at line 2388 of file ProSHADE_data.cpp.

2389 {
2390  //================================================ Decide number of bins and allocate which reflection belongs to which bin
2392 
2393  //================================================ Allocate memory for FSC sums
2394  bindata = new proshade_double*[*noBins];
2395  binCounts = new proshade_signed [*noBins];
2396 
2397  //================================================ Allcate memory for bin sumation
2398  for ( size_t binIt = 0; binIt < static_cast< size_t > ( *noBins ); binIt++ )
2399  {
2400  bindata[binIt] = new proshade_double[12];
2401  ProSHADE_internal_misc::checkMemoryAllocation ( bindata[binIt], __FILE__, __LINE__, __func__ );
2402  }
2403 
2404  //================================================ Allocate memory for Fourier transform imputs and outputs
2405  mapData = new fftw_complex [this->xDimIndices * this->yDimIndices * this->zDimIndices];
2406  origCoeffs = new fftw_complex [this->xDimIndices * this->yDimIndices * this->zDimIndices];
2407  fCoeffs = new fftw_complex [this->xDimIndices * this->yDimIndices * this->zDimIndices];
2408 
2409  //================================================ Check memory allocation
2410  ProSHADE_internal_misc::checkMemoryAllocation ( mapData, __FILE__, __LINE__, __func__ );
2411  ProSHADE_internal_misc::checkMemoryAllocation ( origCoeffs, __FILE__, __LINE__, __func__ );
2412  ProSHADE_internal_misc::checkMemoryAllocation ( fCoeffs, __FILE__, __LINE__, __func__ );
2413  ProSHADE_internal_misc::checkMemoryAllocation ( bindata, __FILE__, __LINE__, __func__ );
2414  ProSHADE_internal_misc::checkMemoryAllocation ( binCounts, __FILE__, __LINE__, __func__ );
2415 
2416  //================================================ Prepare memory for Fourier transform
2417  *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 );
2418 
2419  //================================================ Compute Fourier transform of the original map
2420  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; }
2421  fftw_execute ( *planForwardFourier );
2422  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]; }
2423 
2424  //================================================ Done
2425  return ;
2426 
2427 }

◆ 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 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 1612 of file ProSHADE_data.cpp.

1613 {
1614  //================================================ Invert map
1615  if ( settings->invertMap ) { this->invertMirrorMap ( settings ); }
1616  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map inversion (mirror image) not requested." ); }
1617 
1618  //================================================ Normalise map
1619  if ( settings->normaliseMap ) { this->normaliseMap ( settings ); }
1620  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map normalisation not requested." ); }
1621 
1622  //================================================ Compute mask
1623  if ( settings->maskMap ) { this->maskMap ( settings ); }
1624  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Masking not requested." ); }
1625 
1626  //================================================ Centre map
1627  if ( settings->moveToCOM ) { this->centreMapOnCOM ( settings ); }
1628  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Map centering not requested." ); }
1629 
1630  //================================================ Add extra space
1631  if ( settings->addExtraSpace != 0.0f ) { this->addExtraSpace ( settings ); }
1632  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Extra space not requested." ); }
1633 
1634  //================================================ Remove phase, if required
1635  if ( !settings->usePhase ) { this->removePhaseInormation ( settings ); ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Phase information removed from the data." ); }
1636  else { ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Phase information retained in the data." ); }
1637 
1638  //================================================ Set settings values which were left on AUTO by user and will not be set later
1639  settings->setVariablesLeftOnAuto ( );
1640 
1641  //================================================ Done
1642  return ;
1643 
1644 }

◆ readInMAP()

void ProSHADE_internal_data::ProSHADE_data::readInMAP ( ProSHADE_settings settings)
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.

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

Definition at line 554 of file ProSHADE_data.cpp.

555 {
556  //================================================ Open the file
557  gemmi::Ccp4<float> map;
558  map.read_ccp4 ( gemmi::MaybeGzipped ( this->fileName.c_str() ) );
559 
560  //================================================ Convert to XYZ and create complete map, if need be
561  map.setup ( gemmi::GridSetup::ReorderOnly, NAN );
562 
563  //================================================ Read in the rest of the map file header
565  &this->xDimIndices, &this->yDimIndices, &this->zDimIndices,
566  &this->xDimSize, &this->yDimSize, &this->zDimSize,
567  &this->aAngle, &this->bAngle, &this->cAngle,
568  &this->xFrom, &this->yFrom, &this->zFrom,
569  &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin,
570  &this->xAxisOrder, &this->yAxisOrder, &this->zAxisOrder,
571  &this->xGridIndices, &this->yGridIndices, &this->zGridIndices );
572 
573  //================================================ Save the map density to ProSHADE variable
574  ProSHADE_internal_io::readInMapData ( &map, this->internalMap, this->xDimIndices, this->yDimIndices, this->zDimIndices, this->xAxisOrder, this->yAxisOrder, this->zAxisOrder );
575 
576  //================================================ If mask is supplied and the correct task is used
577  if ( ( settings->appliedMaskFileName != "" ) && ( ( settings->task == MapManip ) || ( settings->task == Symmetry ) ) )
578  {
579  //================================================ Report progress
580  std::stringstream hlpSS;
581  hlpSS << "Reading mask file " << settings->appliedMaskFileName;
582  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, hlpSS.str() );
583 
584  //============================================ Open the mask
585  gemmi::Ccp4<float> mask;
586  mask.read_ccp4 ( gemmi::MaybeGzipped ( settings->appliedMaskFileName.c_str() ) );
587 
588  //============================================ Convert to XYZ and create complete mask, if need be
589  mask.setup ( gemmi::GridSetup::ReorderOnly, 0 );
590 
591  //============================================ Read in the rest of the mask file header
592  proshade_unsign xDI, yDI, zDI, xAOR, yAOR, zAOR, xGI, yGI, zGI;
593  proshade_single xDS, yDS, zDS, aA, bA, cA;
594  proshade_signed xF, yF, zF, xAO, yAO, zAO;
596  &xDI, &yDI, &zDI,
597  &xDS, &yDS, &zDS,
598  &aA, &bA, &cA,
599  &xF, &yF, &zF,
600  &xAO, &yAO, &zAO,
601  &xAOR, &yAOR, &zAOR,
602  &xGI, &yGI, &zGI );
603 
604  //============================================ Sanity check
605  if ( ( this->xDimIndices != xDI ) || ( this->yDimIndices != yDI ) || ( this->zDimIndices != zDI ) )
606  {
607  throw ProSHADE_exception ( "The supplied map mask has different dimensions than the\n : density map.", "EM00065", __FILE__, __LINE__, __func__, "Most likely the mask is not the correct mask for this map,\n : as it has different dimensions from the density map.\n : Please review that the supplied map and mask form a pair." );
608  }
609 
610  //============================================ Save the mask values to ProSHADE variable
611  proshade_double* internalMask = nullptr;
612  ProSHADE_internal_io::readInMapData ( &mask, internalMask, xDI, yDI, zDI, xAOR, yAOR, zAOR );
613 
614  //============================================ Apply the mask to the map
615  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { this->internalMap[iter] *= internalMask[iter]; }
616 
617  //============================================ Release the memory
618  delete[] internalMask;
619 
620  //============================================ Report progress
621  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "Mask read in and applied successfully." );
622  }
623 
624  //================================================ Remove negative values if so required
625  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; } } }
626 
627  //================================================ Set resolution if need be
628  if ( settings->requestedResolution < 0.0f )
629  {
630  settings->setResolution ( std::min ( static_cast<proshade_single> ( this->xDimSize ) / static_cast<proshade_single> ( this->xDimIndices ),
631  std::min ( static_cast<proshade_single> ( this->yDimSize ) / static_cast<proshade_single> ( this->yDimIndices ),
632  static_cast<proshade_single> ( this->zDimSize ) / static_cast<proshade_single> ( this->zDimIndices ) ) ) * 2.0f );
633  }
634 
635  //================================================ Set iterators from and to
636  this->figureIndexStartStop ( );
637 
638  //================================================ If specific resolution is requested, make sure the map has it
639  if ( settings->changeMapResolution || settings->changeMapResolutionTriLinear )
640  {
641  //============================================ Before re-sampling sampling rate
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  //============================================ Bofore re-sampling first index position
647  proshade_single xStartPosBefore = static_cast< proshade_single > ( this->xFrom ) * xSampRate;
648  proshade_single yStartPosBefore = static_cast< proshade_single > ( this->yFrom ) * ySampRate;
649  proshade_single zStartPosBefore = static_cast< proshade_single > ( this->zFrom ) * zSampRate;
650 
651  //============================================ Find COM before map re-sampling
652  proshade_double xMapCOMPreReSampl = 0.0, yMapCOMPreReSampl = 0.0, zMapCOMPreReSampl = 0.0;
653  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 );
654 
655  //============================================ Re-sample map
656  this->reSampleMap ( settings );
657 
658  //============================================ After re-sampling sampling rate
659  xSampRate = this->xDimSize / static_cast< proshade_single > ( this->xTo - this->xFrom );
660  ySampRate = this->yDimSize / static_cast< proshade_single > ( this->yTo - this->yFrom );
661  zSampRate = this->zDimSize / static_cast< proshade_single > ( this->zTo - this->zFrom );
662 
663  //============================================ After re-sampling first index position
664  proshade_single xStartPosAfter = static_cast< proshade_single > ( this->xFrom ) * xSampRate;
665  proshade_single yStartPosAfter = static_cast< proshade_single > ( this->yFrom ) * ySampRate;
666  proshade_single zStartPosAfter = static_cast< proshade_single > ( this->zFrom ) * zSampRate;
667 
668  //============================================ Translate by change in corners to make the boxes as similarly placed as possible
669  proshade_single xMov = static_cast< proshade_single > ( xStartPosAfter - xStartPosBefore );
670  proshade_single yMov = static_cast< proshade_single > ( yStartPosAfter - yStartPosBefore );
671  proshade_single zMov = static_cast< proshade_single > ( zStartPosAfter - zStartPosBefore );
672  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->xDimSize, this->yDimSize, this->zDimSize,
673  &this->xFrom, &this->xTo, &this->yFrom, &this->yTo, &this->zFrom, &this->zTo,
674  &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin );
675 
676  //============================================ Find COM after map re-sampling and corner move
677  proshade_double xMapCOMPostReSampl = 0.0, yMapCOMPostReSampl = 0.0, zMapCOMPostReSampl = 0.0;
678  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 );
679 
680  //============================================ Match the COMs to get as close position of the re-sampled structure to the original as possible
682  static_cast< proshade_single > ( xMapCOMPreReSampl - xMapCOMPostReSampl ),
683  static_cast< proshade_single > ( yMapCOMPreReSampl - yMapCOMPostReSampl ),
684  static_cast< proshade_single > ( zMapCOMPreReSampl - zMapCOMPostReSampl ),
685  this->xDimSize, this->yDimSize, this->zDimSize,
686  static_cast< proshade_signed > ( this->xDimIndices ),
687  static_cast< proshade_signed > ( this->yDimIndices ),
688  static_cast< proshade_signed > ( this->zDimIndices ) );
689  }
690 
691  //================================================ Save the original sizes
692  this->xDimSizeOriginal = this->xDimSize;
693  this->yDimSizeOriginal = this->yDimSize;
694  this->zDimSizeOriginal = this->zDimSize;
695 
696  //================================================ Save the original index counts
697  this->xDimIndicesOriginal = this->xDimIndices;
698  this->yDimIndicesOriginal = this->yDimIndices;
699  this->zDimIndicesOriginal = this->zDimIndices;
700 
701  //================================================ Save the original axis origins
702  this->xAxisOriginOriginal = this->xAxisOrigin;
703  this->yAxisOriginOriginal = this->yAxisOrigin;
704  this->zAxisOriginOriginal = this->zAxisOrigin;
705 
706  //================================================ Compute and save the COM
707  this->findMapCOM ( );
708  this->originalMapXCom = this->xCom;
709  this->originalMapYCom = this->yCom;
710  this->originalMapZCom = this->zCom;
711 
712  //================================================ Done
713 
714 }

◆ 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 725 of file ProSHADE_data.cpp.

726 {
727  //================================================ Set resolution if need be
728  if ( settings->requestedResolution < 0.0f )
729  {
730  settings->setResolution ( 8.0 );
731  }
732 
733  //================================================ Open PDB file for reading
734  gemmi::Structure pdbFile = gemmi::read_structure ( gemmi::MaybeGzipped ( this->fileName ) );
735 
736  //================================================ Change B-factors if need be
737  if ( settings->pdbBFactorNewVal >= 0.0 )
738  {
740  }
741 
742  //================================================ Remove waters if required
743  if ( settings->removeWaters )
744  {
746  }
747 
748  //================================================ Get PDB COM values
749  proshade_double xCOMPdb, yCOMPdb, zCOMPdb;
750  ProSHADE_internal_mapManip::findPDBCOMValues ( pdbFile, &xCOMPdb, &yCOMPdb, &zCOMPdb, settings->firstModelOnly );
751 
752  //================================================ Find the ranges
753  proshade_single xF, xT, yF, yT, zF, zT;
754  ProSHADE_internal_mapManip::determinePDBRanges ( pdbFile, &xF, &xT, &yF, &yT, &zF, &zT, settings->firstModelOnly );
755 
756  //================================================ Move ranges to have all FROM values 20
757  proshade_single xMov = static_cast< proshade_single > ( 20.0f - xF );
758  proshade_single yMov = static_cast< proshade_single > ( 20.0f - yF );
759  proshade_single zMov = static_cast< proshade_single > ( 20.0f - zF );
760  ProSHADE_internal_mapManip::movePDBForMapCalc ( &pdbFile, xMov, yMov, zMov, settings->firstModelOnly );
761 
762  //================================================ Set the angstrom sizes
763  this->xDimSize = static_cast< proshade_single > ( xT - xF + 40.0f );
764  this->yDimSize = static_cast< proshade_single > ( yT - yF + 40.0f );
765  this->zDimSize = static_cast< proshade_single > ( zT - zF + 40.0f );
766 
767  //================================================ Generate map from nicely placed atoms (cell size will be range + 40)
768  ProSHADE_internal_mapManip::generateMapFromPDB ( pdbFile, this->internalMap, settings->requestedResolution, this->xDimSize, this->yDimSize, this->zDimSize, &this->xTo, &this->yTo, &this->zTo, settings->forceP1, settings->firstModelOnly );
769 
770  //================================================ Remove negative values if so required
771  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; } } }
772 
773  //================================================ Set the internal variables to correct values
774  this->setPDBMapValues ( );
775 
776  //================================================ Compute reverse movement based on COMs. If there is more than 1 models, simply moving back the xyzMov is not enough.
777  proshade_double xCOMMap, yCOMMap, zCOMMap;
778  ProSHADE_internal_mapManip::findMAPCOMValues ( this->internalMap, &xCOMMap, &yCOMMap, &zCOMMap,
779  this->xDimSize, this->yDimSize, this->zDimSize,
780  this->xFrom, this->xTo, this->yFrom, this->yTo, this->zFrom, this->zTo );
781 
782  if ( pdbFile.models.size() > 1 )
783  {
784  xMov = static_cast< proshade_single > ( xCOMMap - xCOMPdb );
785  yMov = static_cast< proshade_single > ( yCOMMap - yCOMPdb );
786  zMov = static_cast< proshade_single > ( zCOMMap - zCOMPdb );
787  }
788 
789  //================================================ Move map back to the original PDB location
790  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->xDimSize, this->yDimSize, this->zDimSize,
791  &this->xFrom, &this->xTo, &this->yFrom, &this->yTo, &this->zFrom, &this->zTo,
792  &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin );
793  ProSHADE_internal_mapManip::moveMapByFourier ( this->internalMap, xMov, yMov, zMov, this->xDimSize, this->yDimSize, this->zDimSize,
794  static_cast< proshade_signed > ( this->xDimIndices ), static_cast< proshade_signed > ( this->yDimIndices ),
795  static_cast< proshade_signed > ( this->zDimIndices ) );
796 
797  //================================================ If specific resolution is requested, make sure the map has it
798  if ( settings->changeMapResolution || settings->changeMapResolutionTriLinear )
799  {
800  //============================================ Before re-sampling sampling rate
801  proshade_single xSampRate = this->xDimSize / static_cast< proshade_single > ( this->xTo - this->xFrom );
802  proshade_single ySampRate = this->yDimSize / static_cast< proshade_single > ( this->yTo - this->yFrom );
803  proshade_single zSampRate = this->zDimSize / static_cast< proshade_single > ( this->zTo - this->zFrom );
804 
805  //============================================ Bofore re-sampling first index position
806  proshade_single xStartPosBefore = static_cast< proshade_single > ( this->xFrom ) * xSampRate;
807  proshade_single yStartPosBefore = static_cast< proshade_single > ( this->yFrom ) * ySampRate;
808  proshade_single zStartPosBefore = static_cast< proshade_single > ( this->zFrom ) * zSampRate;
809 
810  //============================================ Find COM before map re-sampling
811  proshade_double xMapCOMPreReSampl = 0.0, yMapCOMPreReSampl = 0.0, zMapCOMPreReSampl = 0.0;
812  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 );
813 
814  //============================================ Re-sample map
815  this->reSampleMap ( settings );
816 
817  //============================================ After re-sampling sampling rate
818  xSampRate = this->xDimSize / static_cast< proshade_single > ( this->xTo - this->xFrom );
819  ySampRate = this->yDimSize / static_cast< proshade_single > ( this->yTo - this->yFrom );
820  zSampRate = this->zDimSize / static_cast< proshade_single > ( this->zTo - this->zFrom );
821 
822  //============================================ After re-sampling first index position
823  proshade_single xStartPosAfter = static_cast< proshade_single > ( this->xFrom ) * xSampRate;
824  proshade_single yStartPosAfter = static_cast< proshade_single > ( this->yFrom ) * ySampRate;
825  proshade_single zStartPosAfter = static_cast< proshade_single > ( this->zFrom ) * zSampRate;
826 
827  //============================================ Translate by change in corners to make the boxes as similarly placed as possible
828  proshade_single xMovHlp = static_cast< proshade_single > ( xStartPosAfter - xStartPosBefore );
829  proshade_single yMovHlp = static_cast< proshade_single > ( yStartPosAfter - yStartPosBefore );
830  proshade_single zMovHlp = static_cast< proshade_single > ( zStartPosAfter - zStartPosBefore );
831  ProSHADE_internal_mapManip::moveMapByIndices ( &xMovHlp, &yMovHlp, &zMovHlp, this->xDimSize, this->yDimSize, this->zDimSize,
832  &this->xFrom, &this->xTo, &this->yFrom, &this->yTo, &this->zFrom, &this->zTo,
833  &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin );
834 
835  //============================================ Find COM after map re-sampling and corner move
836  proshade_double xMapCOMPostReSampl = 0.0, yMapCOMPostReSampl = 0.0, zMapCOMPostReSampl = 0.0;
837  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 );
838 
839  //============================================ Match the COMs to get as close position of the re-sampled structure to the original as possible
841  static_cast< proshade_single > ( xMapCOMPreReSampl - xMapCOMPostReSampl ),
842  static_cast< proshade_single > ( yMapCOMPreReSampl - yMapCOMPostReSampl ),
843  static_cast< proshade_single > ( zMapCOMPreReSampl - zMapCOMPostReSampl ),
844  this->xDimSize, this->yDimSize, this->zDimSize,
845  static_cast< proshade_signed > ( this->xDimIndices ),
846  static_cast< proshade_signed > ( this->yDimIndices ),
847  static_cast< proshade_signed > ( this->zDimIndices ) );
848  }
849 
850  //================================================ Save the original sizes
851  this->xDimSizeOriginal = this->xDimSize;
852  this->yDimSizeOriginal = this->yDimSize;
853  this->zDimSizeOriginal = this->zDimSize;
854 
855  //================================================ Save the original index counts
856  this->xDimIndicesOriginal = this->xDimIndices;
857  this->yDimIndicesOriginal = this->yDimIndices;
858  this->zDimIndicesOriginal = this->zDimIndices;
859 
860  //================================================ Save the original axis origins
861  this->xAxisOriginOriginal = this->xAxisOrigin;
862  this->yAxisOriginOriginal = this->yAxisOrigin;
863  this->zAxisOriginOriginal = this->zAxisOrigin;
864 
865  //================================================ Compute and save the COM
866  this->findMapCOM ( );
867  this->originalMapXCom = this->xCom;
868  this->originalMapYCom = this->yCom;
869  this->originalMapZCom = this->zCom;
870 
871  //================================================ Done
872  return;
873 
874 }

◆ readInStructure()

void ProSHADE_internal_data::ProSHADE_data::readInStructure ( std::string  fName,
proshade_unsign  inputO,
ProSHADE_settings settings 
)

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.

Definition at line 501 of file ProSHADE_data.cpp.

502 {
503  //================================================ Report function start
504  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting to read the structure: " + fName );
505 
506  //================================================ Check if instance is empty
507  if ( !this->isEmpty )
508  {
509  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 );
510  }
511 
512  //================================================ Save the filename
513  this->fileName = fName;
514 
515  //================================================ Check what is the input format
517 
518  //================================================ Save input order
519  this->inputOrder = inputO;
520 
521  //================================================ Decide how to proceed
522  switch ( this->fileType )
523  {
524  case ProSHADE_internal_io::UNKNOWN:
525  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." );
526 
527  case ProSHADE_internal_io::PDB:
528  this->readInPDB ( settings );
529  break;
530 
531  case ProSHADE_internal_io::MAP:
532  this->readInMAP ( settings );
533  break;
534  }
535 
536  //================================================ This structure is now full
537  this->isEmpty = false;
538 
539  //================================================ Report function completion
540  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Structure read in successfully." );
541 
542  //================================================ Done
543  return ;
544 
545 }

◆ 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 3676 of file ProSHADE_data.cpp.

3677 {
3678  //================================================ Report function start
3679  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Centering map onto its COM." );
3680 
3681  //================================================ Copy map for processing
3682  fftw_complex* mapCoeffs = new fftw_complex[this->xDimIndices * this->yDimIndices * this->zDimIndices];
3683  fftw_complex* pattersonMap = new fftw_complex[this->xDimIndices * this->yDimIndices * this->zDimIndices];
3684 
3685  //================================================ Check memory allocation
3686  ProSHADE_internal_misc::checkMemoryAllocation ( mapCoeffs, __FILE__, __LINE__, __func__ );
3687  ProSHADE_internal_misc::checkMemoryAllocation ( pattersonMap, __FILE__, __LINE__, __func__ );
3688 
3689  //================================================ Copy data to mask
3690  for ( proshade_unsign iter = 0; iter < (this->xDimIndices * this->yDimIndices * this->zDimIndices); iter++ )
3691  {
3692  pattersonMap[iter][0] = this->internalMap[iter];
3693  pattersonMap[iter][1] = 0.0;
3694  }
3695 
3696  //================================================ Prepare FFTW plans
3697  fftw_plan forward = fftw_plan_dft_3d ( static_cast< int > ( this->xDimIndices ), static_cast< int > ( this->yDimIndices ), static_cast< int > ( this->zDimIndices ),
3698  pattersonMap, mapCoeffs, FFTW_FORWARD, FFTW_ESTIMATE );
3699  fftw_plan inverse = fftw_plan_dft_3d ( static_cast< int > ( this->xDimIndices ), static_cast< int > ( this->yDimIndices ), static_cast< int > ( this->zDimIndices ),
3700  mapCoeffs, pattersonMap, FFTW_BACKWARD, FFTW_ESTIMATE );
3701 
3702  //================================================ Run forward Fourier
3703  fftw_execute ( forward );
3704 
3705  //================================================ Remove the phase
3707 
3708  //================================================ Run inverse Fourier
3709  fftw_execute ( inverse );
3710 
3711  //================================================ Save the results
3712  proshade_signed mapIt, patIt, patX, patY, patZ;
3713  for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->xDimIndices ); xIt++ )
3714  {
3715  for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->yDimIndices ); yIt++ )
3716  {
3717  for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->zDimIndices ); zIt++ )
3718  {
3719  //==================================== Centre patterson map
3720  patX = xIt - ( static_cast<proshade_signed> ( this->xDimIndices ) / 2 ); if ( patX < 0 ) { patX += this->xDimIndices; }
3721  patY = yIt - ( static_cast<proshade_signed> ( this->yDimIndices ) / 2 ); if ( patY < 0 ) { patY += this->yDimIndices; }
3722  patZ = zIt - ( static_cast<proshade_signed> ( this->zDimIndices ) / 2 ); if ( patZ < 0 ) { patZ += this->zDimIndices; }
3723 
3724  //==================================== Find indices
3725  mapIt = zIt + static_cast< proshade_signed > ( this->zDimIndices ) * ( yIt + static_cast< proshade_signed > ( this->yDimIndices ) * xIt );
3726  patIt = patZ + static_cast< proshade_signed > ( this->zDimIndices ) * ( patY + static_cast< proshade_signed > ( this->yDimIndices ) * patX );
3727 
3728  //==================================== Copy
3729  this->internalMap[mapIt] = pattersonMap[patIt][0];
3730  }
3731  }
3732  }
3733 
3734  //================================================ Release memory
3735  delete[] pattersonMap;
3736  delete[] mapCoeffs;
3737 
3738  //================================================ Delete FFTW plans
3739  fftw_destroy_plan ( forward );
3740  fftw_destroy_plan ( inverse );
3741 
3742  //================================================ Report function completion
3743  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Phase information removed." );
3744 
3745  //================================================ Done
3746  return ;
3747 
3748 }

◆ 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 4522 of file ProSHADE_data.cpp.

4523 {
4524  //================================================ Empty line
4526 
4527  //================================================ Write out rotation centre translation results
4528  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);
4529  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, rotCen.str() );
4530 
4531  //================================================ Write out rotation matrix about origin
4532  proshade_double* rotMat = new proshade_double[9];
4533  ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
4534  ProSHADE_internal_maths::getRotationMatrixFromEulerZXZAngles ( eulerAngles->at(0), eulerAngles->at(1), eulerAngles->at(2), rotMat );
4535 
4536  std::stringstream rotMatSS;
4537  rotMatSS << std::setprecision (3) << std::showpos << "The rotation matrix about origin is : " << rotMat[0] << " " << rotMat[1] << " " << rotMat[2] << std::endl;
4538  rotMatSS << std::setprecision (3) << std::showpos << " : " << rotMat[3] << " " << rotMat[4] << " " << rotMat[5] << std::endl;
4539  rotMatSS << std::setprecision (3) << std::showpos << " : " << rotMat[6] << " " << rotMat[7] << " " << rotMat[8];
4540  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, rotMatSS.str() );
4541 
4542  delete[] rotMat;
4543 
4544  //================================================ Write out origin to overlay translation results
4545  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);
4546  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, finTrs.str() );
4547 
4548  //================================================ Done
4549  return ;
4550 
4551 }

◆ 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 3498 of file ProSHADE_data.cpp.

3499 {
3500  //================================================ Improve this!
3501  if ( settings->recommendedSymmetryType == "" )
3502  {
3503  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, "Did not detect any symmetry!" );
3504  }
3505  else
3506  {
3507  std::stringstream ssHlp;
3508  std::vector< proshade_double > comMove = this->getMapCOMProcessChange ( );
3509  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 .";
3510  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str() );
3511 
3512  if ( settings->detectedSymmetry.size() > 0 )
3513  {
3514  ssHlp.clear(); ssHlp.str ( "" );
3515  ssHlp << " Fold X Y Z Angle Height Average FSC";
3516  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str() );
3517  }
3518  for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( settings->detectedSymmetry.size() ); symIt++ )
3519  {
3520  ssHlp.clear(); ssHlp.str ( "" );
3521  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];
3522  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str() );
3523  }
3524 
3525  std::stringstream hlpSS3;
3526  ssHlp.clear(); ssHlp.str ( "" );
3527  hlpSS3 << std::endl << "To facilitate manual checking for symmetries, the following is a list of all detected C symmetries:";
3528  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, hlpSS3.str() );
3529 
3530  if ( settings->allDetectedCAxes.size() > 0 )
3531  {
3532  ssHlp.clear(); ssHlp.str ( "" );
3533  ssHlp << " Fold X Y Z Angle Height Average FSC";
3534  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str() );
3535  }
3536  for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( settings->allDetectedCAxes.size() ); symIt++ )
3537  {
3538  ssHlp.clear(); ssHlp.str ( "" );
3539  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];
3540  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 0, ssHlp.str() );
3541  }
3542 
3543  }
3544 
3545  //================================================ Done
3546  return ;
3547 
3548 }

◆ 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 1366 of file ProSHADE_data.cpp.

1367 {
1368  //================================================ Initialise the return variable
1369  proshade_single* changeVals = new proshade_single[6];
1370 
1371  //================================================ Now re-sample the map
1372  if ( settings->changeMapResolution )
1373  {
1374  ProSHADE_internal_mapManip::reSampleMapToResolutionFourier ( this->internalMap, settings->requestedResolution, this->xDimIndices, this->yDimIndices, this->zDimIndices,
1375  this->xDimSize, this->yDimSize, this->zDimSize, changeVals );
1376 
1377  if ( settings->changeMapResolutionTriLinear )
1378  {
1379  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" );
1380  }
1381  }
1382  if ( settings->changeMapResolutionTriLinear && !settings->changeMapResolution )
1383  {
1384  ProSHADE_internal_mapManip::reSampleMapToResolutionTrilinear ( this->internalMap, settings->requestedResolution, this->xDimIndices, this->yDimIndices, this->zDimIndices,
1385  this->xDimSize, this->yDimSize, this->zDimSize, changeVals );
1386 
1387  }
1388 
1389  //================================================ Set the internal values to reflect the new map size
1390  this->xDimIndices += static_cast<proshade_unsign> ( changeVals[0] );
1391  this->yDimIndices += static_cast<proshade_unsign> ( changeVals[1] );
1392  this->zDimIndices += static_cast<proshade_unsign> ( changeVals[2] );
1393 
1394  this->xGridIndices = this->xDimIndices;
1395  this->yGridIndices = this->yDimIndices;
1396  this->zGridIndices = this->zDimIndices;
1397 
1398  this->xTo += static_cast<proshade_unsign> ( changeVals[0] );
1399  this->yTo += static_cast<proshade_unsign> ( changeVals[1] );
1400  this->zTo += static_cast<proshade_unsign> ( changeVals[2] );
1401 
1402  this->xDimSize = changeVals[3];
1403  this->yDimSize = changeVals[4];
1404  this->zDimSize = changeVals[5];
1405 
1406  //================================================ Figure how much the new map moved
1407  proshade_single xMov = -( ( static_cast<proshade_single> ( this->xFrom ) * ( this->xDimSize / static_cast<proshade_single> ( this->xDimIndices ) - changeVals[0] ) ) -
1408  ( static_cast<proshade_single> ( this->xFrom ) * ( this->xDimSize / static_cast<proshade_single> ( this->xDimIndices ) ) ) );
1409  proshade_single yMov = -( ( static_cast<proshade_single> ( this->yFrom ) * ( this->yDimSize / static_cast<proshade_single> ( this->yDimIndices ) - changeVals[1] ) ) -
1410  ( static_cast<proshade_single> ( this->yFrom ) * ( this->yDimSize / static_cast<proshade_single> ( this->yDimIndices ) ) ) );
1411  proshade_single zMov = -( ( static_cast<proshade_single> ( this->zFrom ) * ( this->zDimSize / static_cast<proshade_single> ( this->zDimIndices ) - changeVals[2] ) ) -
1412  ( static_cast<proshade_single> ( this->zFrom ) * ( this->zDimSize / static_cast<proshade_single> ( this->zDimIndices ) ) ) );
1413 
1414  //================================================ Move by indices (this should be sufficient)
1415  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->xDimSize, this->yDimSize, this->zDimSize, &this->xFrom, &this->xTo,
1416  &this->yFrom, &this->yTo, &this->zFrom, &this->zTo, &this->xAxisOrigin, &this->yAxisOrigin, &this->zAxisOrigin );
1417 
1418  ProSHADE_internal_mapManip::moveMapByFourier ( this->internalMap, xMov, yMov, zMov, this->xDimSize, this->yDimSize, this->zDimSize,
1419  static_cast< proshade_signed > ( this->xDimIndices ), static_cast< proshade_signed > ( this->yDimIndices ), static_cast< proshade_signed > ( this->zDimIndices ) );
1420 
1421  //================================================ Release memory
1422  delete[] changeVals;
1423 
1424  //================================================ Done
1425  return ;
1426 
1427 }

◆ rotateMapRealSpace()

void 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.

Definition at line 816 of file ProSHADE_overlay.cpp.

817 {
818  //================================================ Initialise local variables
819  bool withinBounds = true;
820  proshade_double c000, c001, c010, c011, c100, c101, c110, c111, c00, c01, c10, c11, c0, c1;
821  size_t arrPos = 0;
822  proshade_double xCOM, yCOM, zCOM;
823 
824  //================================================ Store sampling rates
825  proshade_single xSampRate = this->xDimSize / static_cast< proshade_single > ( this->xTo - this->xFrom );
826  proshade_single ySampRate = this->yDimSize / static_cast< proshade_single > ( this->yTo - this->yFrom );
827  proshade_single zSampRate = this->zDimSize / static_cast< proshade_single > ( this->zTo - this->zFrom );
828 
829  //================================================ Compute map COM
830  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 );
831 
832  //================================================ Allocate local variables
833  proshade_single *mins = new proshade_single[3];
834  proshade_single *maxs = new proshade_single[3];
835  proshade_single *rotMat = new proshade_single[9];
836  proshade_single *rotVec;
837  proshade_single *interpMins = new proshade_single[3];
838  proshade_single *interpMaxs = new proshade_single[3];
839  proshade_single *interpDiff = new proshade_single[3];
840  proshade_single *movs = new proshade_single[3];
841  map = new proshade_double[ this->xDimIndices * this->yDimIndices * this->zDimIndices ];
842 
843  //================================================ Check memory allocation
844  ProSHADE_internal_misc::checkMemoryAllocation ( mins, __FILE__, __LINE__, __func__ );
845  ProSHADE_internal_misc::checkMemoryAllocation ( maxs, __FILE__, __LINE__, __func__ );
846  ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
847  ProSHADE_internal_misc::checkMemoryAllocation ( interpMins, __FILE__, __LINE__, __func__ );
848  ProSHADE_internal_misc::checkMemoryAllocation ( interpMaxs, __FILE__, __LINE__, __func__ );
849  ProSHADE_internal_misc::checkMemoryAllocation ( interpDiff, __FILE__, __LINE__, __func__ );
850  ProSHADE_internal_misc::checkMemoryAllocation ( movs, __FILE__, __LINE__, __func__ );
851  ProSHADE_internal_misc::checkMemoryAllocation ( map, __FILE__, __LINE__, __func__ );
852 
853  //================================================ Fill map with zeroes
854  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { map[iter] = 0.0; }
855 
856  //================================================ Determine map max's and min's in terms of the hkl system
857  mins[0] = std::floor ( static_cast< proshade_single > ( this->xDimIndices ) / -2.0f );
858  mins[1] = std::floor ( static_cast< proshade_single > ( this->yDimIndices ) / -2.0f );
859  mins[2] = std::floor ( static_cast< proshade_single > ( this->zDimIndices ) / -2.0f );
860 
861  maxs[0] = -mins[0];
862  maxs[1] = -mins[1];
863  maxs[2] = -mins[2];
864 
865  if ( this->xDimIndices % 2 == 0 ) { maxs[0] -= 1.0f; }
866  if ( this->yDimIndices % 2 == 0 ) { maxs[1] -= 1.0f; }
867  if ( this->zDimIndices % 2 == 0 ) { maxs[2] -= 1.0f; }
868 
869  //================================================ Rotate about COM instead of map midpoint
870  movs[0] = ( static_cast< proshade_single > ( xCOM ) / xSampRate ) + ( mins[0] - static_cast< proshade_single > ( this->xFrom ) );
871  movs[1] = ( static_cast< proshade_single > ( yCOM ) / ySampRate ) + ( mins[1] - static_cast< proshade_single > ( this->yFrom ) );
872  movs[2] = ( static_cast< proshade_single > ( zCOM ) / zSampRate ) + ( mins[2] - static_cast< proshade_single > ( this->zFrom ) );
873 
874  //================================================ Get rotation matrix from Euler angles
875  ProSHADE_internal_maths::getRotationMatrixFromAngleAxis ( rotMat, axX, axY, axZ, axAng );
876 
877  //================================================ For each point
878  for ( proshade_single xIt = mins[0]; xIt <= maxs[0]; xIt += 1.0f )
879  {
880  for ( proshade_single yIt = mins[1]; yIt <= maxs[1]; yIt += 1.0f )
881  {
882  for ( proshade_single zIt = mins[2]; zIt <= maxs[2]; zIt += 1.0f )
883  {
884  //==================================== Compute new point position
885  rotVec = ProSHADE_internal_maths::compute3x3MatrixVectorMultiplication ( rotMat, xIt - movs[0], yIt - movs[1], zIt - movs[2] );
886 
887  //==================================== Find surrounding grid points indices and check for boundaries
888  withinBounds = true;
889  for ( size_t posIt = 0; posIt < 3; posIt++ )
890  {
891  //================================ Determine surrounding points indices in this dimension
892  interpMins[posIt] = std::floor ( rotVec[posIt] );
893  interpMaxs[posIt] = interpMins[posIt] + 1.0f;
894 
895  //================================ Check for boundaries
896  if ( ( maxs[posIt] < interpMins[posIt] ) || ( interpMins[posIt] < mins[posIt] ) || ( maxs[posIt] < interpMaxs[posIt] ) || ( interpMaxs[posIt] < mins[posIt] ) )
897  {
898  withinBounds = false;
899  break;
900  }
901 
902  //================================ Compute the difference from position to min index along this axis
903  interpDiff[posIt] = rotVec[posIt] - interpMins[posIt];
904  }
905  if ( !withinBounds ) { continue; }
906 
907  //==================================== Make sure interpolation max's are within bounds
908  for ( size_t posIt = 0; posIt < 3; posIt++ )
909  {
910  interpMaxs[posIt] = std::min ( maxs[posIt], std::max ( mins[posIt], interpMaxs[posIt] ) );
911  }
912 
913  //==================================== Release memory
914  delete[] rotVec;
915 
916  //==================================== Find the surrounding points values from their indices
917  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] ) ) );
918  c000 = this->internalMap[arrPos];
919 
920  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] ) ) );
921  c001 = this->internalMap[arrPos];
922 
923  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] ) ) );
924  c010 = this->internalMap[arrPos];
925 
926  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] ) ) );
927  c011 = this->internalMap[arrPos];
928 
929  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] ) ) );
930  c100 = this->internalMap[arrPos];
931 
932  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] ) ) );
933  c101 = this->internalMap[arrPos];
934 
935  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] ) ) );
936  c110 = this->internalMap[arrPos];
937 
938  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] ) ) );
939  c111 = this->internalMap[arrPos];
940 
941  //==================================== Interpolate along x-axis
942  c00 = ( c000 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c100 * static_cast< proshade_double > ( interpDiff[0] ) );
943  c01 = ( c001 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c101 * static_cast< proshade_double > ( interpDiff[0] ) );
944  c10 = ( c010 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c110 * static_cast< proshade_double > ( interpDiff[0] ) );
945  c11 = ( c011 * ( 1.0 - static_cast< proshade_double > ( interpDiff[0] ) ) ) + ( c111 * static_cast< proshade_double > ( interpDiff[0] ) );
946 
947  //==================================== Interpolate along y-axis
948  c0 = ( c00 * ( 1.0 - static_cast< proshade_double > ( interpDiff[1] ) ) ) + ( c10 * static_cast< proshade_double > ( interpDiff[1] ) );
949  c1 = ( c01 * ( 1.0 - static_cast< proshade_double > ( interpDiff[1] ) ) ) + ( c11 * static_cast< proshade_double > ( interpDiff[1] ) );
950 
951  //==================================== Interpolate along z-axis
952  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] ) ) );
953  map[arrPos] = ( c0 * ( 1.0 - static_cast< proshade_double > ( interpDiff[2] ) ) ) + ( c1 * static_cast< proshade_double > ( interpDiff[2] ) );
954  }
955  }
956  }
957 
958  //================================================ Release memory
959  delete[] mins;
960  delete[] maxs;
961  delete[] rotMat;
962  delete[] interpMins;
963  delete[] interpMaxs;
964  delete[] interpDiff;
965  delete[] movs;
966 
967  //================================================ Done
968  return ;
969 
970 }

◆ rotateMapRealSpaceInPlace()

void 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.

Definition at line 982 of file ProSHADE_overlay.cpp.

983 {
984  //================================================ Initialise local variables
985  proshade_double axX, axY, axZ, axAng, tmp, *rMat, *map;
986 
987  //================================================ Allocate local memory
988  rMat = new proshade_double[9];
989 
990  //================================================ Check local memory allocation
991  ProSHADE_internal_misc::checkMemoryAllocation ( rMat, __FILE__, __LINE__, __func__ );
992 
993  //================================================ Convert Euler angles to rotation matrix
995 
996  //================================================ Transpose the rotation matrix
997  tmp = rMat[1];
998  rMat[1] = rMat[3];
999  rMat[3] = tmp;
1000 
1001  tmp = rMat[2];
1002  rMat[2] = rMat[6];
1003  rMat[6] = tmp;
1004 
1005  tmp = rMat[5];
1006  rMat[5] = rMat[7];
1007  rMat[7] = tmp;
1008 
1009  //================================================ Convert rotation matrix to angle-axis
1010  ProSHADE_internal_maths::getAxisAngleFromRotationMatrix ( rMat, &axX, &axY, &axZ, &axAng );
1011 
1012  //================================================ Rotate the internal map
1013  this->rotateMapRealSpace ( axX, axY, axZ, axAng, map );
1014 
1015  //================================================ Copy the rotated map in place of the internal map
1016  for ( size_t iter = 0; iter < static_cast< size_t > ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1017  {
1018  this->internalMap[iter] = map[iter];
1019  }
1020 
1021  //================================================ Release local memory
1022  delete[] rMat;
1023  delete[] map;
1024 
1025  //================================================ Done
1026  return ;
1027 
1028 }

◆ 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 756 of file ProSHADE_overlay.cpp.

757 {
758  //================================================ Set maximum comparison bandwidth to maximum object bandwidth
759  this->maxCompBand = this->spheres[this->noSpheres-1]->getLocalBandwidth();
760 
761  //================================================ Save map COM after processing but before rotation
762  this->findMapCOM ( );
763  this->mapCOMProcessChangeX += ( this->xCom - this->originalMapXCom );
764  this->mapCOMProcessChangeY += ( this->yCom - this->originalMapYCom );
765  this->mapCOMProcessChangeZ += ( this->zCom - this->originalMapZCom );
766 
767  //================================================ Compute the Wigner D matrices for the Euler angles
768  ProSHADE_internal_wigner::computeWignerMatricesForRotation ( settings, this, -eulerAlpha, eulerBeta, -eulerGamma );
769 
770  //================================================ Initialise rotated Spherical Harmonics memory
771  this->allocateRotatedSHMemory ( );
772 
773  //================================================ Multiply SH coeffs by Wigner
774  this->computeRotatedSH ( );
775 
776  //================================================ Inverse the SH coeffs to shells
777  this->invertSHCoefficients ( );
778 
779  //================================================ Find spherical cut-offs
780  std::vector<proshade_double> lonCO, latCO;
781  ProSHADE_internal_overlay::computeAngularThreshold ( &lonCO, &latCO, settings->maxBandwidth * 2 );
782 
783  //================================================ Allocate memory for the rotated map
784  proshade_double *densityMapRotated = new proshade_double [this->xDimIndices * this->yDimIndices * this->zDimIndices];
785  ProSHADE_internal_misc::checkMemoryAllocation ( densityMapRotated, __FILE__, __LINE__, __func__ );
786  for ( unsigned int iter = 0; iter < static_cast<unsigned int> ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ ) { densityMapRotated[iter] = 0.0; }
787 
788  //================================================ Interpolate onto cartesian grid
789  this->interpolateMapFromSpheres ( densityMapRotated );
790 
791  //================================================ Copy map
792  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
793  {
794  this->internalMap[iter] = densityMapRotated[iter];
795  }
796 
797  //================================================ Release rotated map (original is now rotated)
798  delete[] densityMapRotated;
799 
800  //================================================ Done
801  return ;
802 
803 }

◆ 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 2286 of file ProSHADE_data.cpp.

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

◆ 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 
)

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.

Definition at line 2627 of file ProSHADE_data.cpp.

2628 {
2629  //================================================ Report progress
2630  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting recommended symmetry decision procedure." );
2631 
2632  //================================================ If no C symmetries, nothing to save...
2633  if ( CSym->size() == 0 )
2634  {
2635  settings->setRecommendedSymmetry ( "" );
2636  settings->setRecommendedFold ( 0 );
2637  return;
2638  }
2639 
2640  //================================================ Find the top group minimum threshold using smoothened histogram
2641  proshade_double step = 0.01;
2642  proshade_double sigma = 0.03;
2643  proshade_signed windowSize = 9;
2644  proshade_double bestHistPeakStart = this->findTopGroupSmooth ( CSym, 5, step, sigma, windowSize );
2645  if ( bestHistPeakStart > settings->peakThresholdMin ) { bestHistPeakStart = settings->peakThresholdMin; }
2646 
2647  //================================================ Report progress
2648  proshade_unsign noPassed = 0; for ( size_t cIt = 0; cIt < CSym->size(); cIt++ ) { if ( CSym->at(cIt)[5] > bestHistPeakStart ) { noPassed += 1; } }
2649  std::stringstream ss;
2650  ss << "Smoothening has resolved in " << noPassed << " C symmetries.";
2651  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, ss.str() );
2652  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Starting FSC computation to confirm the C symmetries existence." );
2653 
2654  //================================================ Decide if I is the answer
2655  bool alreadyDecided = false;
2656  if ( ISym->size() == 31 )
2657  {
2658  //============================================ Initialise decision vars
2659  proshade_double fscVal = 0.0;
2660  proshade_double fscValAvg = 0.0;
2661 
2662  //============================================ Check if at least one C5 and one C3 with the correct angle have high FSC and peak height
2663  for ( size_t iIt = 0; iIt < 31; iIt++ ) { if ( CSym->at(settings->allDetectedIAxes.at(iIt))[5] > bestHistPeakStart ) { fscVal = this->computeFSC ( settings, CSym, settings->allDetectedIAxes.at(iIt), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts ); fscValAvg += fscVal; } }
2664  fscValAvg /= 31.0;
2665 
2666  //============================================ If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2667  if ( fscValAvg >= ( settings->fscThreshold * 0.85 ) )
2668  {
2669  //======================================== The decision is I
2670  settings->setRecommendedSymmetry ( "I" );
2671  settings->setRecommendedFold ( 0 );
2672  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)) ); }
2673  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)) ); } }
2674 
2675  //======================================== Done
2676  alreadyDecided = true;
2677  }
2678  }
2679 
2680  //================================================ Decide if O is the answer
2681  if ( ( OSym->size() == 13 ) && !alreadyDecided )
2682  {
2683  //============================================ Initialise decision vars
2684  proshade_double fscVal = 0.0;
2685  proshade_double fscValAvg = 0.0;
2686 
2687  //============================================ Check if at least one C5 and one C3 with the correct angle have high FSC and peak height
2688  for ( size_t oIt = 0; oIt < 13; oIt++ ) { if ( CSym->at(settings->allDetectedOAxes.at(oIt))[5] > bestHistPeakStart ) { fscVal = this->computeFSC ( settings, CSym, settings->allDetectedOAxes.at(oIt), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts ); fscValAvg += fscVal; } }
2689  fscValAvg /= 13.0;
2690 
2691  //============================================ If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2692  if ( fscValAvg >= ( settings->fscThreshold * 0.85 ) )
2693  {
2694  //======================================== The decision is O
2695  settings->setRecommendedSymmetry ( "O" );
2696  settings->setRecommendedFold ( 0 );
2697  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)) ); }
2698  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)) ); } }
2699 
2700  //======================================== Done
2701  alreadyDecided = true;
2702  }
2703  }
2704 
2705  //================================================ Decide if T is the answer
2706  if ( ( TSym->size() == 7 ) && !alreadyDecided )
2707  {
2708  //============================================ Initialise decision vars
2709  proshade_double fscVal = 0.0;
2710  proshade_double fscValAvg = 0.0;
2711 
2712  //============================================ Check if at least one C5 and one C3 with the correct angle have high FSC and peak height
2713  for ( size_t tIt = 0; tIt < 7; tIt++ ) { if ( CSym->at(settings->allDetectedTAxes.at(tIt))[5] > bestHistPeakStart ) { fscVal = this->computeFSC ( settings, CSym, settings->allDetectedTAxes.at(tIt), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts ); fscValAvg += fscVal; } }
2714  fscValAvg /= 7.0;
2715 
2716  //============================================ If C3 and C5 are found and have correct angle (must have if they are both in ISym)
2717  if ( fscValAvg >= ( settings->fscThreshold * 0.85 ) )
2718  {
2719  //======================================== The decision is T
2720  settings->setRecommendedSymmetry ( "T" );
2721  settings->setRecommendedFold ( 0 );
2722  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)) ); }
2723  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)) ); } }
2724 
2725  //======================================== Done
2726  alreadyDecided = true;
2727  }
2728  }
2729 
2730  //================================================ Decide if D is the answer
2731  if ( ( settings->allDetectedDAxes.size() > 0 ) && ( DSym->size() > 0 ) && !alreadyDecided )
2732  {
2733  //============================================ Initialise decision vars
2734  proshade_signed bestD = -1;
2735  proshade_unsign bestFold = 0;
2736 
2737  //============================================ Find FSCs
2738  for ( size_t dIt = 0; dIt < settings->allDetectedDAxes.size(); dIt++ )
2739  {
2740  //======================================== Do not consider more than top 20, takes time and is unlikely to produce anything...
2741  if ( dIt > 20 ) { continue; }
2742 
2743  //======================================== Check the peak heights
2744  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 ) );
2745  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[5] < bestHistPeakStart ) && !( lhs999a.AlmostEquals( rhs999 ) ) ) { continue; }
2746  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[5] < bestHistPeakStart ) && !( lhs999b.AlmostEquals( rhs999 ) ) ) { continue; }
2747 
2748  //======================================== Find FSCs
2749  this->computeFSC ( settings, CSym, settings->allDetectedDAxes.at(dIt).at(0), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2750  this->computeFSC ( settings, CSym, settings->allDetectedDAxes.at(dIt).at(1), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2751  }
2752 
2753  //============================================ Find FSC top group threshold
2754  proshade_double bestHistFSCStart = this->findTopGroupSmooth ( CSym, 6, step, sigma, windowSize );
2755 
2756  //============================================ Check if both C symmetries are reliable
2757  for ( size_t dIt = 0; dIt < settings->allDetectedDAxes.size(); dIt++ )
2758  {
2759  //======================================== Check the peak heights
2760  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 ) );
2761  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[5] < bestHistPeakStart ) && !( lhs999a2.AlmostEquals( rhs999 ) ) ) { continue; }
2762  if ( ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[5] < bestHistPeakStart ) && !( lhs999b2.AlmostEquals( rhs999 ) ) ) { continue; }
2763 
2764  //======================================== Does this improve the best fold?
2765  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 ) ) )
2766  {
2767  //==================================== Check the FSC vals
2768  if ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[6] < settings->fscThreshold ) { continue; }
2769  if ( CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[6] < settings->fscThreshold ) { continue; }
2770  if ( std::max ( CSym->at(settings->allDetectedDAxes.at(dIt).at(0))[6], CSym->at(settings->allDetectedDAxes.at(dIt).at(1))[6] ) < bestHistFSCStart ) { continue; }
2771 
2772  //==================================== All good!
2773  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] ) );
2774  bestD = static_cast< proshade_signed > ( dIt );
2775  }
2776  }
2777 
2778  //============================================ Anything?
2779  if ( bestD != -1 )
2780  {
2781  //======================================== The decision is D
2782  settings->setRecommendedSymmetry ( "D" );
2783  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] ) ) );
2784  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(0)) );
2785  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(1)) );
2786  if ( settings->detectedSymmetry.size() == 0 )
2787  {
2788  settings->setDetectedSymmetry ( CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(0)) );
2789  settings->setDetectedSymmetry ( CSym->at(settings->allDetectedDAxes.at( static_cast< size_t > ( bestD ) ).at(1)) );
2790  }
2791 
2792  //======================================== Done
2793  alreadyDecided = true;
2794  }
2795  }
2796 
2797  //================================================ Decide if C is the answer
2798  if ( ( CSym->size() > 0 ) && !alreadyDecided )
2799  {
2800  //============================================ Initialise decision vars
2801  proshade_signed bestC = -1;
2802  proshade_unsign bestFold = 0;
2803 
2804  //============================================ Find FSCs for C syms
2805  for ( size_t cIt = 0; cIt < CSym->size(); cIt++ )
2806  {
2807  //======================================== Do not consider more than top 20, takes time and is unlikely to produce anything...
2808  if ( cIt > 20 ) { continue; }
2809 
2810  //======================================== Check the peak height
2811  if ( CSym->at(cIt)[5] < bestHistPeakStart ) { continue; }
2812 
2813  //======================================== Compute FSC
2814  this->computeFSC ( settings, CSym, cIt, mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2815  }
2816 
2817  //============================================ Find FSC top group threshold
2818  proshade_double bestHistFSCStart = this->findTopGroupSmooth ( CSym, 6, step, sigma, windowSize );
2819 
2820  //============================================ Find reliable C syms
2821  for ( size_t cIt = 0; cIt < CSym->size(); cIt++ )
2822  {
2823  //======================================== Check if this improves the best already found fold
2824  if ( CSym->at(cIt)[0] > static_cast< proshade_double > ( bestFold ) )
2825  {
2826  //==================================== If FSC passes
2827  if ( ( CSym->at(cIt)[6] > settings->fscThreshold ) && ( CSym->at(cIt)[6] >= bestHistFSCStart ) )
2828  {
2829  bestFold = static_cast< proshade_unsign > ( CSym->at(cIt)[0] );
2830  bestC = static_cast< proshade_signed > ( cIt );
2831  }
2832  }
2833  }
2834 
2835  //============================================ Anything?
2836  if ( bestC != -1 )
2837  {
2838  //======================================== The decision is C
2839  settings->setRecommendedSymmetry ( "C" );
2840  settings->setRecommendedFold ( static_cast< proshade_unsign > ( CSym->at( static_cast< size_t > ( bestC ) )[0] ) );
2841  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at( static_cast< size_t > ( bestC ) ) );
2842  if ( settings->detectedSymmetry.size() == 0 ) { settings->setDetectedSymmetry ( CSym->at( static_cast< size_t > ( bestC ) ) ); }
2843 
2844  //======================================== Done
2845  alreadyDecided = true;
2846  }
2847  }
2848 
2849  //================================================ Done
2850  return ;
2851 
2852 }

◆ 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 2865 of file ProSHADE_data.cpp.

2866 {
2867  //================================================ Initialise variables
2868  proshade_unsign bestIndex = 0;
2869  proshade_double highestSym = 0.0;
2870 
2871  //================================================ Search for best fold
2872  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( CSym->size() ); iter++ )
2873  {
2874  //============================================ Check if it is tbe correct fold
2875  const FloatingPoint< proshade_double > lhs1 ( CSym->at(iter)[0] ), rhs1 ( static_cast< proshade_double > ( settings->requestedSymmetryFold ) );
2876  if ( !lhs1.AlmostEquals ( rhs1 ) ) { continue; }
2877 
2878  //============================================ If correct, is it the highest found?
2879  if ( CSym->at(iter)[5] > highestSym )
2880  {
2881  highestSym = CSym->at(iter)[5];
2882  bestIndex = iter;
2883  }
2884  }
2885 
2886  //================================================ Found?
2887  if ( highestSym > 0.0 )
2888  {
2889  settings->setRecommendedSymmetry ( "C" );
2890  settings->setRecommendedFold ( static_cast< proshade_unsign > ( CSym->at(bestIndex)[0] ) );
2891  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, CSym->at(bestIndex) );
2892 
2893  if ( settings->detectedSymmetry.size() == 0 ) { settings->setDetectedSymmetry ( CSym->at(bestIndex) ); }
2894  }
2895  else
2896  {
2897  settings->setRecommendedSymmetry ( "" );
2898  settings->setRecommendedFold ( 0 );
2899  }
2900 
2901  //================================================ Done
2902  return ;
2903 
2904 }

◆ 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 
)

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 2917 of file ProSHADE_data.cpp.

2918 {
2919  //================================================ Initialise variables
2920  proshade_unsign bestIndex = 0;
2921  proshade_double highestSym = 0.0;
2922 
2923  //================================================ Search for best fold
2924  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( DSym->size() ); iter++ )
2925  {
2926  //============================================ Check if it is tbe correct fold
2927  const FloatingPoint< proshade_double > lhs1 ( std::max ( DSym->at(iter)[0], DSym->at(iter)[7] ) ), rhs1 ( static_cast< proshade_double > ( settings->requestedSymmetryFold ) );
2928  if ( !lhs1.AlmostEquals ( rhs1 ) ) { continue; }
2929 
2930  //============================================ Check if peak height is decent
2931  const FloatingPoint< proshade_double > lhs999a ( DSym->at(iter)[5] ), lhs999b ( DSym->at(iter)[12] ), rhs999 ( static_cast< proshade_double > ( -999.9 ) );
2932  if ( ( DSym->at(iter)[5] < settings->peakThresholdMin ) && !( lhs999a.AlmostEquals( rhs999 ) ) ) { continue; }
2933  if ( ( DSym->at(iter)[12] < settings->peakThresholdMin ) && !( lhs999b.AlmostEquals( rhs999 ) ) ) { continue; }
2934 
2935  //============================================ If correct, compute FSC
2936  this->computeFSC ( settings, &DSym->at(iter)[0], mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2937  this->computeFSC ( settings, &DSym->at(iter)[7], mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2938 
2939  //============================================ If best, store it
2940  if ( ( DSym->at(iter)[6] + DSym->at(iter)[13] ) > highestSym )
2941  {
2942  highestSym = ( DSym->at(iter)[6] + DSym->at(iter)[13] );
2943  bestIndex = iter;
2944  }
2945  }
2946 
2947  //================================================ Found?
2948  if ( highestSym > 0.0 )
2949  {
2950  settings->setRecommendedSymmetry ( "D" );
2951  settings->setRecommendedFold ( static_cast< proshade_unsign > ( std::max ( DSym->at(bestIndex)[0], DSym->at(bestIndex)[7] ) ) );
2952  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, &DSym->at(bestIndex)[0] );
2953  ProSHADE_internal_misc::deepCopyAxisToDblPtrVector ( axes, &DSym->at(bestIndex)[7] );
2954 
2955  if ( settings->detectedSymmetry.size() == 0 )
2956  {
2957  settings->setDetectedSymmetry ( &DSym->at(bestIndex)[0] );
2958  settings->setDetectedSymmetry ( &DSym->at(bestIndex)[7] );
2959  }
2960  }
2961  else
2962  {
2963  settings->setRecommendedSymmetry ( "" );
2964  settings->setRecommendedFold ( 0 );
2965  }
2966 
2967  //================================================ Done
2968  return ;
2969 
2970 }

◆ 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 4128 of file ProSHADE_data.cpp.

4129 {
4130  //================================================ Mutate
4131  this->eMatrices[band][order1][order2][0] = val[0];
4132  this->eMatrices[band][order1][order2][1] = val[1];
4133 
4134  //================================================ Done
4135  return ;
4136 
4137 }

◆ 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 4097 of file ProSHADE_data.cpp.

4098 {
4099  //================================================ Mutate
4100  this->integrationWeight = intW;
4101 
4102  //================================================ Done
4103  return ;
4104 
4105 }

◆ 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 4111 of file ProSHADE_data.cpp.

4112 {
4113  //================================================ Mutate
4114  this->integrationWeight += intW;
4115 
4116  //================================================ Done
4117  return ;
4118 
4119 }

◆ 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 880 of file ProSHADE_data.cpp.

881 {
882  //================================================ Set starts to 0
883  this->xFrom = 0;
884  this->yFrom = 0;
885  this->zFrom = 0;
886 
887  //================================================ Set angles to 90 degrees
888  this->aAngle = 90.0;
889  this->bAngle = 90.0;
890  this->cAngle = 90.0;
891 
892  //================================================ Set dimension sizes in indices
893  this->xDimIndices = static_cast< proshade_unsign > ( this->xTo );
894  this->yDimIndices = static_cast< proshade_unsign > ( this->yTo );
895  this->zDimIndices = static_cast< proshade_unsign > ( this->zTo );
896 
897  //================================================ Set the to indices properly
898  this->xTo -= 1;
899  this->yTo -= 1;
900  this->zTo -= 1;
901 
902  //================================================ Set grid indexing to cell indexing
903  this->xGridIndices = this->xDimIndices;
904  this->yGridIndices = this->yDimIndices;
905  this->zGridIndices = this->zDimIndices;
906 
907  //================================================ Set axis order
908  this->xAxisOrder = 1;
909  this->yAxisOrder = 2;
910  this->zAxisOrder = 3;
911 
912  //================================================ Set origin to the first index
913  this->xAxisOrigin = this->xFrom;
914  this->yAxisOrigin = this->yFrom;
915  this->zAxisOrigin = this->zFrom;
916 
917  //================================================ Done
918  return ;
919 
920 }

◆ 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 4162 of file ProSHADE_data.cpp.

4163 {
4164  //================================================ Mutate
4165  this->so3Coeffs[position][0] = val[0];
4166  this->so3Coeffs[position][1] = val[1];
4167 
4168  //================================================ Done
4169  return ;
4170 
4171 }

◆ 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 4180 of file ProSHADE_data.cpp.

4181 {
4182  //================================================ Mutate
4183  this->wignerMatrices[band][order1][order2][0] = val[0];
4184  this->wignerMatrices[band][order1][order2][1] = val[1];
4185 
4186  //================================================ Done
4187  return ;
4188 
4189 }

◆ 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 3656 of file ProSHADE_data.cpp.

3657 {
3658  if ( this->spheres[shell]->getLocalBandwidth( ) >= bandVal )
3659  {
3660  return ( true );
3661  }
3662  else
3663  {
3664  return ( false );
3665  }
3666 }

◆ 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 4276 of file ProSHADE_data.cpp.

4277 {
4278  //================================================ Return the value
4279  return ( static_cast<int> ( so3CoefLoc ( static_cast< int > ( order1 ), static_cast< int > ( order2 ), static_cast< int > ( band ), static_cast< int > ( this->getMaxBand() ) ) ) );
4280 }

◆ 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 1040 of file ProSHADE_overlay.cpp.

1041 {
1042  //================================================ Initialise local variables
1043  proshade_single xMov = static_cast< proshade_single > ( -trsX );
1044  proshade_single yMov = static_cast< proshade_single > ( -trsY );
1045  proshade_single zMov = static_cast< proshade_single > ( -trsZ );
1046 
1047  //================================================ Move the whole map frame to minimise the Fourier movement
1048  ProSHADE_internal_mapManip::moveMapByIndices ( &xMov, &yMov, &zMov, this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
1049  this->getXFromPtr(), this->getXToPtr(), this->getYFromPtr(), this->getYToPtr(),
1050  this->getZFromPtr(), this->getZToPtr(), this->getXAxisOrigin(), this->getYAxisOrigin(), this->getZAxisOrigin() );
1051 
1052  //================================================ Finalise the movement by in-frame Fourier movement
1053  ProSHADE_internal_mapManip::moveMapByFourier ( this->getInternalMap(), xMov, yMov, zMov, this->getXDimSize(), this->getYDimSize(), this->getZDimSize(),
1054  static_cast< proshade_signed > ( this->getXDim() ), static_cast< proshade_signed > ( this->getYDim() ),
1055  static_cast< proshade_signed > ( this->getZDim() ) );
1056 
1057  //================================================ Done
1058  return ;
1059 
1060 }

◆ 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 948 of file ProSHADE_data.cpp.

949 {
950  //================================================ Create and prepare new Grid gemmi object
951  gemmi::Grid<float> mapData;
952  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 ) );
953  mapData.set_size_without_checking ( static_cast< int > ( this->xDimIndices ), static_cast< int > ( this->yDimIndices ), static_cast< int > ( this->zDimIndices ) );
954  mapData.axis_order = gemmi::AxisOrder::XYZ;
955  mapData.spacegroup = &gemmi::get_spacegroup_p1();
956 
957  //================================================ Create and prepare new Ccp4 gemmi object
958  gemmi::Ccp4<float> map;
959  map.grid = mapData;
960  map.update_ccp4_header ( mode );
961 
962  //================================================ Fill in the header
964  this->xDimIndices, this->yDimIndices, this->zDimIndices,
965  this->xDimSize, this->yDimSize, this->zDimSize,
966  this->aAngle, this->bAngle, this->cAngle,
967  this->xFrom, this->yFrom, this->zFrom,
968  this->xAxisOrigin, this->yAxisOrigin, this->zAxisOrigin,
969  this->xAxisOrder, this->yAxisOrder, this->zAxisOrder,
970  this->xGridIndices, this->yGridIndices, this->zGridIndices,
971  title, mode );
972 
973  //================================================ Copy internal map to grid
974  proshade_unsign arrPos = 0;
975  for ( proshade_unsign uIt = 0; uIt < this->xDimIndices; uIt++ )
976  {
977  for ( proshade_unsign vIt = 0; vIt < this->yDimIndices; vIt++ )
978  {
979  for ( proshade_unsign wIt = 0; wIt < this->zDimIndices; wIt++ )
980  {
981  arrPos = wIt + this->zDimIndices * ( vIt + this->yDimIndices * uIt );
982  map.grid.set_value ( static_cast< int > ( uIt ), static_cast< int > ( vIt ), static_cast< int > ( wIt ), static_cast<float> ( this->internalMap[arrPos] ) );
983  }
984  }
985  }
986 
987  //================================================ Update the statistics in the header
988  map.update_ccp4_header ( mode, true );
989 
990  //================================================ Write out the map
991  map.write_ccp4_map ( fName );
992 
993  //================================================ Done
994  return ;
995 
996 }

◆ 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 1064 of file ProSHADE_data.cpp.

1065 {
1066  //================================================ Allocate the memory
1067  proshade_double* hlpMap = new proshade_double[this->xDimIndices * this->yDimIndices * this->zDimIndices];
1068  ProSHADE_internal_misc::checkMemoryAllocation ( hlpMap, __FILE__, __LINE__, __func__ );
1069 
1070  //================================================ Copy original map and over-write with the mask
1071  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1072  {
1073  hlpMap[iter] = this->internalMap[iter];
1074  this->internalMap[iter] = mask[iter];
1075  }
1076 
1077  //================================================ Write out the mask
1078  this->writeMap ( fName );
1079 
1080  //================================================ Copy the original map values back
1081  for ( proshade_unsign iter = 0; iter < ( this->xDimIndices * this->yDimIndices * this->zDimIndices ); iter++ )
1082  {
1083  this->internalMap[iter] = hlpMap[iter];
1084  }
1085 
1086  //================================================ Release memory
1087  delete[] hlpMap;
1088 
1089  //================================================ Done
1090  return ;
1091 }

◆ 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 4488 of file ProSHADE_data.cpp.

4489 {
4490  //================================================ Write out rotated map
4491  std::stringstream fNameHlp;
4492  fNameHlp << settings->overlayStructureName << ".map";
4493  this->writeMap ( fNameHlp.str() );
4494 
4495  //================================================ Write out rotated co-ordinates if possible
4496  if ( ProSHADE_internal_io::isFilePDB ( this->fileName ) )
4497  {
4498  fNameHlp.str("");
4499  fNameHlp << settings->overlayStructureName << ".pdb";
4500  this->writePdb ( fNameHlp.str(), eulA, eulB, eulG, ultimateTranslation->at(0), ultimateTranslation->at(1), ultimateTranslation->at(2), settings->firstModelOnly );
4501  }
4502 
4503  //================================================ Write out the json file with the results
4504  ProSHADE_internal_io::writeRotationTranslationJSON ( rotCentre->at(0), rotCentre->at(1), rotCentre->at(2),
4505  eulA, eulB, eulG,
4506  ultimateTranslation->at(0), ultimateTranslation->at(1), ultimateTranslation->at(2),
4507  settings->rotTrsJSONFile );
4508 
4509  //================================================ Done
4510  return ;
4511 
4512 }

◆ 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,
bool  firstModel = true 
)

This function writes out the PDB formatted file coresponding to the structure so that its COM is at specific position.

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, rotate and translate them according to the arguments and then write the resulting co-ordinates into a new file.

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]firstModelShould only the first model, or rather all of them be used?

Definition at line 1013 of file ProSHADE_data.cpp.

1014 {
1015  //================================================ Check for co-ordinate origin
1016  if ( !ProSHADE_internal_io::isFilePDB ( this->fileName ) )
1017  {
1018  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." );
1019  }
1020 
1021  //================================================ Open PDB file for reading
1022  gemmi::Structure pdbFile = gemmi::read_structure ( gemmi::MaybeGzipped ( this->fileName ) );
1023 
1024  //================================================ If the map was rotated, do the same for the co-ordinates, making sure we take into account the rotation centre of the map
1025  if ( ( euA != 0.0 ) || ( euB != 0.0 ) || ( euG != 0.0 ) )
1026  {
1027  //============================================ Rotate the co-ordinates
1028  ProSHADE_internal_mapManip::rotatePDBCoordinates ( &pdbFile, euA, euB, euG, this->originalPdbRotCenX, this->originalPdbRotCenY, this->originalPdbRotCenZ, firstModel );
1029  }
1030 
1031  //================================================ Translate by required translation and the map centering (if applied)
1032  ProSHADE_internal_mapManip::translatePDBCoordinates ( &pdbFile, trsX, trsY, trsZ, firstModel );
1033 
1034  //================================================ Write the PDB file
1035  std::ofstream outCoOrdFile;
1036  outCoOrdFile.open ( fName.c_str() );
1037 
1038  if ( outCoOrdFile.is_open() )
1039  {
1040  gemmi::PdbWriteOptions opt;
1041  write_pdb ( pdbFile, outCoOrdFile, opt );
1042  }
1043  else
1044  {
1045  std::stringstream hlpMessage;
1046  hlpMessage << "Failed to open the PDB file " << fName << " for output.";
1047  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." );
1048  }
1049 
1050  outCoOrdFile.close ( );
1051 
1052  //================================================ Done
1053  return ;
1054 }

◆ 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 618 of file ProSHADE_overlay.cpp.

619 {
620  //================================================ Sanity check
621  if ( ( this->xDimIndices > xDim ) || ( this->yDimIndices > yDim ) || ( this->zDimIndices > zDim ) )
622  {
623  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." );
624  }
625 
626  //================================================ If done, do nothing
627  if ( ( this->xDimIndices == xDim ) && ( this->yDimIndices == yDim ) && ( this->zDimIndices == zDim ) ) { return ; }
628 
629  //================================================ Find out how many zeroes need to be added before and after
630  proshade_unsign addXPre, addYPre, addZPre, addXPost, addYPost, addZPost;
631  ProSHADE_internal_overlay::computeBeforeAfterZeroCounts ( &addXPre, &addYPre, &addZPre, &addXPost, &addYPost, &addZPost, xDim, yDim, zDim, this->xDimIndices, this->yDimIndices, this->zDimIndices );
632 
633  //================================================ Create a new map
634  proshade_double* newMap = new proshade_double [xDim * yDim * zDim];
635 
636  //================================================ Do the hard work
637  ProSHADE_internal_overlay::paddMapWithZeroes ( this->internalMap, newMap, xDim, yDim, zDim, this->xDimIndices, this->yDimIndices, this->zDimIndices, addXPre, addYPre, addZPre );
638 
639  //================================================ Create a new internal map and copy
640  delete[] this->internalMap;
641  this->internalMap = new proshade_double [xDim * yDim * zDim];
642  for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( xDim * yDim * zDim ); iter++ ) { this->internalMap[iter] = newMap[iter]; }
643 
644  //================================================ Release memory
645  delete[] newMap;
646 
647  //================================================ Update map related variables
648  this->xDimSize = static_cast< proshade_single > ( xDim ) * ( this->xDimSize / static_cast< proshade_single > ( this->xDimIndices ) );
649  this->yDimSize = static_cast< proshade_single > ( yDim ) * ( this->yDimSize / static_cast< proshade_single > ( this->yDimIndices ) );
650  this->zDimSize = static_cast< proshade_single > ( zDim ) * ( this->zDimSize / static_cast< proshade_single > ( this->zDimIndices ) );
651  this->xDimIndices = xDim ; this->yDimIndices = yDim ; this->zDimIndices = zDim;
652  this->xGridIndices = xDim ; this->yGridIndices = yDim ; this->zGridIndices = zDim;
653  this->xFrom -= addXPre ; this->yFrom -= addYPre ; this->zFrom -= addZPre;
654  this->xTo += addXPost; this->yTo += addYPost; this->zTo += addZPost;
655  this->xAxisOrigin -= addXPre ; this->yAxisOrigin -= addYPre ; this->zAxisOrigin -= addZPre ;
656 
657  //================================================ Done
658  return ;
659 
660 }

The documentation for this class was generated from the following files:
ProSHADE_internal_data::ProSHADE_data::findTopGroupSmooth
proshade_double findTopGroupSmooth(std::vector< proshade_double * > *CSym, size_t peakPos, proshade_double step, proshade_double sigma, proshade_signed windowSize)
This function finds the distinct group of axes with highest peak heights.
Definition: ProSHADE_data.cpp:2332
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:115
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:3872
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:1139
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:125
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:1064
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_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:2268
ProSHADE_settings::rotTrsJSONFile
std::string rotTrsJSONFile
The filename to which the rotation and translation operations are to be saved into.
Definition: ProSHADE_settings.hpp:137
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:3929
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:444
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:296
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_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_double minPeakHeight)
This function takes the list of C symmetries and finds the fifteen C3 symmetries with correct angles ...
Definition: ProSHADE_symmetry.cpp:3510
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_misc::addToDblPtrVector
void addToDblPtrVector(std::vector< proshade_double * > *vecToAddTo, proshade_double *elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:143
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:131
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:3133
ProSHADE_internal_data::ProSHADE_data::xAxisOrder
proshade_unsign xAxisOrder
This is the order of the x axis.
Definition: ProSHADE_data.hpp:71
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:1612
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:3325
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:1286
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)
This function takes all the detected symmetry results and decides on which are to be recommended for ...
Definition: ProSHADE_data.cpp:2627
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:4306
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::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)
This function allocates the memory and makes all preparations required for FSC computation.
Definition: ProSHADE_data.cpp:2388
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:4029
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:2648
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:90
ProSHADE_internal_spheres::ProSHADE_rotFun_sphere
This class contains all inputed data for the rotation function angle-axis converted spheres.
Definition: ProSHADE_maths.hpp:54
ProSHADE_exception
This class is the representation of ProSHADE exception.
Definition: ProSHADE_exceptions.hpp:37
ProSHADE_internal_symmetry::saveAllCSymmetries
void saveAllCSymmetries(std::vector< std::vector< proshade_unsign > > detected, std::vector< proshade_double * > peaks, std::vector< proshade_double * > *ret, proshade_double axErr)
This function takes the detected symmetries indices and peaks and saves these in the main cyclic symm...
Definition: ProSHADE_symmetry.cpp:1133
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:4008
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:146
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:2286
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:128
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:127
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:3909
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:4059
ProSHADE_internal_peakSearch::getAllPeaksNaive
std::vector< proshade_double * > getAllPeaksNaive(proshade_complex *map, proshade_unsign dim, proshade_signed peakSize, proshade_double noIQRs)
This function finds peaks in the 3D map using the "naive" approach.
Definition: ProSHADE_peakSearch.cpp:316
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_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_double minPeakHeight)
This function takes the list of C symmetries and finds the four C3 symmetries with correct angles req...
Definition: ProSHADE_symmetry.cpp:2390
ProSHADE_internal_symmetry::printSymmetryCompletion
void printSymmetryCompletion(proshade_unsign noSyms, proshade_signed verbose)
This function simply prints the summary and warnings for cyclic symmetries detection completion.
Definition: ProSHADE_symmetry.cpp:1103
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:3919
ProSHADE_internal_symmetry::findPeaksByHeightBoundaries
std::vector< proshade_double > findPeaksByHeightBoundaries(std::vector< proshade_double * > allPeaks, proshade_double smoothing)
This function groups the peaks by height and returns the boundaries between such groups.
Definition: ProSHADE_symmetry.cpp:317
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:1032
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)
This function computes FSC for any given axis in the supplied CSym symmetry axes vector.
Definition: ProSHADE_data.cpp:2456
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:124
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:932
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:1294
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:811
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:102
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:573
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_settings::symMissPeakThres
proshade_double symMissPeakThres
Percentage of peaks that could be missing that would warrant starting the missing peaks search proced...
Definition: ProSHADE_settings.hpp:121
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:1655
ProSHADE_internal_data::ProSHADE_data::invertMirrorMap
void invertMirrorMap(ProSHADE_settings *settings)
Function for inverting the map to its mirror image.
Definition: ProSHADE_data.cpp:1101
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:1011
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:1299
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:3092
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:4079
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:677
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)
This function takes the D symmetries and searched for the requested symmetry.
Definition: ProSHADE_data.cpp:2917
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_internal_data::ProSHADE_data::computePdbRotationCentre
void computePdbRotationCentre(void)
This function computes the optimal rotation centre for co-ordinates.
Definition: ProSHADE_overlay.cpp:68
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:147
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:101
ProSHADE_internal_io::figureDataType
InputType figureDataType(std::string fName)
Function determining input data type.
Definition: ProSHADE_io.cpp:356
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:1175
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_internal_symmetry::findPeaksCSymmetry
std::vector< std::vector< proshade_unsign > > findPeaksCSymmetry(std::vector< proshade_double * > *peaks, proshade_signed verbose, proshade_unsign band, proshade_double missPeakThres, proshade_double axisErrTolerance, bool axisErrToleranceDef, ProSHADE_internal_data::ProSHADE_data *dataObj)
This function searches the list of peaks for presence of cyclic symmetry.
Definition: ProSHADE_symmetry.cpp:375
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:148
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:480
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:1438
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:3969
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:140
ProSHADE_internal_symmetry::printSymmetryGroup
void printSymmetryGroup(std::vector< proshade_unsign > grp, std::vector< proshade_double * > peaks, proshade_signed verbose)
This function simply prints the detected symmetry and all its supporting peaks.
Definition: ProSHADE_symmetry.cpp:1077
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_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::setPDBMapValues
void setPDBMapValues(void)
Function for determining iterator start and stop positions.
Definition: ProSHADE_data.cpp:880
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:3554
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:3939
ProSHADE_internal_mapManip::removeWaters
void removeWaters(gemmi::Structure *pdbFile, bool firstModel)
This function removed all waters from PDB input file.
Definition: ProSHADE_mapManip.cpp:504
ProSHADE_settings::useBiCubicInterpolationOnPeaks
bool useBiCubicInterpolationOnPeaks
This variable switch decides whether best symmetry is detected from peak indices, or whether bicubic ...
Definition: ProSHADE_settings.hpp:130
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::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:1064
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_internal_data::ProSHADE_data::saveRequestedSymmetryC
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.
Definition: ProSHADE_data.cpp:2865
ProSHADE_settings::peakThresholdMin
proshade_double peakThresholdMin
The threshold for peak height above which axes are considered possible.
Definition: ProSHADE_settings.hpp:133
ProSHADE_internal_peakSearch::findPeaks1D
std::vector< proshade_signed > findPeaks1D(std::vector< proshade_double > data)
This function simply finds all the peaks in a 1D data array.
Definition: ProSHADE_peakSearch.cpp:1014
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_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)
This function computes the FSC.
Definition: ProSHADE_maths.cpp:3090
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_data::ProSHADE_data::computeOptimalTranslation
void computeOptimalTranslation(proshade_double eulA, proshade_double eulB, proshade_double eulG, proshade_single trsX, proshade_single trsY, proshade_single trsZ)
This function computes and saves the optimal translation vector from the already determined translati...
Definition: ProSHADE_overlay.cpp:109
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:1777
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:1092
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_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_double minPeakHeight)
This function takes the list of C symmetries and finds the 3 C2 symmetries with correct angles requir...
Definition: ProSHADE_symmetry.cpp:2071
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_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:310
ProSHADE_settings::task
ProSHADE_Task task
This custom type variable determines which task to perfom (i.e. symmetry detection,...
Definition: ProSHADE_settings.hpp:40
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::zDimIndicesOriginal
proshade_unsign zDimIndicesOriginal
This is the size of the map cell z dimension in indices.
Definition: ProSHADE_data.hpp:87
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_double minPeakHeight)
This function takes the list of C symmetries and finds the six C2 symmetries with correct angles requ...
Definition: ProSHADE_symmetry.cpp:2472
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:1448
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:948
ProSHADE_internal_data::ProSHADE_data::getMaxBand
proshade_unsign getMaxBand(void)
This function returns the maximum band value for the object.
Definition: ProSHADE_data.cpp:3630
ProSHADE_settings::appliedMaskFileName
std::string appliedMaskFileName
The filename from which mask data will be read from.
Definition: ProSHADE_settings.hpp:86
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:1193
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:2960
ProSHADE_settings::normaliseMap
bool normaliseMap
Should the map be normalised to mean 0 sd 1?
Definition: ProSHADE_settings.hpp:72
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:99
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:3949
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_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:1202
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:1082
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_data::ProSHADE_data::getCyclicSymmetriesList
std::vector< proshade_double * > getCyclicSymmetriesList(ProSHADE_settings *settings)
This function obtains a list of all C symmetries from already computed self-rotation map.
Definition: ProSHADE_symmetry.cpp:198
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:132
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:2943
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:4253
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:4069
ProSHADE_settings::setRecommendedSymmetry
void setRecommendedSymmetry(std::string val)
Sets the ProSHADE detected symmetry type.
Definition: ProSHADE.cpp:1210
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_maths::smoothen1D
std::vector< proshade_double > smoothen1D(proshade_double step, proshade_signed windowSize, proshade_double sigma, std::vector< proshade_double > data)
This function takes a 1D vector and computes smoothened version based on the parameters.
Definition: ProSHADE_maths.cpp:2873
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:3959
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:1631
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:91
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, bool firstModel=true)
This function writes out the PDB formatted file coresponding to the structure so that its COM is at s...
Definition: ProSHADE_data.cpp:1013
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:1263
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:1147
ProSHADE_internal_overlay::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_overlay.cpp:578
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:398
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:3044
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_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_double minPeakHeight)
This function takes the list of C symmetries and finds the ten C3 symmetries with correct angles requ...
Definition: ProSHADE_symmetry.cpp:3438
ProSHADE_settings::overlayStructureName
std::string overlayStructureName
The filename to which the rotated and translated moving structure is to be saved.
Definition: ProSHADE_settings.hpp:136
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:2721
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:3620
ProSHADE_internal_data::ProSHADE_data::rotateMapRealSpace
void 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:816
ProSHADE_internal_maths::getAxisAngleFromRotationMatrix
void getAxisAngleFromRotationMatrix(proshade_double *rotMat, proshade_double *x, proshade_double *y, proshade_double *z, proshade_double *ang)
This function converts rotation matrix to the axis-angle representation.
Definition: ProSHADE_maths.cpp:1128
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:4009
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:96
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:114
ProSHADE_internal_data::ProSHADE_data::readInMAP
void readInMAP(ProSHADE_settings *settings)
Function for reading map data using gemmi library.
Definition: ProSHADE_data.cpp:554
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::getZAxisOrigin
proshade_signed * getZAxisOrigin(void)
This function allows access to the map Z axis origin value.
Definition: ProSHADE_data.cpp:4049
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:306
ProSHADE_settings::smoothingFactor
proshade_double smoothingFactor
This factor decides how small the group sizes should be - larger factor means more smaller groups.
Definition: ProSHADE_settings.hpp:118
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:1861
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:1916
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:1366
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:296
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:644
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:67
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:3999
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:3979
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:381
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:1380
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:926
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:441
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:2916
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:3857
ProSHADE_settings::allDetectedIAxes
std::vector< proshade_unsign > allDetectedIAxes
The vector of all detected icosahedral symmetry axes indices in allDetectedCAxes.
Definition: ProSHADE_settings.hpp:149
ProSHADE_settings::forceBounds
proshade_signed * forceBounds
These will be the boundaries to be forced upon the map.
Definition: ProSHADE_settings.hpp:93
ProSHADE_settings::detectedSymmetry
std::vector< proshade_double * > detectedSymmetry
The vector of detected symmetry axes.
Definition: ProSHADE_settings.hpp:144
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:126
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_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_double minPeakHeight)
This function takes the list of C symmetries and finds the 3 C4 symmetries with perpendicular angles ...
Definition: ProSHADE_symmetry.cpp:2324
ProSHADE_internal_data::ProSHADE_data::getIcosahedralSymmetriesList
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.
Definition: ProSHADE_symmetry.cpp:2799
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:1376
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:2082
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_double minPeakHeight)
This function takes the list of C symmetries and finds the 4 C3 symmetries with correct angles requir...
Definition: ProSHADE_symmetry.cpp:1535
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:2871
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:4039
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:3756
ProSHADE_internal_data::ProSHADE_data::getTetrahedralSymmetriesList
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.
Definition: ProSHADE_symmetry.cpp:1419
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::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:706
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_overlay::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_overlay.cpp:506
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:1914
ProSHADE_internal_symmetry::getPeaksAngleAxisPositions
std::vector< proshade_double * > getPeaksAngleAxisPositions(std::vector< proshade_double * > allPeaks, proshade_signed verbose)
This function converts peaks ZXZ Euler anles to angle-axis representation for further processing.
Definition: ProSHADE_symmetry.cpp:263
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:122
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:92
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:2980
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:1233
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_settings::setVariablesLeftOnAuto
void setVariablesLeftOnAuto(void)
Function to determine general values that the user left on auto-determination.
Definition: ProSHADE.cpp:333
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_double minPeakHeight)
This function takes the list of C symmetries and finds the six C5 symmetries with given angles requir...
Definition: ProSHADE_symmetry.cpp:3020
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:1155
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:3895
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:2802
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_data::ProSHADE_data::getOctahedralSymmetriesList
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.
Definition: ProSHADE_symmetry.cpp:2199
ProSHADE_internal_messages::printProgressMessage
void printProgressMessage(proshade_signed verbose, proshade_signed messageLevel, std::string message)
General stdout message printing.
Definition: ProSHADE_messages.cpp:70
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:382
ProSHADE_settings::allDetectedCAxes
std::vector< std::vector< proshade_double > > allDetectedCAxes
The vector of all detected cyclic symmetry axes.
Definition: ProSHADE_settings.hpp:145
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:3676
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:763
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_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:3142
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:1503
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:1485
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:725
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::getZFromPtr
proshade_signed * getZFromPtr(void)
This function allows access to the map start along the Z axis.
Definition: ProSHADE_data.cpp:3989
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:4019