 |
ProSHADE
0.7.6.1 (AUG 2021)
Protein Shape Detection
|
This class contains all inputed and derived data for a single structure.
More...
#include <ProSHADE_data.hpp>
|
| ProSHADE_data () |
| Constructor for getting empty ProSHADE_data class. More...
|
|
| ProSHADE_data (std::string strName, double *mapVals, int len, proshade_single xDmSz, proshade_single yDmSz, proshade_single zDmSz, proshade_unsign xDmInd, proshade_unsign yDmInd, proshade_unsign zDmInd, proshade_signed xFr, proshade_signed yFr, proshade_signed zFr, proshade_signed xT, proshade_signed yT, proshade_signed zT, proshade_unsign inputO) |
| Constructor for creating ProSHADE_data structure with data. More...
|
|
| ~ProSHADE_data (void) |
| Destructor for the ProSHADE_data class. More...
|
|
void | readInStructure (std::string fName, proshade_unsign inputO, ProSHADE_settings *settings, proshade_double *maskArr=nullptr, proshade_unsign maskXDim=0, proshade_unsign maskYDim=0, proshade_unsign maskZDim=0, proshade_double *weightsArr=nullptr, proshade_unsign weigXDim=0, proshade_unsign weigYDim=0, proshade_unsign weigZDim=0) |
| This function initialises the basic ProSHADE_data variables and reads in a single structure. More...
|
|
void | readInStructure (gemmi::Structure gemmiStruct, proshade_unsign inputO, ProSHADE_settings *settings) |
| This function initialises the basic ProSHADE_data variables and reads in a single structure from Gemmi co-ordinate object. More...
|
|
void | writeMap (std::string fName, std::string title="Created by ProSHADE and written by GEMMI", int mode=2) |
| Function for writing out the internal structure representation in MRC MAP format. More...
|
|
void | writePdb (std::string fName, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true) |
| This function writes out the co-ordinates file with ProSHADE type rotation and translation applied. More...
|
|
void | writeGemmi (std::string fName, gemmi::Structure gemmiStruct, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true) |
| This function writes out the gemmi::Structure object with ProSHADE type rotation and translation applied. More...
|
|
void | writeMask (std::string fName, proshade_double *mask) |
| Function for writing out a mask in MRC MAP format. More...
|
|
void | invertMirrorMap (ProSHADE_settings *settings) |
| Function for inverting the map to its mirror image. More...
|
|
void | normaliseMap (ProSHADE_settings *settings) |
| Function for normalising the map values to mean 0 and sd 1.. More...
|
|
void | maskMap (ProSHADE_settings *settings) |
| Function for computing the map mask using blurring and X IQRs from median. More...
|
|
void | getReBoxBoundaries (ProSHADE_settings *settings, proshade_signed *&ret) |
| This function finds the boundaries enclosing positive map values and adds some extra space. More...
|
|
void | createNewMapFromBounds (ProSHADE_settings *settings, ProSHADE_data *&newStr, proshade_signed *newBounds) |
| This function creates a new structure from the calling structure and new bounds values. More...
|
|
void | reSampleMap (ProSHADE_settings *settings) |
| This function changes the internal map sampling to conform to particular resolution value. More...
|
|
void | centreMapOnCOM (ProSHADE_settings *settings) |
| This function shits the map so that its COM is in the centre of the map. More...
|
|
void | addExtraSpace (ProSHADE_settings *settings) |
| This function increases the size of the map so that it can add empty space around it. More...
|
|
void | removePhaseInormation (ProSHADE_settings *settings) |
| This function removes phase from the map, effectively converting it to Patterson map. More...
|
|
void | 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 | 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) |
| This function gets the optimal translation vector and returns it as a standard library vector. It also applies the translation to the internal map. More...
|
|
void | zeroPaddToDims (proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim) |
| This function changes the size of a structure to fit the supplied new limits. More...
|
|
void | rotateMapReciprocalSpace (ProSHADE_settings *settings, proshade_double eulerAlpha, proshade_double eulerBeta, proshade_double eulerGamma) |
| This function rotates a map based on the given Euler angles. More...
|
|
std::vector< proshade_double > | rotateMapRealSpace (proshade_double axX, proshade_double axY, proshade_double axZ, proshade_double axAng, proshade_double *&map) |
| This function rotates a map based on the given angle-axis rotation. More...
|
|
std::vector< proshade_double > | rotateMapRealSpaceInPlace (proshade_double eulA, proshade_double eulB, proshade_double eulG) |
| This function rotates a map based on the given Euler angles in place. More...
|
|
void | translateMap (proshade_double trsX, proshade_double trsY, proshade_double trsZ) |
| This function simply translates the map by a given number of Angstroms along the three axes. More...
|
|
void | allocateRotatedSHMemory (void) |
| This function allocates the memory required for storing the rotated Spherical Harmonics coefficients.
|
|
void | computeRotatedSH (void) |
| This function multiplies the objects spherical harmonics with the Wigner D matrices, obtaining rotated spherical harmonics coefficients.
|
|
void | invertSHCoefficients (void) |
| This function computes the shell mapped data from inverting the Spherical Harmonics coefficients. More...
|
|
void | interpolateMapFromSpheres (proshade_double *&densityMapRotated) |
| This function interpolates the density map from the sphere mapped data. More...
|
|
void | computeTranslationMap (ProSHADE_internal_data::ProSHADE_data *obj1) |
| This function does the computation of the translation map and saves results internally. More...
|
|
void | findMapCOM (void) |
| This function finds the centre of mass of the internal map representation. More...
|
|
void | writeOutOverlayFiles (ProSHADE_settings *settings, proshade_double eulA, proshade_double eulB, proshade_double eulG, std::vector< proshade_double > *rotCentre, std::vector< proshade_double > *ultimateTranslation) |
| This function writes out the rotated map, co-ordinates and transformation JSON file. More...
|
|
void | reportOverlayResults (ProSHADE_settings *settings, std::vector< proshade_double > *rotationCentre, std::vector< proshade_double > *eulerAngles, std::vector< proshade_double > *finalTranslation) |
| This function reports the results of the overlay mode. More...
|
|
void | deepCopyMap (proshade_double *&saveTo, proshade_signed verbose) |
| This function copies the internal map into the supplied pointer, which it also allocates. More...
|
|
proshade_double | getMapValue (proshade_unsign pos) |
| This function returns the internal map representation value of a particular array position. More...
|
|
proshade_unsign | getMaxSpheres (void) |
| This function returns the number of spheres which contain the whole object. More...
|
|
proshade_unsign | getMaxBand (void) |
| This function returns the maximum band value for the object. More...
|
|
proshade_double * | getRealSphHarmValue (proshade_unsign band, proshade_unsign order, proshade_unsign shell) |
| This function allows access to the private internal real spherical harmonics values. More...
|
|
proshade_double * | getImagSphHarmValue (proshade_unsign band, proshade_unsign order, proshade_unsign shell) |
| This function allows access to the private internal imaginary spherical harmonics values. More...
|
|
proshade_double | getRRPValue (proshade_unsign band, proshade_unsign sh1, proshade_unsign sh2) |
| This function allows access to the priva internal RRP matrices. More...
|
|
proshade_double | getAnySphereRadius (proshade_unsign shell) |
| This function allows access to the radius of any particular sphere. More...
|
|
proshade_double | getIntegrationWeight (void) |
| This function allows access to the integration weight for the object. More...
|
|
proshade_unsign | getShellBandwidth (proshade_unsign shell) |
| This function allows access to the bandwidth of a particular shell. More...
|
|
proshade_single | getSpherePosValue (proshade_unsign shell) |
| This function allows access to sphere positions. More...
|
|
proshade_complex ** | getEMatrixByBand (proshade_unsign band) |
| This function allows access to E matrix for a particular band. More...
|
|
void | getEMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_double *valueReal, proshade_double *valueImag) |
| This function allows access to E matrix by knowing the band, order1 and order2 indices. More...
|
|
proshade_complex * | getInvSO3Coeffs (void) |
| This function allows access to the inverse SO(3) coefficients array. More...
|
|
proshade_complex * | getSO3Coeffs (void) |
| This function allows access to the SO(3) coefficients array. More...
|
|
proshade_unsign | getComparisonBand (void) |
| This function allows access to the maximum band for the comparison. More...
|
|
void | getWignerMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_double *valueReal, proshade_double *valueImag) |
| This function allows access to the Wigner D matrix by knowing the band, order1 and order2 indices. More...
|
|
proshade_single | getXDimSize (void) |
| This function allows access to the map size in angstroms along the X axis. More...
|
|
proshade_single | getYDimSize (void) |
| This function allows access to the map size in angstroms along the Y axis. More...
|
|
proshade_single | getZDimSize (void) |
| This function allows access to the map size in angstroms along the Z axis. More...
|
|
proshade_unsign | getXDim (void) |
| This function allows access to the map size in indices along the X axis. More...
|
|
proshade_unsign | getYDim (void) |
| This function allows access to the map size in indices along the Y axis. More...
|
|
proshade_unsign | getZDim (void) |
| This function allows access to the map size in indices along the Z axis. More...
|
|
proshade_signed * | getXFromPtr (void) |
| This function allows access to the map start along the X axis. More...
|
|
proshade_signed * | getYFromPtr (void) |
| This function allows access to the map start along the Y axis. More...
|
|
proshade_signed * | getZFromPtr (void) |
| This function allows access to the map start along the Z axis. More...
|
|
proshade_signed * | getXToPtr (void) |
| This function allows access to the map last position along the X axis. More...
|
|
proshade_signed * | getYToPtr (void) |
| This function allows access to the map last position along the Y axis. More...
|
|
proshade_signed * | getZToPtr (void) |
| This function allows access to the map last position along the Z axis. More...
|
|
proshade_signed * | getXAxisOrigin (void) |
| This function allows access to the map X axis origin value. More...
|
|
proshade_signed * | getYAxisOrigin (void) |
| This function allows access to the map Y axis origin value. More...
|
|
proshade_signed * | getZAxisOrigin (void) |
| This function allows access to the map Z axis origin value. More...
|
|
proshade_double *& | getInternalMap (void) |
| This function allows access to the first map array value address. More...
|
|
proshade_complex * | getTranslationFnPointer (void) |
| This function allows access to the translation function through a pointer. More...
|
|
std::vector< proshade_double > | getMapCOMProcessChange (void) |
| This function allows access to the translation caused by structure processing. More...
|
|
void | setIntegrationWeight (proshade_double intW) |
| This function allows setting the integration weight for the object. More...
|
|
void | setIntegrationWeightCumul (proshade_double intW) |
| This function allows setting the cumulative integration weight for the object. More...
|
|
void | setEMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_complex val) |
| This function allows setting the E matrix value. More...
|
|
void | normaliseEMatrixValue (proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_double normF) |
| This function allows normalising the E matrix value. More...
|
|
void | setSO3CoeffValue (proshade_unsign position, proshade_complex val) |
| This function allows setting the SOFT coefficient values using array position and value. More...
|
|
void | setWignerMatrixValue (proshade_complex val, proshade_unsign band, proshade_unsign order1, proshade_unsign order2) |
| This function allows setting the Wigner D matrix value by its band, order1 and order2 co-ordinate. More...
|
|
|
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.
|
|
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.
◆ 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] | settings | ProSHADE_settings object specifying what should be done. |
[out] | X | Empty data object with deault values. |
Definition at line 93 of file ProSHADE_data.cpp.
98 this->
fileType = ProSHADE_internal_io::UNKNOWN;
163 this->
spherePos = std::vector<proshade_single> ( );
◆ 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] | settings | ProSHADE_settings object specifying what should be done. |
[in] | strName | The name of the structure for reference. |
[in] | mapVals | A pointer to array where all the map data are. |
[in] | len | The length of this map values array. |
[in] | xDmSz | The size of the x-axis dimension in Angstroms. |
[in] | yDmSz | The size of the y-axis dimension in Angstroms. |
[in] | zDmSz | The size of the z-axis dimension in Angstroms. |
[in] | xDmInd | The size of the x-axis dimension in indices. |
[in] | yDmInd | The size of the y-axis dimension in indices. |
[in] | zDmInd | The size of the z-axis dimension in indices. |
[in] | xFr | The first index statting position along the x-axis. |
[in] | yFr | The first index statting position along the y-axis. |
[in] | zFr | The first index statting position along the z-axis. |
[in] | xT | The last index end position along the x-axis. |
[in] | yT | The last index end position along the y-axis. |
[in] | zT | The last index end position along the z-axis. |
[in] | inputO | The input order for this structure. |
[out] | X | Empty data object with filled in values and map. |
Definition at line 214 of file ProSHADE_data.cpp.
219 this->
fileType = ProSHADE_internal_io::MAP;
284 this->
spherePos = std::vector<proshade_single> ( );
306 if (
static_cast<proshade_unsign
> ( len ) != ( xDmInd * yDmInd * zDmInd ) )
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." );
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 ) ) )
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." );
323 proshade_unsign arrPos = 0;
324 for ( proshade_unsign xIt = 0; xIt < this->
xDimIndices; xIt++ )
326 for ( proshade_unsign yIt = 0; yIt < this->
yDimIndices; yIt++ )
328 for ( proshade_unsign zIt = 0; zIt < this->
zDimIndices; zIt++ )
330 arrPos = zIt + this->zDimIndices * ( yIt + this->yDimIndices * xIt );
331 this->
internalMap[arrPos] =
static_cast<proshade_double
> ( mapVals[arrPos] );
◆ ~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
-
Definition at line 349 of file ProSHADE_data.cpp.
358 if ( this->
spheres !=
nullptr )
360 for ( proshade_unsign iter = 0; iter < this->
noSpheres; iter++ )
362 if ( this->
spheres[iter] !=
nullptr )
374 for ( proshade_unsign iter = 0; iter < this->
noSpheres; iter++ )
388 for ( proshade_unsign iter = 0; iter < this->
noSpheres; iter++ )
402 for ( proshade_unsign bwIt = 0; bwIt < this->
maxShellBand; bwIt++ )
406 for ( proshade_unsign shIt = 0; shIt < this->
noSpheres; shIt++ )
424 for ( proshade_unsign bandIter = 0; bandIter < this->
maxCompBand; bandIter++ )
426 if ( this->
eMatrices[bandIter] !=
nullptr )
428 for ( proshade_unsign band2Iter = 0; band2Iter < static_cast<proshade_unsign> ( ( bandIter * 2 ) + 1 ); band2Iter++ )
430 if ( this->
eMatrices[bandIter][band2Iter] !=
nullptr )
432 delete[] this->
eMatrices[bandIter][band2Iter];
456 for ( proshade_unsign bandIter = 1; bandIter < this->
maxCompBand; bandIter++ )
460 for ( proshade_unsign order1Iter = 0; order1Iter < ( (bandIter * 2) + 1 ); order1Iter++ )
480 if ( this->sphereMappedRotFun.size() > 0 )
482 for ( proshade_unsign spIt = 0; spIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); spIt++ )
484 delete this->sphereMappedRotFun.at(spIt);
◆ 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] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 1590 of file ProSHADE_data.cpp.
1593 std::stringstream hlpSS;
1594 hlpSS <<
"Adding extra " << settings->
addExtraSpace <<
" angstroms.";
1603 this->
xDimSize += 2 *
static_cast<proshade_single
> ( xAddIndices ) * this->
xDimSize /
static_cast<proshade_single
> ( this->
xDimIndices );
1604 this->
yDimSize += 2 *
static_cast<proshade_single
> ( yAddIndices ) * this->
yDimSize /
static_cast<proshade_single
> ( this->
yDimIndices );
1605 this->
zDimSize += 2 *
static_cast<proshade_single
> ( zAddIndices ) * this->
zDimSize /
static_cast<proshade_single
> ( this->
zDimIndices );
1619 this->
xFrom -= xAddIndices;
1620 this->
yFrom -= yAddIndices;
1621 this->
zFrom -= zAddIndices;
1623 this->
xTo += xAddIndices;
1624 this->
yTo += yAddIndices;
1625 this->
zTo += zAddIndices;
1638 proshade_unsign newMapIndex, oldMapIndex;
1639 for ( proshade_unsign xIt = 0; xIt < (this->
xDimIndices - xAddIndices); xIt++ )
1642 if ( xIt < xAddIndices ) {
continue; }
1644 for ( proshade_unsign yIt = 0; yIt < (this->
yDimIndices - yAddIndices); yIt++ )
1647 if ( yIt < yAddIndices ) {
continue; }
1649 for ( proshade_unsign zIt = 0; zIt < (this->
zDimIndices - zAddIndices); zIt++ )
1652 if ( zIt < zAddIndices ) {
continue; }
1656 oldMapIndex = (zIt - zAddIndices) + (this->
zDimIndices - ( 2 * zAddIndices ) ) * ( (yIt - yAddIndices) + (this->
yDimIndices - ( 2 * yAddIndices ) ) * (xIt - xAddIndices) );
1658 newMap[newMapIndex] = this->
internalMap[oldMapIndex];
◆ 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] | band | The minimal band of the comparison for which E matrices are computed. |
Definition at line 275 of file ProSHADE_distances.cpp.
284 for ( proshade_unsign bandIter = 0; bandIter < this->
maxCompBand; bandIter++ )
287 this->
eMatrices[bandIter] =
new proshade_complex* [
static_cast<proshade_unsign
> ( ( bandIter * 2 ) + 1 )];
290 for ( proshade_unsign band2Iter = 0; band2Iter < static_cast<proshade_unsign> ( ( bandIter * 2 ) + 1 ); band2Iter++ )
292 this->
eMatrices[bandIter][band2Iter] =
new proshade_complex [
static_cast<proshade_unsign
> ( ( bandIter * 2 ) + 1 )];
◆ 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.
37 for ( proshade_unsign bwIt = 0; bwIt < this->
maxShellBand; bwIt++ )
43 for ( proshade_unsign shIt = 0; shIt < this->
noSpheres; shIt++ )
◆ 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] | band | The bandwidth to which the computation will be done. |
Definition at line 675 of file ProSHADE_distances.cpp.
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 ) )];
◆ 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] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 1525 of file ProSHADE_data.cpp.
1531 proshade_double xCOM = 0.0;
1532 proshade_double yCOM = 0.0;
1533 proshade_double zCOM = 0.0;
1541 proshade_single xSampRate =
static_cast< proshade_single
> ( this->
xDimSize ) /
static_cast< proshade_single
> ( this->
xTo - this->
xFrom );
1542 proshade_single ySampRate =
static_cast< proshade_single
> ( this->
yDimSize ) /
static_cast< proshade_single
> ( this->
yTo - this->
yFrom );
1543 proshade_single zSampRate =
static_cast< proshade_single
> ( this->
zDimSize ) /
static_cast< proshade_single
> ( this->
zTo - this->
zFrom );
1546 xCOM /=
static_cast< proshade_double
> ( xSampRate );
1547 yCOM /=
static_cast< proshade_double
> ( ySampRate );
1548 zCOM /=
static_cast< proshade_double
> ( zSampRate );
1550 xCOM -=
static_cast< proshade_double
> ( this->
xFrom );
1551 yCOM -=
static_cast< proshade_double
> ( this->
yFrom );
1552 zCOM -=
static_cast< proshade_double
> ( this->
zFrom );
1555 proshade_double xDist = ( (
static_cast<proshade_double
> ( this->
xDimIndices ) / 2.0 ) - xCOM ) *
static_cast<proshade_double
> ( this->
xDimSize ) /
static_cast<proshade_double
> ( this->
xDimIndices );
1556 proshade_double yDist = ( (
static_cast<proshade_double
> ( this->
yDimIndices ) / 2.0 ) - yCOM ) *
static_cast<proshade_double
> ( this->
yDimSize ) /
static_cast<proshade_double
> ( this->
yDimIndices );
1557 proshade_double zDist = ( (
static_cast<proshade_double
> ( this->
zDimIndices ) / 2.0 ) - zCOM ) *
static_cast<proshade_double
> ( this->
zDimSize ) /
static_cast<proshade_double
> ( this->
zDimIndices );
1561 static_cast< proshade_single
> ( xDist ),
1562 static_cast< proshade_single
> ( yDist ),
1563 static_cast< proshade_single
> ( zDist ),
1565 static_cast< proshade_signed
> ( this->
xDimIndices ),
1566 static_cast< proshade_signed
> ( this->
yDimIndices ),
1567 static_cast< proshade_signed
> ( this->
zDimIndices ) );
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | sym | A single double array containing a single Cyclic symmetry entry in the ProSHADE format. |
[in] | mapData | FFTW complex array which will be the input for the Fourier transform done by the planForwardFourier plan. |
[in] | fCoeffs | FFTW complex array where the Fourier transform coefficients will be saved into by the planForwardFourier plan. |
[in] | origCoeffs | FFTW complex array holding already compute Fourier transform of the non-rotated map. |
[in] | planForwardFourier | A prepared FFTW3 plan for transforming the mapData onto fCoeffs. |
[in] | noBins | The number of bins as already pre-computed. |
[in] | binIndexing | A map of pre-computed bin assignments for each reflection in the format as outputted by FFTW. |
[in] | bindata | Pre-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] | binCounts | Pre-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] | fsc | The FSC value found for the first (smallest) rotated map along the symmetry axis and the original map. |
Definition at line 2510 of file ProSHADE_data.cpp.
2513 const FloatingPoint< proshade_double > lhs1 ( sym[6] ), rhs1 ( -1.0 );
2514 if ( !lhs1.AlmostEquals ( rhs1 ) ) {
return ( sym[6] ); }
2517 std::stringstream ss2;
2518 ss2 <<
"Computing FSC for symmetry C" << sym[0] <<
" ( " << sym[1] <<
" ; " << sym[2] <<
" ; " << sym[3] <<
" ) with peak height " << sym[5];
2522 proshade_double *rotMap;
2525 proshade_double averageFSC = 0.0;
2526 for ( proshade_double rotIter = 1.0; rotIter < sym[0]; rotIter += 1.0 )
2529 this->
rotateMapRealSpace ( sym[1], sym[2], sym[3], ( ( 2.0 * M_PI ) / sym[0] ) * rotIter, rotMap );
2532 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; }
2533 fftw_execute ( *planForwardFourier );
2536 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; } }
2537 for (
size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { binCounts[binIt] = 0; }
2547 averageFSC /= ( sym[0] - 1.0 );
2550 sym[6] = averageFSC;
2553 std::stringstream ss3;
2554 ss3 <<
"FSC value is " << averageFSC <<
" .";
2558 return ( averageFSC );
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | CSym | A vector of pointers to double arrays, each array being a single Cyclic symmetry entry. |
[in] | symIndex | The index of the symmetry axis in the CSym vector for which FSC should be computed. |
[in] | mapData | FFTW complex array which will be the input for the Fourier transform done by the planForwardFourier plan. |
[in] | fCoeffs | FFTW complex array where the Fourier transform coefficients will be saved into by the planForwardFourier plan. |
[in] | origCoeffs | FFTW complex array holding already compute Fourier transform of the non-rotated map. |
[in] | planForwardFourier | A prepared FFTW3 plan for transforming the mapData onto fCoeffs. |
[in] | noBins | The number of bins as already pre-computed. |
[in] | binIndexing | A map of pre-computed bin assignments for each reflection in the format as outputted by FFTW. |
[in] | bindata | Pre-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] | binCounts | Pre-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] | fsc | The FSC value found for the first (smallest) rotated map along the symmetry axis and the original map. |
Definition at line 2425 of file ProSHADE_data.cpp.
2428 if ( symIndex >= CSym->size() )
2430 std::cerr <<
"The supplied symmetry axes vector does not contain element number " << symIndex <<
". Returning FSC 0.0." << std::endl;
2435 const FloatingPoint< proshade_double > lhs1 ( CSym->at(symIndex)[6] ), rhs1 ( -1.0 );
2436 if ( !lhs1.AlmostEquals ( rhs1 ) ) {
return ( CSym->at(symIndex)[6] ); }
2439 std::stringstream ss2;
2440 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];
2444 proshade_double *rotMap;
2447 proshade_double averageFSC = 0.0;
2448 for ( proshade_double rotIter = 1.0; rotIter < CSym->at(symIndex)[0]; rotIter += 1.0 )
2451 this->
rotateMapRealSpace ( CSym->at(symIndex)[1], CSym->at(symIndex)[2], CSym->at(symIndex)[3], ( ( 2.0 * M_PI ) / CSym->at(symIndex)[0] ) * rotIter, rotMap );
2454 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; }
2455 fftw_execute ( *planForwardFourier );
2458 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; } }
2459 for (
size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) { binCounts[binIt] = 0; }
2469 averageFSC /= ( CSym->at(symIndex)[0] - 1.0 );
2472 CSym->at(symIndex)[6] = averageFSC;
2475 std::stringstream ss3;
2476 ss3 <<
"FSC value is " << averageFSC <<
" .";
2480 return ( averageFSC );
◆ 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] | settings | A pointer to settings class containing all the information required for map self-rotation function computation. |
Definition at line 41 of file ProSHADE_symmetry.cpp.
◆ 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] | settings | A pointer to settings class containing all the information required for the task. |
Definition at line 59 of file ProSHADE_distances.cpp.
68 proshade_double descValR = 0.0;
69 proshade_unsign arrPos1, arrPos2;
70 for ( proshade_unsign band = 0; band < this->
maxShellBand; band++ )
73 for ( proshade_unsign shell1 = 0; shell1 < this->
noSpheres; shell1++ )
78 for ( proshade_unsign shell2 = 0; shell2 < this->
noSpheres; shell2++ )
86 for ( proshade_unsign shell2 = 0; shell2 < this->
noSpheres; shell2++ )
89 if ( shell1 > shell2 ) {
continue; }
103 for ( proshade_unsign order = 0; order < static_cast< proshade_unsign > ( ( 2 * band ) + 1 ); order++ )
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() ) ) );
116 this->
rrpMatrices[band][shell1][shell2] = descValR;
117 this->
rrpMatrices[band][shell2][shell1] = descValR;
◆ 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] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 1843 of file ProSHADE_data.cpp.
1851 for ( proshade_unsign iter = 0; iter < this->
noSpheres; iter++ )
1858 for ( proshade_unsign iter = 0; iter < this->
noSpheres; iter++ )
1861 std::stringstream ss;
1862 ss <<
"Now decomposing sphere " << iter <<
". " <<
"( Band is: " << this->
spheres[iter]->
getLocalBandwidth() <<
").";
◆ computeTranslationMap()
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] | staticStructure | A pointer to the data class object of the other ( static ) structure. |
Definition at line 324 of file ProSHADE_overlay.cpp.
327 fftw_complex *tmpIn1 =
nullptr, *tmpOut1 =
nullptr, *tmpIn2 =
nullptr, *tmpOut2 =
nullptr, *resOut =
nullptr;
328 fftw_plan forwardFourierObj1, forwardFourierObj2, inverseFourierCombo;
329 proshade_unsign dimMult = staticStructure->
getXDim() * staticStructure->
getYDim() * staticStructure->
getZDim();
330 ProSHADE_internal_overlay::allocateTranslationFunctionMemory ( tmpIn1, tmpOut1, tmpIn2, tmpOut2, this->
translationMap, resOut, forwardFourierObj1, forwardFourierObj2, inverseFourierCombo, staticStructure->
getXDim(), staticStructure->
getYDim(), staticStructure->
getZDim() );
333 for ( proshade_unsign iter = 0; iter < dimMult; iter++ ) { tmpIn1[iter][0] = staticStructure->
getMapValue ( iter ); tmpIn1[iter][1] = 0.0; }
334 for ( proshade_unsign iter = 0; iter < dimMult; iter++ ) { tmpIn2[iter][0] = this->
getMapValue ( iter ); tmpIn2[iter][1] = 0.0; }
337 fftw_execute ( forwardFourierObj1 );
338 fftw_execute ( forwardFourierObj2 );
342 fftw_execute ( inverseFourierCombo );
◆ 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] | settings | A pointer to settings class containing all the information required for map self-rotation function computation. |
Definition at line 120 of file ProSHADE_symmetry.cpp.
126 proshade_double shellSpacing = ( 2.0 * M_PI ) /
static_cast<proshade_double
> ( this->
maxShellBand ) * 2.0;
127 std::vector< proshade_double > allPeakHeights;
130 for ( proshade_unsign spIt = 1; spIt < ( this->
maxShellBand * 2 ); spIt++ )
135 static_cast<proshade_double
> ( spIt ) * shellSpacing,
140 for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( sphereMappedRotFun.size() ); shIt++ )
143 std::stringstream hlpSS;
144 hlpSS <<
"Interpolating sphere " << shIt <<
" ( radius: " << this->sphereMappedRotFun.at(shIt)->getRadius() <<
" ).";
148 this->sphereMappedRotFun.at(shIt)->interpolateSphereValues ( this->
getInvSO3Coeffs ( ) );
156 for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); shIt++ )
158 this->sphereMappedRotFun.at(shIt)->findAllPeaks (
static_cast< proshade_signed
> ( settings->
peakNeighbours ), &allPeakHeights );
162 std::stringstream hlpSS;
163 hlpSS <<
"Detected " << allPeakHeights.size() <<
" peaks with any height.";
170 std::stringstream hlpSS2;
171 hlpSS2 <<
"From these peaks, decided the threshold will be " << peakThres <<
" peak height.";
175 for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); shIt++ )
177 this->sphereMappedRotFun.at(shIt)->removeSmallPeaks ( peakThres );
◆ 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] | settings | A pointer to settings class containing all the information required for reading in the map. |
[in] | newStr | A pointer reference to a new structure class which has all the same values except for the new bounds and adequately changed map. |
[in] | newBounds | A 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 1387 of file ProSHADE_data.cpp.
1393 newStr->fileName =
"N/A";
1394 newStr->fileType = ProSHADE_internal_io::MAP;
1397 newStr->xDimIndices =
static_cast< proshade_unsign
> ( newBounds[1] ) -
static_cast< proshade_unsign
> ( newBounds[0] ) + 1;
1398 newStr->yDimIndices =
static_cast< proshade_unsign
> ( newBounds[3] ) -
static_cast< proshade_unsign
> ( newBounds[2] ) + 1;
1399 newStr->zDimIndices =
static_cast< proshade_unsign
> ( newBounds[5] ) -
static_cast< proshade_unsign
> ( newBounds[4] ) + 1;
1401 newStr->aAngle = this->
aAngle;
1402 newStr->bAngle = this->
aAngle;
1403 newStr->cAngle = this->
aAngle;
1405 newStr->xDimSize =
static_cast<proshade_single
> ( newStr->xDimIndices ) * ( this->
xDimSize /
static_cast<proshade_single
> ( this->
xDimIndices ) );
1406 newStr->yDimSize =
static_cast<proshade_single
> ( newStr->yDimIndices ) * ( this->
yDimSize /
static_cast<proshade_single
> ( this->
yDimIndices ) );
1407 newStr->zDimSize =
static_cast<proshade_single
> ( newStr->zDimIndices ) * ( this->
zDimSize /
static_cast<proshade_single
> ( this->
zDimIndices ) );
1409 newStr->xGridIndices = newStr->xDimIndices;
1410 newStr->yGridIndices = newStr->yDimIndices;
1411 newStr->zGridIndices = newStr->zDimIndices;
1417 newStr->xAxisOrigin = this->
xAxisOrigin + newBounds[0];
1418 newStr->yAxisOrigin = this->
yAxisOrigin + newBounds[2];
1419 newStr->zAxisOrigin = this->
zAxisOrigin + newBounds[4];
1421 newStr->xFrom = this->
xFrom + newBounds[0];
1422 newStr->yFrom = this->
yFrom + newBounds[2];
1423 newStr->zFrom = this->
zFrom + newBounds[4];
1425 newStr->xTo = this->
xTo - (
static_cast< proshade_signed
> ( this->
xDimIndices - 1 ) - newBounds[1] );
1426 newStr->yTo = this->
yTo - (
static_cast< proshade_signed
> ( this->
yDimIndices - 1 ) - newBounds[3] );
1427 newStr->zTo = this->
zTo - (
static_cast< proshade_signed
> ( this->
zDimIndices - 1 ) - newBounds[5] );
1430 newStr->internalMap =
new proshade_double[newStr->xDimIndices * newStr->yDimIndices * newStr->zDimIndices];
1435 this->xFrom, this->yFrom, this->zFrom, newStr->yDimIndices, newStr->zDimIndices,
1436 this->xDimIndices, this->yDimIndices, this->zDimIndices, newStr->internalMap, this->internalMap );
◆ 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] | saveTo | A pointer where the internal map should be deep copied into. |
[in] | verbose | How loud the run should be? |
Definition at line 3435 of file ProSHADE_data.cpp.
3438 if ( saveTo !=
nullptr )
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | axes | A vector to which all the axes of the recommended symmetry (if any) will be saved. |
[in] | allCs | A vector to which all the detected cyclic symmetries will be saved into. |
Definition at line 1903 of file ProSHADE_data.cpp.
1906 if ( settings->axisErrToleranceDefault )
1908 settings->
axisErrTolerance = std::min ( std::max ( 0.01, ( 2.0 * M_PI ) /
static_cast< proshade_double
> ( this->
maxShellBand ) ), 0.05 );
1912 fftw_complex *mapData, *origCoeffs, *fCoeffs;
1913 fftw_plan planForwardFourier;
1914 proshade_double **bindata;
1915 proshade_signed *binIndexing, *binCounts, noBins;
1916 this->
prepareFSCFourierMemory ( mapData, origCoeffs, fCoeffs, binIndexing, &noBins, bindata, binCounts, &planForwardFourier );
1922 std::stringstream hlpSS;
1927 proshade_double symThres = 0.0;
1931 bool possible010PIIssue =
false;
1933 if ( possible010PIIssue )
1935 proshade_double* addAxis =
new proshade_double[7];
1936 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;
1942 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 ); } }
1949 if ( CSyms.size() > 0 )
1951 bool passedTests =
false;
1952 for (
size_t cIt = 0; cIt < CSyms.size(); cIt++ )
1981 delete[] origCoeffs;
1983 fftw_destroy_plan ( planForwardFourier );
1984 delete[] binIndexing;
1985 for (
size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) {
delete[] bindata[binIt]; }
2000 bool possible010PIIssue =
false;
2002 if ( possible010PIIssue )
2004 proshade_double* addAxis =
new proshade_double[7];
2005 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;
2010 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 ); } }
2013 std::stringstream ss;
2014 ss <<
"Detected " << CSyms.size() <<
" C symmetries.";
2018 if ( this->sphereMappedRotFun.size() < 1 )
2020 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." );
2026 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." );
2034 std::vector< proshade_double* > ISyms;
2039 proshade_double fscMax = 0.0;
2040 size_t fscMaxInd = 0;
2043 for (
size_t icoIt = 0; icoIt < ISymsHlp.size(); icoIt++ )
2046 if ( ISymsHlp.at(icoIt).size() != 31 ) {
continue; }
2049 proshade_double fscVal = 0.0;
2050 proshade_double fscValAvg = 0.0;
2053 for (
size_t aIt = 0; aIt < ISymsHlp.at(icoIt).size(); aIt++ )
2056 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 );
2059 fscVal = this->
computeFSC ( settings, &CSyms,
static_cast< size_t > ( matchedPos ), mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts );
2060 ISymsHlp.at(fscMaxInd).at(aIt)[6] = fscVal;
2061 fscValAvg += fscVal;
2068 if ( fscValAvg > fscMax )
2079 for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ISymsHlp.at(fscMaxInd).size() ); retIt++ )
2082 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 );
2091 this->
saveRecommendedSymmetry ( settings, &CSyms, &DSyms, &TSyms, &OSyms, &ISyms, axes, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts );
2098 this->
saveRequestedSymmetryD ( settings, &DSyms, axes, mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts );
2106 if ( TSyms.size() == 7 )
2109 proshade_double fscVal = 0.0;
2110 proshade_double fscValAvg = 0.0;
2113 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; } }
2133 if ( OSyms.size() == 13 )
2136 proshade_double fscVal = 0.0;
2137 proshade_double fscValAvg = 0.0;
2140 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; } }
2158 proshade_double fscMax = 0.0;
2159 size_t fscMaxInd = 0;
2161 std::vector< proshade_double* > ISyms;
2163 for (
size_t icoIt = 0; icoIt < ISymsHlp.size(); icoIt++ )
2166 if ( ISymsHlp.at(icoIt).size() != 31 ) {
continue; }
2169 proshade_double fscVal = 0.0;
2170 proshade_double fscValAvg = 0.0;
2173 for (
size_t aIt = 0; aIt < ISymsHlp.at(icoIt).size(); aIt++ )
2176 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 );
2179 fscVal = this->
computeFSC ( settings, &CSyms,
static_cast< size_t > ( matchedPos ), mapData, fCoeffs, origCoeffs, &planForwardFourier, noBins, binIndexing, bindata, binCounts );
2180 ISymsHlp.at(fscMaxInd).at(aIt)[6] = fscVal;
2181 fscValAvg += fscVal;
2188 if ( fscValAvg > fscMax )
2199 for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ISymsHlp.at(fscMaxInd).size() ); retIt++ )
2202 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 );
2211 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); } }
2229 delete[] origCoeffs;
2231 fftw_destroy_plan ( planForwardFourier );
2232 delete[] binIndexing;
2233 for (
size_t binIt = 0; binIt < static_cast< size_t > ( noBins ); binIt++ ) {
delete[] bindata[binIt]; }
◆ 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 983 of file ProSHADE_data.cpp.
◆ 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 3523 of file ProSHADE_data.cpp.
3529 proshade_double totNonZeroPoints = 0.0;
3530 proshade_signed mapIt = 0;
3533 for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->
xDimIndices ); xIt++ )
3535 for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->
yDimIndices ); yIt++ )
3537 for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->
zDimIndices ); zIt++ )
3540 mapIt = zIt +
static_cast< proshade_signed
> ( this->
zDimIndices ) * ( yIt +
static_cast< proshade_signed
> ( this->
yDimIndices ) * xIt );
3543 if ( this->
internalMap[mapIt] <= 0.0 ) {
continue; }
3554 this->
xCom /= totNonZeroPoints;
3555 this->
yCom /= totNonZeroPoints;
3556 this->
zCom /= totNonZeroPoints;
3560 ( (
static_cast< proshade_single
> ( this->
xCom ) -
static_cast< proshade_single
> ( this->
xFrom ) ) *
3563 ( (
static_cast< proshade_single
> ( this->
yCom ) -
static_cast< proshade_single
> ( this->
yFrom ) ) *
3566 ( (
static_cast< proshade_single
> ( this->
zCom ) -
static_cast< proshade_single
> ( this->
zFrom ) ) *
◆ 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] | settings | ProSHADE_settings object containing all the settings for this run. |
[in] | fold | The fold which should be sought for by the function. |
[in] | peakThres | The threshold used to cut peaks. |
[out] | ret | Vector of double pointers to arrays having the standard ProSHADE symmetry group structure. |
Definition at line 3895 of file ProSHADE_symmetry.cpp.
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;
3905 this->sphereMappedRotFun.clear();
3908 for ( proshade_double angIt = 1.0; angIt < static_cast<proshade_double> ( fold ); angIt += 1.0 )
3911 soughtAngle = angIt * ( 2.0 * M_PI /
static_cast<proshade_double
> ( fold ) );
3915 M_PI /
static_cast< proshade_double
> ( this->
maxShellBand ),
3918 static_cast<proshade_unsign
> ( angIt - 1.0 ) ) );
3921 this->sphereMappedRotFun.at(
static_cast<proshade_unsign
> ( angIt - 1.0 ))->interpolateSphereValues ( this->
getInvSO3Coeffs ( ) );
3924 this->sphereMappedRotFun.at(
static_cast<proshade_unsign
> ( angIt - 1.0 ))->findAllPeaks (
static_cast< proshade_signed
> ( settings->
peakNeighbours ), &allPeakHeights );
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.";
3936 std::stringstream hlpSS2;
3937 hlpSS2 <<
"Determined peak threshold " << *peakThres <<
".";
3941 for ( proshade_unsign shIt = 0; shIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); shIt++ )
3943 this->sphereMappedRotFun.at(shIt)->removeSmallPeaks ( *peakThres );
3947 for ( proshade_unsign sphIt = 0; sphIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.size() ); sphIt++ )
3950 for ( proshade_unsign pkIt = 0; pkIt < static_cast<proshade_unsign> ( this->sphereMappedRotFun.at(sphIt)->getPeaks().size() ); pkIt++ )
3954 for ( proshade_unsign pkGrpIt = 0; pkGrpIt < static_cast<proshade_unsign> ( peakGroups.size() ); pkGrpIt++ )
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 ),
3962 if ( !newPeak ) {
continue; }
3966 static_cast< proshade_double
> ( this->sphereMappedRotFun.at(sphIt)->getPeaks().at(pkIt).second ),
3968 this->sphereMappedRotFun.at(sphIt)->getAngularDim() ) );
3973 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( peakGroups.size() ); grIt++ )
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) <<
" ; "; }
3985 delete peakGroups.at(grIt);
◆ 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] | CSym | A vector of pointers to double arrays, each array being a single Cyclic symmetry entry. |
[in] | step | The granulosity of the interval <0,1> using which the search should be done. |
[in] | sigma | The variance of the Gaussian used to smoothen the peak height histogram. |
[in] | windowSize | The width of the window over which smoothening is done. |
[out] | threshold | The minimum peak height that an axis needs to have to be considered a member of the distinct top group. |
Definition at line 2301 of file ProSHADE_data.cpp.
2304 proshade_double threshold = 0.0;
2305 proshade_signed totSize =
static_cast< proshade_signed
> ( ( 1.0 / step ) + 1 );
2306 std::vector< std::pair < proshade_double, proshade_unsign > > vals;
2307 std::vector< proshade_double > hist (
static_cast< unsigned long int > ( totSize ), 0.0 );
2308 proshade_unsign histPos = 0;
2311 if ( windowSize % 2 == 0 ) { windowSize += 1; }
2314 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 ) ); }
2317 for ( proshade_double it = 0.0; it <= 1.0; it = it + step )
2319 for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( vals.size() ); symIt++ )
2322 if ( ( vals.at(symIt).first > it ) && ( vals.at(symIt).first <= ( it + step ) ) ) { hist.at(histPos) += 1.0; }
2336 proshade_signed bestHistPos;
2337 if ( peaks.size() > 0 ) { bestHistPos = peaks.at(peaks.size()-1) + ( ( windowSize - 1 ) / 2 ); }
2338 else { bestHistPos = 0.0; }
2340 threshold = (
static_cast< proshade_double
> ( bestHistPos ) * step ) - (
static_cast< proshade_double
> ( windowSize ) * step );
2343 return ( threshold );
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | axesList | A vector of ints specifying which C axes from the full list are members of the group. |
[in] | groupType | An 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] | matrixTolerance | The maximum allowed trace difference for two matrices to still be considered the same. |
[out] | val | A vector containing a vector of 9 doubles (rotation matrix) for each group element for the requested group. |
Definition at line 3168 of file ProSHADE_data.cpp.
3171 std::vector<std::vector< proshade_double > > ret;
3174 if ( groupType ==
"C" )
3183 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(0)).at(0) ) );
3189 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." );
3192 else if ( groupType ==
"D" )
3201 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(0)).at(0) ) );
3205 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(1)).at(0) ) );
3214 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." );
3217 else if ( groupType ==
"T" )
3223 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3226 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3227 if ( lhs1.AlmostEquals ( rhs1 ) )
3233 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3241 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3244 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3245 if ( lhs1.AlmostEquals ( rhs1 ) )
3251 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3262 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." );
3265 else if ( groupType ==
"O" )
3271 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3274 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 4.0 );
3275 if ( lhs1.AlmostEquals ( rhs1 ) )
3281 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3289 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3292 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3293 if ( lhs1.AlmostEquals ( rhs1 ) )
3299 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3307 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3310 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3311 if ( lhs1.AlmostEquals ( rhs1 ) )
3317 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3328 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." );
3331 else if ( groupType ==
"I" )
3337 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3340 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 5.0 );
3341 if ( lhs1.AlmostEquals ( rhs1 ) )
3347 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3355 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3358 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 3.0 );
3359 if ( lhs1.AlmostEquals ( rhs1 ) )
3365 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3373 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3376 const FloatingPoint< proshade_double > lhs1 ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ), rhs1 ( 2.0 );
3377 if ( lhs1.AlmostEquals ( rhs1 ) )
3383 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3394 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." );
3397 else if ( groupType ==
"X" )
3400 for ( proshade_unsign grIt = 0; grIt < static_cast<proshade_unsign> ( axesList.size() ); grIt++ )
3406 static_cast< proshade_signed
> ( settings->
allDetectedCAxes.at(axesList.at(grIt)).at(0) ) );
3416 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." );
3421 std::stringstream hlpSS;
3422 hlpSS <<
"Unknown symmetry type: >" << groupType <<
"<";
3423 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." );
◆ 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] | X | The distance of the requested sphere to the centre of the coordinates. |
Definition at line 3749 of file ProSHADE_data.cpp.
3752 return ( this->
spheres[shell]->getShellRadius() );
◆ 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] | settings | A pointer to settings class containing all the information required for map overlay. |
[out] | val | A vector of the Euler angles of the best peak in the rotation function map. |
Definition at line 1386 of file ProSHADE_overlay.cpp.
1389 std::vector < proshade_double > ret;
1390 proshade_double eulA, eulB, eulG;
1395 &eulA, &eulB, &eulG, settings );
◆ getBestTranslationMapPeaksAngstrom()
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] | staticStructure | A pointer to the data class object of the other ( static ) structure. |
[out] | X | A vector of doubles with the optimal translation vector in Angstroms. |
Definition at line 250 of file ProSHADE_overlay.cpp.
253 std::vector< proshade_double > ret;
254 proshade_double mapPeak = 0.0;
255 proshade_unsign xDimS = staticStructure->
getXDim();
256 proshade_unsign yDimS = staticStructure->
getYDim();
257 proshade_unsign zDimS = staticStructure->
getZDim();
258 proshade_double trsX = 0.0, trsY = 0.0, trsZ = 0.0;
269 if ( trsX > (
static_cast< proshade_double
> ( xDimS ) / 2.0 ) ) { trsX = trsX -
static_cast< proshade_double
> ( xDimS ); }
270 if ( trsY > (
static_cast< proshade_double
> ( yDimS ) / 2.0 ) ) { trsY = trsY -
static_cast< proshade_double
> ( yDimS ); }
271 if ( trsZ > (
static_cast< proshade_double
> ( zDimS ) / 2.0 ) ) { trsZ = trsZ -
static_cast< proshade_double
> ( zDimS ); }
280 proshade_single xMov =
static_cast< proshade_single
> ( -trsX );
281 proshade_single yMov =
static_cast< proshade_single
> ( -trsY );
282 proshade_single zMov =
static_cast< proshade_single
> ( -trsZ );
303 static_cast< proshade_signed
> ( this->
getXDim() ),
static_cast< proshade_signed
> ( this->
getYDim() ),
static_cast< proshade_signed
> ( this->
getZDim() ) );
◆ getComparisonBand()
proshade_unsign ProSHADE_internal_data::ProSHADE_data::getComparisonBand |
( |
void |
| ) |
|
This function allows access to the maximum band for the comparison.
- Parameters
-
[out] | X | The bandwidth used for this comparison. |
Definition at line 3848 of file ProSHADE_data.cpp.
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
Definition at line 198 of file ProSHADE_symmetry.cpp.
201 std::vector< proshade_double* > ret;
218 std::vector< std::vector< proshade_unsign > > detectedCSymmetries;
219 for ( proshade_signed iter =
static_cast< proshade_signed
> ( peakGroupsBoundaries.size() - 1 ); iter >= 0; iter-- )
222 std::vector< proshade_double* > symPeaks;
223 for ( proshade_unsign it = 0; it < static_cast<proshade_unsign> ( peaksAA.size() ); it++ )
233 settings->axisErrToleranceDefault,
244 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( peaksAA.size() ); iter++ ) {
delete[] allPeaks.at(iter);
delete[] peaksAA.at(iter); }
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[out] | ret | A 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.
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;
3767 for ( proshade_unsign prIt = 0; prIt < static_cast< proshade_unsign > ( primes.size() ); prIt++ )
3770 std::stringstream hlpSS;
3771 hlpSS <<
"Searching for prime fold symmetry C" << primes.at(prIt) <<
".";
3778 for (
size_t axIt = 0; axIt < prSyms.size(); axIt++ )
3781 if ( prSyms.at(axIt)[5] >= symThres )
3791 delete[] prSyms.at(axIt);
3796 if ( ret.size() < 1 ) {
return ( ret ); }
3799 while ( anyNewSyms )
3805 for ( proshade_unsign axIt1 = 0; axIt1 < static_cast< proshade_unsign > ( ret.size() ); axIt1++ )
3807 for ( proshade_unsign axIt2 = 0; axIt2 < static_cast< proshade_unsign > ( ret.size() ); axIt2++ )
3810 foldToTest =
static_cast< proshade_unsign
> ( ret.at(axIt1)[0] * ret.at(axIt2)[0] );
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; }
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 <<
".";
3828 for (
size_t newAxIt = 0; newAxIt < prSyms.size(); newAxIt++ )
3830 if ( prSyms.at(newAxIt)[5] >= symThres )
3840 delete[] prSyms.at(newAxIt);
3846 if ( tmpHolder.size() > 0 )
3848 for ( proshade_unsign tmpIt = 0; tmpIt < static_cast< proshade_unsign > ( tmpHolder.size() ); tmpIt++ )
3851 delete[] tmpHolder.at(tmpIt);
3855 tmpHolder.clear ( );
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[in] | CSymList | A vector containing the already detected Cyclic symmetries. |
Definition at line 1299 of file ProSHADE_symmetry.cpp.
1302 std::vector< proshade_double* > ret;
1303 proshade_double dotProduct;
1309 if ( CSymList->size() < 2 ) {
return ( ret ); }
1312 for ( proshade_unsign ax1 = 0; ax1 < static_cast<proshade_unsign> ( CSymList->size() ); ax1++ )
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; }
1318 for ( proshade_unsign ax2 = 1; ax2 < static_cast<proshade_unsign> ( CSymList->size() ); ax2++ )
1321 if ( ax1 >= ax2 ) {
continue; }
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; }
1329 &CSymList->at(ax1)[3], &CSymList->at(ax2)[1],
1330 &CSymList->at(ax2)[2], &CSymList->at(ax2)[3] );
1336 if ( CSymList->at(ax1)[0] >= CSymList->at(ax2)[0] )
1340 std::vector< proshade_unsign > DSymInd;
1350 std::vector< proshade_unsign > DSymInd;
1360 std::stringstream hlpSS;
1361 hlpSS <<
"Detected " << ret.size() <<
" D symmetries.";
◆ 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] | band | The band for which the E matrix subset order * order should be returned. |
[out] | X | Pointer to pointer of complex matrix with dimensions order * order of the E matrices. |
Definition at line 3796 of file ProSHADE_data.cpp.
◆ 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] | band | The band for which the E matrix value should be returned. |
[in] | order1 | The first order for which the E matrix value should be returned. |
[in] | order2 | The second order for which the E matrix value should be returned. |
[in] | valueReal | The proshade_double number pointer to where the real part of the value will be saved. |
[in] | valueImag | The proshade_double number pointer to where the imaginary part of the value will be saved. |
Definition at line 3811 of file ProSHADE_data.cpp.
3814 *valueReal = this->
eMatrices[band][order1][order2][0];
3815 *valueImag = this->
eMatrices[band][order1][order2][1];
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[in] | CSymList | A vector containing the already detected Cyclic symmetries. |
Definition at line 2799 of file ProSHADE_symmetry.cpp.
2802 std::vector< proshade_double* > ret;
2825 for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
2827 for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
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 ) )
◆ 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] | band | The band for which the imaginary E matrix values are requested. |
[in] | order | The order for which the imaginary E matrix values are requested. |
[in] | eMatsLMImag | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4187 of file ProSHADE_data.cpp.
4190 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4192 eMatsLMImag[iter] =
static_cast<double> ( this->
eMatrices[band][order1][iter][1] );
◆ 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] | rotFunImag | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4274 of file ProSHADE_data.cpp.
4277 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4279 rotFunImag[iter] =
static_cast<double> ( this->
so3CoeffsInverse[iter][1] );
◆ 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] | so3CoefsImag | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4223 of file ProSHADE_data.cpp.
4226 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4228 so3CoefsImag[iter] =
static_cast<double> ( this->
so3Coeffs[iter][1] );
◆ 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] | X | Pointer to the value of the internal private spherical harmonics imaginary value of the given index. |
Definition at line 3736 of file ProSHADE_data.cpp.
3739 return ( &this->
sphericalHarmonics[shell][seanindex (
static_cast< int > ( order ) -
static_cast< int > ( band ),
3740 static_cast< int > ( band ),
3741 static_cast< int > ( this->
spheres[shell]->getLocalBandwidth() ) )][1] );
◆ 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] | trsFunImag | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4310 of file ProSHADE_data.cpp.
4313 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4315 trsFunImag[iter] =
static_cast<double> ( this->
translationMap[iter][1] );
◆ getIntegrationWeight()
proshade_double ProSHADE_internal_data::ProSHADE_data::getIntegrationWeight |
( |
void |
| ) |
|
This function allows access to the integration weight for the object.
- Parameters
-
[out] | X | The integration weight for the object or 0.0 if not yet computed. |
Definition at line 3760 of file ProSHADE_data.cpp.
◆ getInternalMap()
proshade_double *& ProSHADE_internal_data::ProSHADE_data::getInternalMap |
( |
void |
| ) |
|
This function allows access to the first map array value address.
- Parameters
-
[out] | internalMap | Pointer to the first position in the internal map array. |
Definition at line 4028 of file ProSHADE_data.cpp.
◆ getInvSO3Coeffs()
proshade_complex * ProSHADE_internal_data::ProSHADE_data::getInvSO3Coeffs |
( |
void |
| ) |
|
This function allows access to the inverse SO(3) coefficients array.
- Parameters
-
[out] | X | The internal inverse SO(3) coefficients array variable. |
Definition at line 3826 of file ProSHADE_data.cpp.
◆ 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] | mapCOMProcessChange | Vector of the distances in Angstroms that the structure has been moved internally. |
Definition at line 4048 of file ProSHADE_data.cpp.
4051 std::vector< proshade_double > ret;
◆ 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] | pos | The position in the map array, of which the value should be returned. |
[out] | X | The internal map representation value at position pos. |
Definition at line 3589 of file ProSHADE_data.cpp.
◆ getMaxBand()
proshade_unsign ProSHADE_internal_data::ProSHADE_data::getMaxBand |
( |
void |
| ) |
|
This function returns the maximum band value for the object.
- Parameters
-
[out] | X | The largest number of bands used in any shell of the object. |
Definition at line 3599 of file ProSHADE_data.cpp.
◆ getMaxSpheres()
proshade_unsign ProSHADE_internal_data::ProSHADE_data::getMaxSpheres |
( |
void |
| ) |
|
This function returns the number of spheres which contain the whole object.
- Parameters
-
[out] | X | The total number of spheres to which the structure is mapped. |
Definition at line 3578 of file ProSHADE_data.cpp.
◆ getNoRecommendedSymmetryAxes()
proshade_unsign ProSHADE_internal_data::ProSHADE_data::getNoRecommendedSymmetryAxes |
( |
ProSHADE_settings * |
settings | ) |
|
This function returns the number of detected recommended symmetry axes.
- Parameters
-
[in] | settings | A pointer to settings class containing all the information required for map manipulation. |
[out] | val | The length of the recommended symmetry axes vector. |
Definition at line 4386 of file ProSHADE_data.cpp.
4389 return (
static_cast<proshade_unsign
> ( settings->
detectedSymmetry.size() ) );
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[in] | CSymList | A vector containing the already detected Cyclic symmetries. |
Definition at line 2199 of file ProSHADE_symmetry.cpp.
2202 std::vector< proshade_double* > ret;
2221 for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
2223 for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
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 ) )
◆ getOverlayRotationFunction()
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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | obj2 | A pointer to the data class object of the other ( static ) structure. |
Definition at line 35 of file ProSHADE_overlay.cpp.
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[in] | CSymList | A vector containing the already detected Cyclic symmetries. |
[out] | ret | A 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.
2874 std::vector< std::vector< proshade_double* > > ret;
2886 for (
size_t pIt = 0; pIt < ret.size(); pIt++ )
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[in] | CSymList | A vector containing the already detected Cyclic symmetries. |
[out] | ret | A 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.
2919 std::vector< proshade_double* > ret;
2934 for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ret.size() ); retIt++ )
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[in] | CSymList | A vector containing the already detected Cyclic symmetries. |
[out] | ret | A 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.
4256 std::vector< proshade_double* > ret;
4271 for ( proshade_unsign retIt = 0; retIt < static_cast < proshade_unsign > ( ret.size() ); retIt++ )
◆ 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] | band | The band for which the real E matrix values are requested. |
[in] | order | The order for which the real E matrix values are requested. |
[in] | eMatsLMReal | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4167 of file ProSHADE_data.cpp.
4170 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4172 eMatsLMReal[iter] =
static_cast<double> ( this->
eMatrices[band][order1][iter][0] );
◆ 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] | rotFunReal | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4256 of file ProSHADE_data.cpp.
4259 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4261 rotFunReal[iter] =
static_cast<double> ( this->
so3CoeffsInverse[iter][0] );
◆ 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] | so3CoefsReal | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4205 of file ProSHADE_data.cpp.
4208 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4210 so3CoefsReal[iter] =
static_cast<double> ( this->
so3Coeffs[iter][0] );
◆ 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] | X | Pointer to the value of the internal private spherical harmonics real value of the given index. |
Definition at line 3723 of file ProSHADE_data.cpp.
3726 return ( &this->
sphericalHarmonics[shell][seanindex (
static_cast< int > ( order ) -
static_cast< int > ( band ),
3727 static_cast< int > ( band ),
3728 static_cast< int > ( this->
spheres[shell]->getLocalBandwidth() ) )][0] );
◆ 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] | trsFunReal | The array to which the values will be written into. |
[in] | len | The lenght of the array. |
Definition at line 4292 of file ProSHADE_data.cpp.
4295 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4297 trsFunReal[iter] =
static_cast<double> ( this->
translationMap[iter][0] );
◆ 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] | settings | A pointer to settings class containing all the information required for reading in the map. |
[in] | ret | A 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 1329 of file ProSHADE_data.cpp.
1337 for ( proshade_unsign iter = 0; iter < 6; iter++ ) { ret[iter] = settings->
forceBounds[iter]; }
1344 static_cast< proshade_signed
> ( this->
xDimIndices ),
1345 static_cast< proshade_signed
> ( this->
yDimIndices ),
1346 static_cast< proshade_signed
> ( this->
zDimIndices ),
1357 std::stringstream ssHlp;
1358 ssHlp <<
"New boundaries are: " << ret[1] - ret[0] + 1 <<
" x " << ret[3] - ret[2] + 1 <<
" x " << ret[5] - ret[4] + 1;
1364 for ( proshade_unsign iter = 0; iter < 6; iter++ ) { settings->
forceBounds[iter] = ret[iter]; }
◆ getRecommendedSymmetryFold()
proshade_unsign ProSHADE_internal_data::ProSHADE_data::getRecommendedSymmetryFold |
( |
ProSHADE_settings * |
settings | ) |
|
This function simply returns the detected recommended symmetry fold.
- Parameters
-
[in] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 4374 of file ProSHADE_data.cpp.
◆ getRecommendedSymmetryType()
std::string ProSHADE_internal_data::ProSHADE_data::getRecommendedSymmetryType |
( |
ProSHADE_settings * |
settings | ) |
|
This function simply returns the detected recommended symmetry type.
- Parameters
-
[in] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 4363 of file ProSHADE_data.cpp.
◆ 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] | aI | The index along the Euler alpha dimension. |
[in] | bI | The index along the Euler beta dimension. |
[in] | gI | The index along the Euler gamma dimension. |
[in] | rotMat | The array to which the rotation matrix will be written into. |
[in] | len | The lenght of the array (must be 9). |
Definition at line 4331 of file ProSHADE_data.cpp.
4334 proshade_double eA, eB, eG;
4338 proshade_double* rMat =
nullptr;
4339 rMat =
new proshade_double[9];
4346 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( len ); iter++ )
4348 rotMat[iter] =
static_cast<double> ( rMat[iter] );
◆ 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] | X | The value of the internal private RRP matrix for the given indices. |
Definition at line 3609 of file ProSHADE_data.cpp.
◆ 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] | shell | The index of the shell for which the bandwidth is required. |
[out] | X | The bandwidth of the requested shell. |
Definition at line 3772 of file ProSHADE_data.cpp.
3775 return ( this->
spheres[shell]->getLocalBandwidth ( ) );
◆ getSO3Coeffs()
proshade_complex * ProSHADE_internal_data::ProSHADE_data::getSO3Coeffs |
( |
void |
| ) |
|
This function allows access to the SO(3) coefficients array.
- Parameters
-
[out] | X | The internal SO(3) coefficients array variable. |
Definition at line 3837 of file ProSHADE_data.cpp.
◆ 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] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 1742 of file ProSHADE_data.cpp.
1747 std::stringstream hlpSS;
1748 hlpSS <<
"The sphere distances were determined as " << this->
spherePos.at(0);
1749 for ( proshade_unsign iter = 1; iter < static_cast<proshade_unsign> ( this->
spherePos.size() ); iter++ ) { hlpSS <<
"; " << this->
spherePos.at(iter); }
1750 hlpSS <<
" Angstroms.";
1756 proshade_unsign maxDim =
static_cast< proshade_unsign
> ( std::max ( this->
xDimSize, std::max ( this->
yDimSize, this->
zDimSize ) ) );
1757 proshade_unsign minDim =
static_cast< proshade_unsign
> ( std::min ( this->
xDimSize, std::min ( this->
yDimSize, this->
zDimSize ) ) );
1758 proshade_unsign midDim =
static_cast< proshade_unsign
> ( 0 );
1759 if ( ( this->
xDimSize <
static_cast< proshade_single
> ( maxDim ) ) && ( this->
xDimSize >
static_cast< proshade_single
> ( minDim ) ) ) { midDim =
static_cast< proshade_unsign
> ( this->
xDimSize ); }
1760 else if ( ( this->
yDimSize <
static_cast< proshade_single
> ( maxDim ) ) && ( this->
yDimSize >
static_cast< proshade_single
> ( minDim ) ) ) { midDim =
static_cast< proshade_unsign
> ( this->
yDimSize ); }
1761 else { midDim =
static_cast< proshade_unsign
> ( this->
zDimSize ); }
1763 proshade_single maxDiag =
static_cast< proshade_single
> ( std::sqrt ( std::pow (
static_cast<proshade_single
> ( maxDim ), 2.0 ) +
1764 std::pow (
static_cast<proshade_single
> ( midDim ), 2.0 ) ) );
1767 for ( proshade_single iter = 0.5f; ( iter * settings->
maxSphereDists ) < ( maxDiag / 2.0f ); iter += 1.0f )
1776 std::stringstream hlpSS;
1777 hlpSS <<
"The sphere distances were determined as " << this->
spherePos.at(0);
1778 for ( proshade_unsign iter = 1; iter < static_cast<proshade_unsign> ( this->
spherePos.size() ); iter++ ) { hlpSS <<
"; " << this->
spherePos.at(iter); }
1779 hlpSS <<
" Angstroms.";
◆ getSpherePosValue()
proshade_single ProSHADE_internal_data::ProSHADE_data::getSpherePosValue |
( |
proshade_unsign |
shell | ) |
|
This function allows access to sphere positions.
- Parameters
-
[in] | shell | The index of the sphere for which the position (radius) is to be obtained. |
[out] | X | The radius of the sphere with index shell. |
Definition at line 3784 of file ProSHADE_data.cpp.
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | axisNo | The index of the axis to be returned. |
[out] | val | A 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 4398 of file ProSHADE_data.cpp.
4401 if (
static_cast<proshade_unsign
> ( settings->
detectedSymmetry.size() ) <= axisNo )
4404 return ( std::vector< std::string > ( ) );
4408 std::vector< std::string > ret;
4411 std::stringstream ssHlp;
◆ 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] | settings | A pointer to settings class containing all the information required for symmetry detection. |
[in] | CSymList | A vector containing the already detected Cyclic symmetries. |
Definition at line 1419 of file ProSHADE_symmetry.cpp.
1422 std::vector< proshade_double* > ret;
1438 for ( proshade_unsign csIt = 0; csIt < static_cast<proshade_unsign> ( CSymList->size() ); csIt++ )
1440 for ( proshade_unsign retIt = 0; retIt < static_cast<proshade_unsign> ( ret.size() ); retIt++ )
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 ) ) )
◆ getTranslationFnPointer()
proshade_complex * ProSHADE_internal_data::ProSHADE_data::getTranslationFnPointer |
( |
void |
| ) |
|
This function allows access to the translation function through a pointer.
- Parameters
-
[out] | translationMap | Pointer to the first position in the translation function map array. |
Definition at line 4038 of file ProSHADE_data.cpp.
◆ 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] | band | The band for which the Wigner D matrix value should be returned. |
[in] | order1 | The first order for which the Wigner D matrix value should be returned. |
[in] | order2 | The second order for which the Wigner D matrix value should be returned. |
[in] | valueReal | The proshade_double number pointer to where the real part of the value will be saved. |
[in] | valueImag | The proshade_double number pointer to where the imaginary part of the value will be saved. |
Definition at line 3863 of file ProSHADE_data.cpp.
◆ getXAxisOrigin()
proshade_signed * ProSHADE_internal_data::ProSHADE_data::getXAxisOrigin |
( |
void |
| ) |
|
This function allows access to the map X axis origin value.
- Parameters
-
[out] | xAxisOrigin | The value of X axis origin for the map. |
Definition at line 3998 of file ProSHADE_data.cpp.
◆ 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] | xDimSize | The size of the internal map in indices along the X axis. |
Definition at line 3908 of file ProSHADE_data.cpp.
◆ 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] | xDimSize | The size of the internal map in angstroms along the X axis. |
Definition at line 3878 of file ProSHADE_data.cpp.
◆ getXFromPtr()
proshade_signed * ProSHADE_internal_data::ProSHADE_data::getXFromPtr |
( |
void |
| ) |
|
This function allows access to the map start along the X axis.
- Parameters
-
[out] | xFrom | Pointer to the starting index along the X axis. |
Definition at line 3938 of file ProSHADE_data.cpp.
3941 return ( &this->
xFrom );
◆ 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] | xFrom | Pointer to the final index along the X axis. |
Definition at line 3968 of file ProSHADE_data.cpp.
3971 return ( &this->
xTo );
◆ getYAxisOrigin()
proshade_signed * ProSHADE_internal_data::ProSHADE_data::getYAxisOrigin |
( |
void |
| ) |
|
This function allows access to the map Y axis origin value.
- Parameters
-
[out] | yAxisOrigin | The value of Y axis origin for the map. |
Definition at line 4008 of file ProSHADE_data.cpp.
◆ 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] | xDimSize | The size of the internal map in indices along the Y axis. |
Definition at line 3918 of file ProSHADE_data.cpp.
◆ 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] | xDimSize | The size of the internal map in angstroms along the Y axis. |
Definition at line 3888 of file ProSHADE_data.cpp.
◆ getYFromPtr()
proshade_signed * ProSHADE_internal_data::ProSHADE_data::getYFromPtr |
( |
void |
| ) |
|
This function allows access to the map start along the Y axis.
- Parameters
-
[out] | yFrom | Pointer to the starting index along the Y axis. |
Definition at line 3948 of file ProSHADE_data.cpp.
3951 return ( &this->
yFrom );
◆ 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] | yFrom | Pointer to the final index along the Y axis. |
Definition at line 3978 of file ProSHADE_data.cpp.
3981 return ( &this->
yTo );
◆ getZAxisOrigin()
proshade_signed * ProSHADE_internal_data::ProSHADE_data::getZAxisOrigin |
( |
void |
| ) |
|
This function allows access to the map Z axis origin value.
- Parameters
-
[out] | zAxisOrigin | The value of Z axis origin for the map. |
Definition at line 4018 of file ProSHADE_data.cpp.
◆ 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] | xDimSize | The size of the internal map in indices along the Z axis. |
Definition at line 3928 of file ProSHADE_data.cpp.
◆ 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] | xDimSize | The size of the internal map in angstroms along the Z axis. |
Definition at line 3898 of file ProSHADE_data.cpp.
◆ getZFromPtr()
proshade_signed * ProSHADE_internal_data::ProSHADE_data::getZFromPtr |
( |
void |
| ) |
|
This function allows access to the map start along the Z axis.
- Parameters
-
[out] | zFrom | Pointer to the starting index along the Z axis. |
Definition at line 3958 of file ProSHADE_data.cpp.
3961 return ( &this->
zFrom );
◆ 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] | zFrom | Pointer to the final index along the Z axis. |
Definition at line 3988 of file ProSHADE_data.cpp.
3991 return ( &this->
zTo );
◆ interpolateMapFromSpheres()
void ProSHADE_internal_data::ProSHADE_data::interpolateMapFromSpheres |
( |
proshade_double *& |
densityMapRotated | ) |
|
This function interpolates the density map from the sphere mapped data.
- Parameters
-
[in] | densityMapRotated | The pointer to allocated memory where the new map values will be held. |
Definition at line 1200 of file ProSHADE_overlay.cpp.
1203 proshade_double rad = 0.0, lon = 0.0, lat = 0.0, newU = 0.0, newV = 0.0, newW = 0.0;
1204 proshade_unsign lowerLonL = 0, upperLonL = 0, lowerLonU = 0, upperLonU = 0, lowerLatL = 0, upperLatL = 0, lowerLatU = 0, upperLatU = 0, lowerShell = 0, upperShell = 0;
1205 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;
1206 proshade_double lowerShellValue = 0.0, upperShellValue = 0.0;
1207 proshade_double xSamplingRate =
static_cast<proshade_double
> ( this->
xDimSize ) /
static_cast<proshade_double
> ( this->
xDimIndices );
1208 proshade_double ySamplingRate =
static_cast<proshade_double
> ( this->
yDimSize ) /
static_cast<proshade_double
> ( this->
yDimIndices );
1209 proshade_double zSamplingRate =
static_cast<proshade_double
> ( this->
zDimSize ) /
static_cast<proshade_double
> ( this->
zDimIndices );
1210 proshade_signed arrPos;
1211 std::vector<proshade_double> lonCOU, latCOU, lonCOL, latCOL;
1213 for ( proshade_signed uIt = 0; uIt < static_cast<proshade_signed> (this->
xDimIndices); uIt++ )
1215 for ( proshade_signed vIt = 0; vIt < static_cast<proshade_signed> (this->
yDimIndices); vIt++ )
1217 for ( proshade_signed wIt = 0; wIt < static_cast<proshade_signed> (this->
zDimIndices); wIt++ )
1220 newU =
static_cast<proshade_double
> ( uIt - (
static_cast<proshade_signed
> (this->
xDimIndices) / 2 ) );
1221 newV =
static_cast<proshade_double
> ( vIt - (
static_cast<proshade_signed
> (this->
yDimIndices) / 2 ) );
1222 newW =
static_cast<proshade_double
> ( wIt - (
static_cast<proshade_signed
> (this->
zDimIndices) / 2 ) );
1225 if ( ( newU == 0.0 ) && ( newV == 0.0 ) && ( newW == 0.0 ) )
1227 arrPos = wIt +
static_cast< proshade_signed
> ( this->
zDimIndices ) * ( vIt +
static_cast< proshade_signed
> ( this->
yDimIndices ) * uIt );
1228 densityMapRotated[arrPos] = this->
internalMap[arrPos];
1233 rad = sqrt ( pow( ( newU * xSamplingRate ), 2.0 ) +
1234 pow( ( newV * ySamplingRate ), 2.0 ) +
1235 pow( ( newW * zSamplingRate ), 2.0 ) );
1236 lon = atan2 ( ( newV * ySamplingRate ), ( newU * xSamplingRate ) );
1237 lat = asin ( ( newW * zSamplingRate ) / rad );
1240 if ( rad != rad ) { rad = 0.0; }
1241 if ( lon != lon ) { lon = 0.0; }
1242 if ( lat != lat ) { lat = 0.0; }
1247 for ( proshade_unsign iter = 0; iter < (this->
noSpheres-1); iter++ )
1249 if ( (
static_cast< proshade_double
> ( this->
spherePos.at(iter) ) <= rad ) && (
static_cast< proshade_double
> ( this->
spherePos.at(iter+1) ) > rad ) )
1252 upperShell = iter+1;
1257 if ( upperShell == 0 )
1259 arrPos = wIt +
static_cast< proshade_signed
> ( this->
zDimIndices ) * ( vIt +
static_cast< proshade_signed
> ( this->
yDimIndices ) * uIt );
1260 densityMapRotated[arrPos] = 0.0;
1265 lonCOL.clear(); latCOL.clear(); lonCOU.clear(); latCOU.clear();
1270 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( lonCOL.size() ); iter++ )
1272 if ( iter == (
static_cast<proshade_unsign
> ( lonCOL.size() ) - 1 ) )
1278 if ( ( std::floor(10000. * lonCOL.at(iter)) <= std::floor(10000. * lon) ) && ( std::floor(10000. * lonCOL.at(iter+1)) > std::floor(10000. * lon) ) )
1285 if ( upperLonL == this->
spheres[lowerShell]->getLocalAngRes() ) { upperLonL = 0; }
1287 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( lonCOU.size() ); iter++ )
1289 if ( iter == (
static_cast<proshade_unsign
> ( lonCOU.size() ) - 1 ) )
1295 if ( ( std::floor(10000. * lonCOU.at(iter)) <= std::floor(10000. * lon) ) && ( std::floor(10000. * lonCOU.at(iter+1)) > std::floor(10000. * lon) ) )
1302 if ( upperLonU == this->
spheres[upperShell]->getLocalAngRes() ) { upperLonU = 0; }
1304 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( latCOL.size() ); iter++ )
1306 if ( iter == (
static_cast<proshade_unsign
> ( latCOL.size() ) - 1 ) )
1312 if ( ( std::floor(10000. * latCOL.at(iter)) <= std::floor(10000. * lat) ) && ( std::floor(10000. * latCOL.at(iter+1)) > std::floor(10000. * lat) ) )
1319 if ( upperLatL == this->
spheres[lowerShell]->getLocalAngRes() ) { upperLatL = 0; }
1321 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( latCOU.size() ); iter++ )
1323 if ( iter == (
static_cast<proshade_unsign
> ( latCOU.size() ) - 1 ) )
1329 if ( ( std::floor(10000. * latCOU.at(iter)) <= std::floor(10000. * lat) ) && ( std::floor(10000. * latCOU.at(iter+1)) > std::floor(10000. * lat) ) )
1336 if ( upperLatU == this->
spheres[upperShell]->getLocalAngRes() ) { upperLatU = 0; }
1344 distLLon = std::abs ( lon - lonCOL.at(lowerLonL) ) / ( std::abs( lon - lonCOL.at(lowerLonL) ) + std::abs( lon - lonCOL.at(upperLonL) ) );
1345 valLLon = ( ( 1.0 - distLLon ) * x00 ) + ( distLLon * x01 );
1346 valULon = ( ( 1.0 - distLLon ) * x10 ) + ( distLLon * x11 );
1348 distLLat = std::abs ( lat - latCOL.at(lowerLatL) ) / ( std::abs( lat - latCOL.at(lowerLatL) ) + std::abs( lat - latCOL.at(upperLatL) ) );
1349 lowerShellValue = ( ( 1.0 - distLLat ) * valLLon ) + ( distLLat * valULon );
1357 distLLon = std::abs ( lon - lonCOU.at(lowerLonU) ) / ( std::abs( lon - lonCOU.at(lowerLonU) ) + std::abs( lon - lonCOU.at(upperLonU) ) );
1358 valLLon = ( ( 1.0 - distLLon ) * x00 ) + ( distLLon * x01 );
1359 valULon = ( ( 1.0 - distLLon ) * x10 ) + ( distLLon * x11 );
1361 distLLat = std::abs ( lat - latCOU.at(lowerLatU) ) / ( std::abs( lat - latCOU.at(lowerLatU) ) + std::abs( lat - latCOU.at(upperLatU) ) );
1362 upperShellValue = ( ( 1.0 - distLLat ) * valLLon ) + ( distLLat * valULon );
1365 distLRad = std::abs ( rad -
static_cast< proshade_double
> ( this->
spherePos.at(lowerShell) ) ) / ( std::abs( rad -
static_cast< proshade_double
> ( this->
spherePos.at(lowerShell) ) ) +
1366 std::abs( rad -
static_cast< proshade_double
> ( this->
spherePos.at(upperShell) ) ) );
1368 arrPos = wIt +
static_cast< proshade_signed
> ( this->
zDimIndices ) * ( vIt +
static_cast< proshade_signed
> ( this->
yDimIndices ) * uIt );
1369 densityMapRotated[arrPos] = ( ( 1.0 - distLRad ) * lowerShellValue ) + ( distLRad * upperShellValue );
◆ 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] | settings | A pointer to settings class containing all the information required for reading in the map. |
Definition at line 1188 of file ProSHADE_data.cpp.
1194 proshade_signed arrayPos, invPos;
1207 for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->
xDimIndices ); xIt++ )
1209 for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->
yDimIndices ); yIt++ )
1211 for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->
zDimIndices ); zIt++ )
1214 arrayPos = zIt +
static_cast< proshade_signed
> ( this->
zDimIndices ) * ( yIt +
static_cast< proshade_signed
> ( this->
yDimIndices ) * xIt );
1215 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 ) );
◆ 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 1107 of file ProSHADE_overlay.cpp.
1110 double *sigR =
nullptr, *sigI =
nullptr, *rcoeffs =
nullptr, *icoeffs =
nullptr, *weights =
nullptr, *workspace =
nullptr;
1111 fftw_plan idctPlan, ifftPlan;
1114 for (
int shell = 0; shell < static_cast<int> ( this->
noSpheres ); shell++ )
1123 makeweights (
static_cast< int > ( this->
spheres[shell]->getLocalBandwidth() ), weights );
1129 for (
unsigned int iter = 0; iter < static_cast<unsigned int> ( oneDim * oneDim ); iter++ )
1138 InvFST_semi_fly ( rcoeffs,
1142 static_cast< int > ( this->
spheres[shell]->getLocalBandwidth() ),
1145 static_cast< int > ( this->
spheres[shell]->getLocalBandwidth() ),
1150 for (
unsigned int iter = 0; iter < static_cast<unsigned int> ( oneDim * oneDim ); iter++ )
1156 fftw_destroy_plan ( idctPlan );
1157 fftw_destroy_plan ( ifftPlan );
◆ 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] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 1799 of file ProSHADE_data.cpp.
1815 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( this->
spherePos.size() ); iter++ )
1817 std::stringstream ss;
1818 ss <<
"Now mapping sphere " << iter <<
" .";
1824 this->internalMap, &this->maxShellBand );
◆ maskMap()
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] | settings | A pointer to settings class containing all the information required for reading in the map. |
Definition at line 1289 of file ProSHADE_data.cpp.
1309 delete[] blurredMap;
◆ 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] | band | The band indice of the E matrix to which the value should be assigned. |
[in] | order1 | The first order indice of the E matrix to which the value should be assigned. |
[in] | order2 | The second order indice of the E matrix to which the value should be assigned. |
[in] | normF | The value by which the original E matrix value will be divided to normalise it. |
Definition at line 4115 of file ProSHADE_data.cpp.
4118 this->
eMatrices[band][order1][order2][0] /= normF;
4119 this->
eMatrices[band][order1][order2][1] /= normF;
◆ 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] | settings | A pointer to settings class containing all the information required for reading in the map. |
Definition at line 1242 of file ProSHADE_data.cpp.
1257 proshade_double* meanSD =
new proshade_double[2];
◆ 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] | mapData | The input array for Fourier transform. |
[in] | origCoeffs | The array for holding the Fourier coefficients of the original (non-rotated) density. |
[in] | fCoeffs | The array for holding the results of Fourier transform. |
[in] | binIndexing | A map that will be filled with binning indices for fast binning. |
[in] | noBins | The number of bins will be stored in this variable. |
[in] | bindata | An array to store the bin sums and other FSC computation temporary results. |
[in] | binCounts | An array that will be used to store the number of reflactions in each bin. |
Definition at line 2357 of file ProSHADE_data.cpp.
2363 bindata =
new proshade_double*[*noBins];
2364 binCounts =
new proshade_signed [*noBins];
2367 for (
size_t binIt = 0; binIt < static_cast< size_t > ( *noBins ); binIt++ )
2369 bindata[binIt] =
new proshade_double[12];
2386 *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 );
2390 fftw_execute ( *planForwardFourier );
2391 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]; }
◆ 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] | settings | A 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 1699 of file ProSHADE_data.cpp.
◆ readInGemmi()
void ProSHADE_internal_data::ProSHADE_data::readInGemmi |
( |
gemmi::Structure |
gemmiStruct, |
|
|
ProSHADE_settings * |
settings |
|
) |
| |
|
protected |
Function for reading co-ordinate data from Gemmi object.
This function processes the input Gemmi structure into ProSHADE internal map. It starts with ProSHADE optional modifications of the co-ordinates (i.e. setting all B-factors to given value and removing waters). It then proceeds to move the co-ordinates so that their minimal point is at position [20, 20, 20] (this is to make sure map density will be at the centre of the box) and computes the theoretical density map using Gemmi's Cromer & Libermann method. It then moves the map box to the original co-ordinates position.
If map re-sampling is required, then this is done here as well.
Finally, this function sets all the ProSHADE internal values to what other functions expect and terminates.
- Parameters
-
[in] | settings | A 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 785 of file ProSHADE_data.cpp.
806 proshade_double xCOMPdb, yCOMPdb, zCOMPdb;
810 proshade_single xF, xT, yF, yT, zF, zT;
814 proshade_single xMov =
static_cast< proshade_single
> ( 20.0f - xF );
815 proshade_single yMov =
static_cast< proshade_single
> ( 20.0f - yF );
816 proshade_single zMov =
static_cast< proshade_single
> ( 20.0f - zF );
820 this->
xDimSize =
static_cast< proshade_single
> ( xT - xF + 40.0f );
821 this->
yDimSize =
static_cast< proshade_single
> ( yT - yF + 40.0f );
822 this->
zDimSize =
static_cast< proshade_single
> ( zT - zF + 40.0f );
825 ProSHADE_internal_mapManip::generateMapFromPDB ( gemmiStruct, this->
internalMap, settings->
requestedResolution, this->xDimSize, this->yDimSize, this->zDimSize, &this->xTo, &this->yTo, &this->zTo, settings->
forceP1, settings->
firstModelOnly );
834 proshade_double xCOMMap, yCOMMap, zCOMMap;
839 if ( gemmiStruct.models.size() > 1 )
841 xMov =
static_cast< proshade_single
> ( xCOMMap - xCOMPdb );
842 yMov =
static_cast< proshade_single
> ( yCOMMap - yCOMPdb );
843 zMov =
static_cast< proshade_single
> ( zCOMMap - zCOMPdb );
851 static_cast< proshade_signed
> ( this->
xDimIndices ),
static_cast< proshade_signed
> ( this->
yDimIndices ),
852 static_cast< proshade_signed
> ( this->
zDimIndices ) );
858 proshade_single xSampRate = this->
xDimSize /
static_cast< proshade_single
> ( this->
xTo - this->
xFrom );
859 proshade_single ySampRate = this->
yDimSize /
static_cast< proshade_single
> ( this->
yTo - this->
yFrom );
860 proshade_single zSampRate = this->
zDimSize /
static_cast< proshade_single
> ( this->
zTo - this->
zFrom );
863 proshade_single xStartPosBefore =
static_cast< proshade_single
> ( this->
xFrom ) * xSampRate;
864 proshade_single yStartPosBefore =
static_cast< proshade_single
> ( this->
yFrom ) * ySampRate;
865 proshade_single zStartPosBefore =
static_cast< proshade_single
> ( this->
zFrom ) * zSampRate;
868 proshade_double xMapCOMPreReSampl = 0.0, yMapCOMPreReSampl = 0.0, zMapCOMPreReSampl = 0.0;
869 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 );
875 xSampRate = this->
xDimSize /
static_cast< proshade_single
> ( this->
xTo - this->
xFrom );
876 ySampRate = this->
yDimSize /
static_cast< proshade_single
> ( this->
yTo - this->
yFrom );
877 zSampRate = this->
zDimSize /
static_cast< proshade_single
> ( this->
zTo - this->
zFrom );
880 proshade_single xStartPosAfter =
static_cast< proshade_single
> ( this->
xFrom ) * xSampRate;
881 proshade_single yStartPosAfter =
static_cast< proshade_single
> ( this->
yFrom ) * ySampRate;
882 proshade_single zStartPosAfter =
static_cast< proshade_single
> ( this->
zFrom ) * zSampRate;
885 proshade_single xMovHlp =
static_cast< proshade_single
> ( xStartPosAfter - xStartPosBefore );
886 proshade_single yMovHlp =
static_cast< proshade_single
> ( yStartPosAfter - yStartPosBefore );
887 proshade_single zMovHlp =
static_cast< proshade_single
> ( zStartPosAfter - zStartPosBefore );
893 proshade_double xMapCOMPostReSampl = 0.0, yMapCOMPostReSampl = 0.0, zMapCOMPostReSampl = 0.0;
894 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 );
898 static_cast< proshade_single
> ( xMapCOMPreReSampl - xMapCOMPostReSampl ),
899 static_cast< proshade_single
> ( yMapCOMPreReSampl - yMapCOMPostReSampl ),
900 static_cast< proshade_single
> ( zMapCOMPreReSampl - zMapCOMPostReSampl ),
902 static_cast< proshade_signed
> ( this->
xDimIndices ),
903 static_cast< proshade_signed
> ( this->
yDimIndices ),
904 static_cast< proshade_signed
> ( this->
zDimIndices ) );
◆ readInMAP()
void ProSHADE_internal_data::ProSHADE_data::readInMAP |
( |
ProSHADE_settings * |
settings, |
|
|
proshade_double * |
maskArr = nullptr , |
|
|
proshade_unsign |
maskXDim = 0 , |
|
|
proshade_unsign |
maskYDim = 0 , |
|
|
proshade_unsign |
maskZDim = 0 , |
|
|
proshade_double * |
weightsArr = nullptr , |
|
|
proshade_unsign |
weigXDim = 0 , |
|
|
proshade_unsign |
weigYDim = 0 , |
|
|
proshade_unsign |
weigZDim = 0 |
|
) |
| |
|
protected |
Function for reading map data using gemmi library.
This function reads in the map data using the information from the settings object and saves all the results into the structure calling it. More specifically, the data are parsed from the input file, mask (if any is supplied) is applied here, the Fourier weights are applied, map re-sampling is done and then the final map details are saved for further processing.
- Parameters
-
[in] | settings | A pointer to settings class containing all the information required for reading in the map. |
[in] | maskArr | An array of mask values (default nullptr) to be used instead of an input mask file. |
[in] | maskXDim | The size of maskArray x dimension in indices (defaults to 0). |
[in] | maskYDim | The size of maskArray y dimension in indices (defaults to 0). |
[in] | maskZDim | The size of maskArray z dimension in indices (defaults to 0). |
[in] | weightsArr | An array of weights (default nullptr) to be used instead of input file. |
[in] | weigXDim | The size of weightsArray x dimension in indices (defaults to 0). |
[in] | weigYDim | The size of weightsArray y dimension in indices (defaults to 0). |
[in] | weigZDim | The size of weightsArray z dimension in indices (defaults to 0). |
Definition at line 619 of file ProSHADE_data.cpp.
622 gemmi::Ccp4<float> map;
623 map.read_ccp4 ( gemmi::MaybeGzipped ( this->
fileName.c_str() ) );
626 map.setup ( gemmi::GridSetup::ReorderOnly, NAN );
643 maskArr, maskXDim, maskYDim, maskZDim );
647 weightsArr, weigXDim, weigYDim, weigZDim );
656 std::min (
static_cast<proshade_single
> ( this->
yDimSize ) /
static_cast<proshade_single
> ( this->
yDimIndices ),
657 static_cast<proshade_single
> ( this->
zDimSize ) /
static_cast<proshade_single
> ( this->
zDimIndices ) ) ) * 2.0f );
667 proshade_single xSampRate = this->
xDimSize /
static_cast< proshade_single
> ( this->
xTo - this->
xFrom );
668 proshade_single ySampRate = this->
yDimSize /
static_cast< proshade_single
> ( this->
yTo - this->
yFrom );
669 proshade_single zSampRate = this->
zDimSize /
static_cast< proshade_single
> ( this->
zTo - this->
zFrom );
672 proshade_single xStartPosBefore =
static_cast< proshade_single
> ( this->
xFrom ) * xSampRate;
673 proshade_single yStartPosBefore =
static_cast< proshade_single
> ( this->
yFrom ) * ySampRate;
674 proshade_single zStartPosBefore =
static_cast< proshade_single
> ( this->
zFrom ) * zSampRate;
677 proshade_double xMapCOMPreReSampl = 0.0, yMapCOMPreReSampl = 0.0, zMapCOMPreReSampl = 0.0;
678 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 );
684 xSampRate = this->
xDimSize /
static_cast< proshade_single
> ( this->
xTo - this->
xFrom );
685 ySampRate = this->
yDimSize /
static_cast< proshade_single
> ( this->
yTo - this->
yFrom );
686 zSampRate = this->
zDimSize /
static_cast< proshade_single
> ( this->
zTo - this->
zFrom );
689 proshade_single xStartPosAfter =
static_cast< proshade_single
> ( this->
xFrom ) * xSampRate;
690 proshade_single yStartPosAfter =
static_cast< proshade_single
> ( this->
yFrom ) * ySampRate;
691 proshade_single zStartPosAfter =
static_cast< proshade_single
> ( this->
zFrom ) * zSampRate;
694 proshade_single xMov =
static_cast< proshade_single
> ( xStartPosAfter - xStartPosBefore );
695 proshade_single yMov =
static_cast< proshade_single
> ( yStartPosAfter - yStartPosBefore );
696 proshade_single zMov =
static_cast< proshade_single
> ( zStartPosAfter - zStartPosBefore );
702 proshade_double xMapCOMPostReSampl = 0.0, yMapCOMPostReSampl = 0.0, zMapCOMPostReSampl = 0.0;
703 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 );
707 static_cast< proshade_single
> ( xMapCOMPreReSampl - xMapCOMPostReSampl ),
708 static_cast< proshade_single
> ( yMapCOMPreReSampl - yMapCOMPostReSampl ),
709 static_cast< proshade_single
> ( zMapCOMPreReSampl - zMapCOMPostReSampl ),
711 static_cast< proshade_signed
> ( this->
xDimIndices ),
712 static_cast< proshade_signed
> ( this->
yDimIndices ),
713 static_cast< proshade_signed
> ( this->
zDimIndices ) );
◆ 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] | settings | A 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 750 of file ProSHADE_data.cpp.
759 gemmi::Structure pdbFile = gemmi::read_structure ( gemmi::MaybeGzipped ( this->
fileName ) );
◆ readInStructure() [1/2]
void ProSHADE_internal_data::ProSHADE_data::readInStructure |
( |
gemmi::Structure |
gemmiStruct, |
|
|
proshade_unsign |
inputO, |
|
|
ProSHADE_settings * |
settings |
|
) |
| |
This function initialises the basic ProSHADE_data variables and reads in a single structure from Gemmi co-ordinate object.
This function is basically the constructor for the ProSHADE_data class. It reads in a structure from the supplied gemmi::Structure object in the same way a co-ordinate structure would be read from file.
- Parameters
-
[in] | gemmiStruct | The Gemmi Structure object that should be read in. |
[in] | inputO | The order of this structure in this run's input. |
[in] | settings | A pointer to settings class containing all the information required for reading in the map. |
Definition at line 567 of file ProSHADE_data.cpp.
570 std::stringstream ss;
571 ss <<
"Starting to load the structure from Gemmi object " << inputO;
577 throw ProSHADE_exception (
"Structure data class not empty.",
"E000005", __FILE__, __LINE__, __func__,
"Attempted to read in structure into a ProSHADE_data\n : object which already does have structure read in\n : i.e. " + this->
fileName );
584 this->
fileType = ProSHADE_internal_io::GEMMI;
◆ readInStructure() [2/2]
void ProSHADE_internal_data::ProSHADE_data::readInStructure |
( |
std::string |
fName, |
|
|
proshade_unsign |
inputO, |
|
|
ProSHADE_settings * |
settings, |
|
|
proshade_double * |
maskArr = nullptr , |
|
|
proshade_unsign |
maskXDim = 0 , |
|
|
proshade_unsign |
maskYDim = 0 , |
|
|
proshade_unsign |
maskZDim = 0 , |
|
|
proshade_double * |
weightsArr = nullptr , |
|
|
proshade_unsign |
weigXDim = 0 , |
|
|
proshade_unsign |
weigYDim = 0 , |
|
|
proshade_unsign |
weigZDim = 0 |
|
) |
| |
This function initialises the basic ProSHADE_data variables and reads in a single structure.
This function is basically the constructor for the ProSHADE_data class. It reads in a structure (independent of the structure type) and fills in all the appropriate variables of the class.
- Parameters
-
[in] | fName | The file name of the file which should be loaded. |
[in] | inputO | The order of this structure in this run's input. |
[in] | settings | A pointer to settings class containing all the information required for reading in the map. |
[in] | maskArr | An array of mask values (default nullptr) to be used instead of an input mask file. |
[in] | maskXDim | The size of maskArray x dimension in indices (defaults to 0). |
[in] | maskYDim | The size of maskArray y dimension in indices (defaults to 0). |
[in] | maskZDim | The size of maskArray z dimension in indices (defaults to 0). |
[in] | weightsArr | An array of weights (default nullptr) to be used instead of input file. |
[in] | weigXDim | The size of weightsArray x dimension in indices (defaults to 0). |
[in] | weigYDim | The size of weightsArray y dimension in indices (defaults to 0). |
[in] | weigZDim | The size of weightsArray z dimension in indices (defaults to 0). |
Definition at line 509 of file ProSHADE_data.cpp.
517 throw ProSHADE_exception (
"Structure data class not empty.",
"E000005", __FILE__, __LINE__, __func__,
"Attempted to read in structure into a ProSHADE_data\n : object which already does have structure read in\n : i.e. " + this->
fileName );
532 case ProSHADE_internal_io::UNKNOWN:
533 throw ProSHADE_exception (
"Unknown file type.",
"E000006", __FILE__, __LINE__, __func__,
"When attempting to read the file\n : " + this->
fileName +
"\n : the file extension was determined as unknown. This could\n : mean either that the file does not exist, or that it is\n : not one of the supported extensions." );
535 case ProSHADE_internal_io::GEMMI:
536 throw ProSHADE_exception (
"Unknown file type.",
"E000006", __FILE__, __LINE__, __func__,
"When attempting to read the file\n : " + this->
fileName +
"\n : the file extension was determined as unknown. This could\n : mean either that the file does not exist, or that it is\n : not one of the supported extensions." );
538 case ProSHADE_internal_io::PDB:
542 case ProSHADE_internal_io::MAP:
543 this->
readInMAP ( settings, maskArr, maskXDim, maskYDim, maskZDim, weightsArr, weigXDim, weigYDim, weigZDim );
◆ 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] | settings | A pointer to settings class containing all the information required for map manipulation. |
Definition at line 3645 of file ProSHADE_data.cpp.
3662 pattersonMap[iter][1] = 0.0;
3666 fftw_plan forward = fftw_plan_dft_3d (
static_cast< int > ( this->
xDimIndices ),
static_cast< int > ( this->
yDimIndices ),
static_cast< int > ( this->
zDimIndices ),
3667 pattersonMap, mapCoeffs, FFTW_FORWARD, FFTW_ESTIMATE );
3668 fftw_plan inverse = fftw_plan_dft_3d (
static_cast< int > ( this->
xDimIndices ),
static_cast< int > ( this->
yDimIndices ),
static_cast< int > ( this->
zDimIndices ),
3669 mapCoeffs, pattersonMap, FFTW_BACKWARD, FFTW_ESTIMATE );
3672 fftw_execute ( forward );
3678 fftw_execute ( inverse );
3681 proshade_signed mapIt, patIt, patX, patY, patZ;
3682 for ( proshade_signed xIt = 0; xIt < static_cast<proshade_signed> ( this->
xDimIndices ); xIt++ )
3684 for ( proshade_signed yIt = 0; yIt < static_cast<proshade_signed> ( this->
yDimIndices ); yIt++ )
3686 for ( proshade_signed zIt = 0; zIt < static_cast<proshade_signed> ( this->
zDimIndices ); zIt++ )
3689 patX = xIt - (
static_cast<proshade_signed
> ( this->
xDimIndices ) / 2 );
if ( patX < 0 ) { patX += this->
xDimIndices; }
3690 patY = yIt - (
static_cast<proshade_signed
> ( this->
yDimIndices ) / 2 );
if ( patY < 0 ) { patY += this->
yDimIndices; }
3691 patZ = zIt - (
static_cast<proshade_signed
> ( this->
zDimIndices ) / 2 );
if ( patZ < 0 ) { patZ += this->
zDimIndices; }
3694 mapIt = zIt +
static_cast< proshade_signed
> ( this->
zDimIndices ) * ( yIt +
static_cast< proshade_signed
> ( this->
yDimIndices ) * xIt );
3695 patIt = patZ +
static_cast< proshade_signed
> ( this->
zDimIndices ) * ( patY +
static_cast< proshade_signed
> ( this->
yDimIndices ) * patX );
3698 this->
internalMap[mapIt] = pattersonMap[patIt][0];
3704 delete[] pattersonMap;
3708 fftw_destroy_plan ( forward );
3709 fftw_destroy_plan ( inverse );
◆ 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] | settings | ProSHADE_settings object specifying the details of how the computations should be done. |
[in] | rotationCentre | Pointer to vector for saving the position of the centre of rotation about which the rotation is to be done. |
[in] | mapBoxMovement | Pointer to vector for saving the sum of all translations done internally by ProSHADE to this input map. |
[in] | eulerAngles | Pointer to vector where the three Euler angles will be saved into. |
[in] | finalTranslation | Pointer 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 4491 of file ProSHADE_data.cpp.
4497 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);
4501 proshade_double* rotMat =
new proshade_double[9];
4505 std::stringstream rotMatSS;
4506 rotMatSS << std::setprecision (3) << std::showpos <<
"The rotation matrix about origin is : " << rotMat[0] <<
" " << rotMat[1] <<
" " << rotMat[2] << std::endl;
4507 rotMatSS << std::setprecision (3) << std::showpos <<
" : " << rotMat[3] <<
" " << rotMat[4] <<
" " << rotMat[5] << std::endl;
4508 rotMatSS << std::setprecision (3) << std::showpos <<
" : " << rotMat[6] <<
" " << rotMat[7] <<
" " << rotMat[8];
4514 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);
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection reporting. |
Definition at line 3467 of file ProSHADE_data.cpp.
3476 std::stringstream ssHlp;
3478 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 .";
3483 ssHlp.clear(); ssHlp.str (
"" );
3484 ssHlp <<
" Fold X Y Z Angle Height Average FSC";
3487 for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( settings->
detectedSymmetry.size() ); symIt++ )
3489 ssHlp.clear(); ssHlp.str (
"" );
3494 std::stringstream hlpSS3;
3495 ssHlp.clear(); ssHlp.str (
"" );
3496 hlpSS3 << std::endl <<
"To facilitate manual checking for symmetries, the following is a list of all detected C symmetries:";
3501 ssHlp.clear(); ssHlp.str (
"" );
3502 ssHlp <<
" Fold X Y Z Angle Height Average FSC";
3505 for ( proshade_unsign symIt = 0; symIt < static_cast<proshade_unsign> ( settings->
allDetectedCAxes.size() ); symIt++ )
3507 ssHlp.clear(); ssHlp.str (
"" );
◆ 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] | settings | A pointer to settings class containing all the information required for reading in the map. |
Definition at line 1453 of file ProSHADE_data.cpp.
1456 proshade_single* changeVals =
new proshade_single[6];
1462 this->xDimSize, this->yDimSize, this->zDimSize, changeVals );
1472 this->xDimSize, this->yDimSize, this->zDimSize, changeVals );
1477 this->
xDimIndices +=
static_cast<proshade_unsign
> ( changeVals[0] );
1478 this->
yDimIndices +=
static_cast<proshade_unsign
> ( changeVals[1] );
1479 this->
zDimIndices +=
static_cast<proshade_unsign
> ( changeVals[2] );
1485 this->
xTo +=
static_cast<proshade_unsign
> ( changeVals[0] );
1486 this->
yTo +=
static_cast<proshade_unsign
> ( changeVals[1] );
1487 this->
zTo +=
static_cast<proshade_unsign
> ( changeVals[2] );
1494 proshade_single xMov = -( (
static_cast<proshade_single
> ( this->
xFrom ) * ( this->
xDimSize /
static_cast<proshade_single
> ( this->
xDimIndices ) - changeVals[0] ) ) -
1495 (
static_cast<proshade_single
> ( this->
xFrom ) * ( this->
xDimSize /
static_cast<proshade_single
> ( this->
xDimIndices ) ) ) );
1496 proshade_single yMov = -( (
static_cast<proshade_single
> ( this->
yFrom ) * ( this->
yDimSize /
static_cast<proshade_single
> ( this->
yDimIndices ) - changeVals[1] ) ) -
1497 (
static_cast<proshade_single
> ( this->
yFrom ) * ( this->
yDimSize /
static_cast<proshade_single
> ( this->
yDimIndices ) ) ) );
1498 proshade_single zMov = -( (
static_cast<proshade_single
> ( this->
zFrom ) * ( this->
zDimSize /
static_cast<proshade_single
> ( this->
zDimIndices ) - changeVals[2] ) ) -
1499 (
static_cast<proshade_single
> ( this->
zFrom ) * ( this->
zDimSize /
static_cast<proshade_single
> ( this->
zDimIndices ) ) ) );
1506 static_cast< proshade_signed
> ( this->
xDimIndices ),
static_cast< proshade_signed
> ( this->
yDimIndices ),
static_cast< proshade_signed
> ( this->
zDimIndices ) );
1509 delete[] changeVals;
◆ rotateMapRealSpace()
std::vector< proshade_double > ProSHADE_internal_data::ProSHADE_data::rotateMapRealSpace |
( |
proshade_double |
axX, |
|
|
proshade_double |
axY, |
|
|
proshade_double |
axZ, |
|
|
proshade_double |
axAng, |
|
|
proshade_double *& |
map |
|
) |
| |
This function rotates a map based on the given angle-axis rotation.
This function takes the axis and angle of the required rotation as well as a pointer to which the rotated map should be saved into and proceeds to rotate the map in real space using tri-linear interpolation.
- Parameters
-
[in] | axX | The x-axis element of the angle-axis rotation representation. |
[in] | axY | The y-axis element of the angle-axis rotation representation. |
[in] | axZ | The z-axis element of the angle-axis rotation representation. |
[in] | axAng | The angle about the axis by which the rotation is to be done. |
[in] | map | A pointer which will be set to point to the rotated map. |
[out] | ret | The rotation centre about which the rotation was done in Angstroms. |
Definition at line 718 of file ProSHADE_overlay.cpp.
721 bool withinBounds =
true;
722 proshade_double c000, c001, c010, c011, c100, c101, c110, c111, c00, c01, c10, c11, c0, c1;
724 proshade_double xCOM, yCOM, zCOM;
725 std::vector< proshade_double > ret;
728 proshade_single xSampRate = this->
xDimSize /
static_cast< proshade_single
> ( this->
xTo - this->
xFrom );
729 proshade_single ySampRate = this->
yDimSize /
static_cast< proshade_single
> ( this->
yTo - this->
yFrom );
730 proshade_single zSampRate = this->
zDimSize /
static_cast< proshade_single
> ( this->
zTo - this->
zFrom );
733 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 );
736 proshade_single *mins =
new proshade_single[3];
737 proshade_single *maxs =
new proshade_single[3];
738 proshade_single *rotMat =
new proshade_single[9];
739 proshade_single *rotVec;
740 proshade_single *interpMins =
new proshade_single[3];
741 proshade_single *interpMaxs =
new proshade_single[3];
742 proshade_single *interpDiff =
new proshade_single[3];
743 proshade_single *movs =
new proshade_single[3];
760 mins[0] = std::floor (
static_cast< proshade_single
> ( this->
xDimIndices ) / -2.0f );
761 mins[1] = std::floor (
static_cast< proshade_single
> ( this->
yDimIndices ) / -2.0f );
762 mins[2] = std::floor (
static_cast< proshade_single
> ( this->
zDimIndices ) / -2.0f );
768 if ( this->
xDimIndices % 2 == 0 ) { maxs[0] -= 1.0f; }
769 if ( this->
yDimIndices % 2 == 0 ) { maxs[1] -= 1.0f; }
770 if ( this->
zDimIndices % 2 == 0 ) { maxs[2] -= 1.0f; }
786 for ( proshade_single xIt = mins[0]; xIt <= maxs[0]; xIt += 1.0f )
788 for ( proshade_single yIt = mins[1]; yIt <= maxs[1]; yIt += 1.0f )
790 for ( proshade_single zIt = mins[2]; zIt <= maxs[2]; zIt += 1.0f )
797 for (
size_t posIt = 0; posIt < 3; posIt++ )
800 interpMins[posIt] = std::floor ( rotVec[posIt] );
801 interpMaxs[posIt] = interpMins[posIt] + 1.0f;
804 if ( ( maxs[posIt] < interpMins[posIt] ) || ( interpMins[posIt] < mins[posIt] ) || ( maxs[posIt] < interpMaxs[posIt] ) || ( interpMaxs[posIt] < mins[posIt] ) )
806 withinBounds =
false;
811 interpDiff[posIt] = rotVec[posIt] - interpMins[posIt];
813 if ( !withinBounds ) {
continue; }
816 for (
size_t posIt = 0; posIt < 3; posIt++ )
818 interpMaxs[posIt] = std::min ( maxs[posIt], std::max ( mins[posIt], interpMaxs[posIt] ) );
825 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] ) ) );
828 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] ) ) );
831 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] ) ) );
834 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] ) ) );
837 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] ) ) );
840 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] ) ) );
843 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] ) ) );
846 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] ) ) );
850 c00 = ( c000 * ( 1.0 -
static_cast< proshade_double
> ( interpDiff[0] ) ) ) + ( c100 *
static_cast< proshade_double
> ( interpDiff[0] ) );
851 c01 = ( c001 * ( 1.0 -
static_cast< proshade_double
> ( interpDiff[0] ) ) ) + ( c101 *
static_cast< proshade_double
> ( interpDiff[0] ) );
852 c10 = ( c010 * ( 1.0 -
static_cast< proshade_double
> ( interpDiff[0] ) ) ) + ( c110 *
static_cast< proshade_double
> ( interpDiff[0] ) );
853 c11 = ( c011 * ( 1.0 -
static_cast< proshade_double
> ( interpDiff[0] ) ) ) + ( c111 *
static_cast< proshade_double
> ( interpDiff[0] ) );
856 c0 = ( c00 * ( 1.0 -
static_cast< proshade_double
> ( interpDiff[1] ) ) ) + ( c10 *
static_cast< proshade_double
> ( interpDiff[1] ) );
857 c1 = ( c01 * ( 1.0 -
static_cast< proshade_double
> ( interpDiff[1] ) ) ) + ( c11 *
static_cast< proshade_double
> ( interpDiff[1] ) );
860 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] ) ) );
861 map[arrPos] = ( c0 * ( 1.0 -
static_cast< proshade_double
> ( interpDiff[2] ) ) ) + ( c1 *
static_cast< proshade_double
> ( interpDiff[2] ) );
◆ rotateMapRealSpaceInPlace()
std::vector< proshade_double > ProSHADE_internal_data::ProSHADE_data::rotateMapRealSpaceInPlace |
( |
proshade_double |
eulA, |
|
|
proshade_double |
eulB, |
|
|
proshade_double |
eulG |
|
) |
| |
This function rotates a map based on the given Euler angles in place.
This function takes the Euler angles of the required rotation and proceeds to make use of the rotateMapRealSpace () function to rotate the map in real space using trilinear interpolation, replacing the original map with the rotated one.
- Parameters
-
[in] | eulerAlpha | The rotation expressed as a pointer to Euler alpha angle. |
[in] | eulerBeta | The rotation expressed as a pointer to Euler beta angle. |
[in] | eulerGamma | The rotation expressed as a pointer to Euler gamma angle. |
[out] | ret | The rotation centre about which the rotation was done in Angstroms. |
Definition at line 891 of file ProSHADE_overlay.cpp.
894 proshade_double axX, axY, axZ, axAng, tmp, *rMat, *map;
897 rMat =
new proshade_double[9];
922 std::vector< proshade_double > ret = this->
rotateMapRealSpace ( axX, axY, axZ, axAng, map );
◆ 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] | settings | The settings object specifying how exactly the rotation is to be done. |
[in] | eulerAlpha | The rotation expressed as a pointer to Euler alpha angle. |
[in] | eulerBeta | The rotation expressed as a pointer to Euler beta angle. |
[in] | eulerGamma | The rotation expressed as a pointer to Euler gamma angle. |
Definition at line 657 of file ProSHADE_overlay.cpp.
681 std::vector<proshade_double> lonCO, latCO;
687 for (
unsigned int iter = 0; iter < static_cast<unsigned int> ( this->
xDimIndices * this->
yDimIndices * this->
zDimIndices ); iter++ ) { densityMapRotated[iter] = 0.0; }
699 delete[] densityMapRotated;
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | CSyms | A pointer to vector |
[in] | axes | A pointer to a vector to which all the axes of the recommended symmetry (if any) will be saved. |
[in] | allCs | A pointer to a vector to which all the detected cyclic symmetries will be saved into. |
Definition at line 2255 of file ProSHADE_data.cpp.
2258 bool isArgSameAsSettings =
true;
2261 for ( proshade_unsign cIt = 0; cIt < static_cast<proshade_unsign> ( CSyms->size() ); cIt++ )
2264 std::vector< proshade_double > nextSym;
2275 if ( ( cIt == 0 ) && ( settings->
allDetectedCAxes.size() == 0 ) ) { isArgSameAsSettings =
false; }
2280 delete[] CSyms->at(cIt);
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | CSym | A vector of pointers to double arrays, each array being a single Cyclic symmetry entry. |
[in] | DSym | A vector of pointers to double arrays, each array being a single Dihedral symmetry entry. |
[in] | TSym | A vector of pointers to double arrays, all of which together form the axes of tetrahedral symmetry. |
[in] | OSym | A vector of pointers to double arrays, all of which together form the axes of octahedral symmetry. |
[in] | ISym | A vector of pointers to double arrays, all of which together form the axes of icosahedral symmetry. |
[in] | axes | A vector to which all the axes of the recommended symmetry (if any) will be saved. |
[in] | mapData | FFTW complex array which will be the input for the Fourier transform done by the planForwardFourier plan. |
[in] | fCoeffs | FFTW complex array where the Fourier transform coefficients will be saved into by the planForwardFourier plan. |
[in] | origCoeffs | FFTW complex array holding already compute Fourier transform of the non-rotated map. |
[in] | planForwardFourier | A prepared FFTW3 plan for transforming the mapData onto fCoeffs. |
[in] | noBins | The number of bins as already pre-computed. |
[in] | binIndexing | A map of pre-computed bin assignments for each reflection in the format as outputted by FFTW. |
[in] | bindata | Pre-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] | binCounts | Pre-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 2596 of file ProSHADE_data.cpp.
2602 if ( CSym->size() == 0 )
2610 proshade_double step = 0.01;
2611 proshade_double sigma = 0.03;
2612 proshade_signed windowSize = 9;
2613 proshade_double bestHistPeakStart = this->
findTopGroupSmooth ( CSym, 5, step, sigma, windowSize );
2617 proshade_unsign noPassed = 0;
for (
size_t cIt = 0; cIt < CSym->size(); cIt++ ) {
if ( CSym->at(cIt)[5] > bestHistPeakStart ) { noPassed += 1; } }
2618 std::stringstream ss;
2619 ss <<
"Smoothening has resolved in " << noPassed <<
" C symmetries.";
2624 bool alreadyDecided =
false;
2625 if ( ISym->size() == 31 )
2628 proshade_double fscVal = 0.0;
2629 proshade_double fscValAvg = 0.0;
2632 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; } }
2645 alreadyDecided =
true;
2650 if ( ( OSym->size() == 13 ) && !alreadyDecided )
2653 proshade_double fscVal = 0.0;
2654 proshade_double fscValAvg = 0.0;
2657 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; } }
2670 alreadyDecided =
true;
2675 if ( ( TSym->size() == 7 ) && !alreadyDecided )
2678 proshade_double fscVal = 0.0;
2679 proshade_double fscValAvg = 0.0;
2682 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; } }
2695 alreadyDecided =
true;
2700 if ( ( settings->
allDetectedDAxes.size() > 0 ) && ( DSym->size() > 0 ) && !alreadyDecided )
2703 proshade_signed bestD = -1;
2704 proshade_unsign bestFold = 0;
2710 if ( dIt > 20 ) {
continue; }
2713 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 ) );
2714 if ( ( CSym->at(settings->
allDetectedDAxes.at(dIt).at(0))[5] < bestHistPeakStart ) && !( lhs999a.AlmostEquals( rhs999 ) ) ) {
continue; }
2715 if ( ( CSym->at(settings->
allDetectedDAxes.at(dIt).at(1))[5] < bestHistPeakStart ) && !( lhs999b.AlmostEquals( rhs999 ) ) ) {
continue; }
2718 this->
computeFSC ( settings, CSym, settings->
allDetectedDAxes.at(dIt).at(0), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2719 this->
computeFSC ( settings, CSym, settings->
allDetectedDAxes.at(dIt).at(1), mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2723 proshade_double bestHistFSCStart = this->
findTopGroupSmooth ( CSym, 5, step, sigma, windowSize );
2729 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 ) );
2730 if ( ( CSym->at(settings->
allDetectedDAxes.at(dIt).at(0))[5] < bestHistPeakStart ) && !( lhs999a2.AlmostEquals( rhs999 ) ) ) {
continue; }
2731 if ( ( CSym->at(settings->
allDetectedDAxes.at(dIt).at(1))[5] < bestHistPeakStart ) && !( lhs999b2.AlmostEquals( rhs999 ) ) ) {
continue; }
2734 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 ) ) )
2739 if ( std::max ( CSym->at(settings->
allDetectedDAxes.at(dIt).at(0))[6], CSym->at(settings->
allDetectedDAxes.at(dIt).at(1))[6] ) < bestHistFSCStart ) {
continue; }
2742 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] ) );
2743 bestD =
static_cast< proshade_signed
> ( dIt );
2752 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] ) ) );
2762 alreadyDecided =
true;
2767 if ( ( CSym->size() > 0 ) && !alreadyDecided )
2770 proshade_signed bestC = -1;
2771 proshade_unsign bestFold = 0;
2774 for (
size_t cIt = 0; cIt < CSym->size(); cIt++ )
2777 if ( cIt > 20 ) {
continue; }
2780 if ( CSym->at(cIt)[5] < bestHistPeakStart ) {
continue; }
2783 this->
computeFSC ( settings, CSym, cIt, mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2787 proshade_double bestHistFSCStart = this->
findTopGroupSmooth ( CSym, 6, step, sigma, windowSize );
2790 for (
size_t cIt = 0; cIt < CSym->size(); cIt++ )
2793 if ( CSym->at(cIt)[0] >
static_cast< proshade_double
> ( bestFold ) )
2796 if ( ( CSym->at(cIt)[6] > settings->
fscThreshold ) && ( CSym->at(cIt)[6] >= bestHistFSCStart ) )
2798 bestFold =
static_cast< proshade_unsign
> ( CSym->at(cIt)[0] );
2799 bestC =
static_cast< proshade_signed
> ( cIt );
2809 settings->
setRecommendedFold (
static_cast< proshade_unsign
> ( CSym->at(
static_cast< size_t > ( bestC ) )[0] ) );
2814 alreadyDecided =
true;
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | CSym | A vector of pointers to double arrays, each array being a single Cyclic symmetry entry. |
[in] | axes | A vector to which all the axes of the requested symmetry (if any) will be saved. |
Definition at line 2834 of file ProSHADE_data.cpp.
2837 proshade_unsign bestIndex = 0;
2838 proshade_double highestSym = 0.0;
2841 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( CSym->size() ); iter++ )
2844 const FloatingPoint< proshade_double > lhs1 ( CSym->at(iter)[0] ), rhs1 (
static_cast< proshade_double
> ( settings->
requestedSymmetryFold ) );
2845 if ( !lhs1.AlmostEquals ( rhs1 ) ) {
continue; }
2848 if ( CSym->at(iter)[5] > highestSym )
2850 highestSym = CSym->at(iter)[5];
2856 if ( highestSym > 0.0 )
2859 settings->
setRecommendedFold (
static_cast< proshade_unsign
> ( CSym->at(bestIndex)[0] ) );
◆ 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] | settings | A pointer to settings class containing all the information required for map symmetry detection. |
[in] | DSym | A vector of pointers to double arrays, each array being a single Dihedral symmetry entry. |
[in] | axes | A vector to which all the axes of the requested symmetry (if any) will be saved. |
Definition at line 2886 of file ProSHADE_data.cpp.
2889 proshade_unsign bestIndex = 0;
2890 proshade_double highestSym = 0.0;
2893 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( DSym->size() ); iter++ )
2896 const FloatingPoint< proshade_double > lhs1 ( std::max ( DSym->at(iter)[0], DSym->at(iter)[7] ) ), rhs1 (
static_cast< proshade_double
> ( settings->
requestedSymmetryFold ) );
2897 if ( !lhs1.AlmostEquals ( rhs1 ) ) {
continue; }
2900 const FloatingPoint< proshade_double > lhs999a ( DSym->at(iter)[5] ), lhs999b ( DSym->at(iter)[12] ), rhs999 (
static_cast< proshade_double
> ( -999.9 ) );
2901 if ( ( DSym->at(iter)[5] < settings->
peakThresholdMin ) && !( lhs999a.AlmostEquals( rhs999 ) ) ) {
continue; }
2902 if ( ( DSym->at(iter)[12] < settings->
peakThresholdMin ) && !( lhs999b.AlmostEquals( rhs999 ) ) ) {
continue; }
2905 this->
computeFSC ( settings, &DSym->at(iter)[0], mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2906 this->
computeFSC ( settings, &DSym->at(iter)[7], mapData, fCoeffs, origCoeffs, planForwardFourier, noBins, binIndexing, bindata, binCounts );
2909 if ( ( DSym->at(iter)[6] + DSym->at(iter)[13] ) > highestSym )
2911 highestSym = ( DSym->at(iter)[6] + DSym->at(iter)[13] );
2917 if ( highestSym > 0.0 )
2920 settings->
setRecommendedFold (
static_cast< proshade_unsign
> ( std::max ( DSym->at(bestIndex)[0], DSym->at(bestIndex)[7] ) ) );
◆ 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] | band | The band indice of the E matrix to which the value should be assigned. |
[in] | order1 | The first order indice of the E matrix to which the value should be assigned. |
[in] | order2 | The second order indice of the E matrix to which the value should be assigned. |
[in] | val | The value which should be saved. |
Definition at line 4097 of file ProSHADE_data.cpp.
4100 this->
eMatrices[band][order1][order2][0] = val[0];
4101 this->
eMatrices[band][order1][order2][1] = val[1];
◆ setIntegrationWeight()
void ProSHADE_internal_data::ProSHADE_data::setIntegrationWeight |
( |
proshade_double |
intW | ) |
|
This function allows setting the integration weight for the object.
- Parameters
-
[in] | intW | The integration weight to be set for this object. |
Definition at line 4066 of file ProSHADE_data.cpp.
◆ setIntegrationWeightCumul()
void ProSHADE_internal_data::ProSHADE_data::setIntegrationWeightCumul |
( |
proshade_double |
intW | ) |
|
This function allows setting the cumulative integration weight for the object.
- Parameters
-
[in] | intW | The integration weight to be added to the current value for this object. |
Definition at line 4080 of file ProSHADE_data.cpp.
◆ 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 937 of file ProSHADE_data.cpp.
◆ 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] | position | The 1D array position at which the new value should be saved. |
[in] | val | Complex value to be saved into the array. |
Definition at line 4131 of file ProSHADE_data.cpp.
◆ 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] | val | proshade_complex value of the Wigner D matrix at position band, order1, order2. |
[in] | band | The band of the Wigner D matrix value. |
[in] | order1 | The first order of the Wigner D matrix value. |
[in] | order2 | The second order of the Wigner D matrix value. |
Definition at line 4149 of file ProSHADE_data.cpp.
◆ 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] | shell | The index (number) of the shell for which the check should be done. |
[in] | bandVal | The band value which should be sought for the shell. |
[out] | X | True if the shell has the band, false otherwise. |
Definition at line 3625 of file ProSHADE_data.cpp.
3627 if ( this->
spheres[shell]->getLocalBandwidth( ) >= bandVal )
◆ 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] | order1 | The first order for which the SO(3) value index is requested. |
[in] | order2 | The second order for which the SO(3) value index is requested. |
[in] | band | The band for which the SO(3) value index is requested. |
[out] | val | Index position of the SO(3) value. |
Definition at line 4245 of file ProSHADE_data.cpp.
4248 return (
static_cast<int> ( so3CoefLoc (
static_cast< int > ( order1 ),
static_cast< int > ( order2 ),
static_cast< int > ( band ),
static_cast< int > ( this->
getMaxBand() ) ) ) );
◆ 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] | settings | The settings object specifying how exactly the rotation is to be done. |
[in] | trsX | The translation expressed as a number of angstroms to move by along the x-axis. |
[in] | trsY | The translation expressed as a number of angstroms to move by along the y-axis. |
[in] | trsZ | The translation expressed as a number of angstroms to move by along the z-axis. |
Definition at line 954 of file ProSHADE_overlay.cpp.
957 proshade_single xMov =
static_cast< proshade_single
> ( -trsX );
958 proshade_single yMov =
static_cast< proshade_single
> ( -trsY );
959 proshade_single zMov =
static_cast< proshade_single
> ( -trsZ );
968 static_cast< proshade_signed
> ( this->
getXDim() ),
static_cast< proshade_signed
> ( this->
getYDim() ),
969 static_cast< proshade_signed
> ( this->
getZDim() ) );
◆ writeGemmi()
void ProSHADE_internal_data::ProSHADE_data::writeGemmi |
( |
std::string |
fName, |
|
|
gemmi::Structure |
gemmiStruct, |
|
|
proshade_double |
euA = 0.0 , |
|
|
proshade_double |
euB = 0.0 , |
|
|
proshade_double |
euG = 0.0 , |
|
|
proshade_double |
trsX = 0.0 , |
|
|
proshade_double |
trsY = 0.0 , |
|
|
proshade_double |
trsZ = 0.0 , |
|
|
proshade_double |
rotX = 0.0 , |
|
|
proshade_double |
rotY = 0.0 , |
|
|
proshade_double |
rotZ = 0.0 , |
|
|
bool |
firstModel = true |
|
) |
| |
This function writes out the gemmi::Structure object with ProSHADE type rotation and translation applied.
This function takes loaded gemmi::Structure object and applies specific rotation and translations to it. These are intended to be the results of ProSHADE Overlay mode compuations, but could be anything else, as long as the usage is correct. Finally, it writes out a PDB formatted file with the now positions.
- Parameters
-
[in] | fName | The filename (including path) to where the output PDB file should be saved. |
[in] | gemmiStruct | gemmi::Structure object which should be modified and written out. |
[in] | euA | The Euler angle alpha by which the co-ordinates should be rotated (leave empty if no rotation is required). |
[in] | euB | The Euler angle beta by which the co-ordinates should be rotated (leave empty if no rotation is required). |
[in] | euG | The Euler angle gamma by which the co-ordinates should be rotated (leave empty if no rotation is required). |
[in] | trsX | The translation to be done along X-axis in Angstroms. |
[in] | trsY | The translation to be done along Y-axis in Angstroms. |
[in] | trsZ | The translation to be done along Z-axis in Angstroms. |
[in] | rotX | The translation to be done along X-axis in Angstroms. |
[in] | rotY | The translation to be done along Y-axis in Angstroms. |
[in] | rotZ | The translation to be done along Z-axis in Angstroms. |
[in] | firstModel | Should only the first model, or rather all of them be used? |
Definition at line 1109 of file ProSHADE_data.cpp.
1112 if ( ( euA != 0.0 ) || ( euB != 0.0 ) || ( euG != 0.0 ) )
1122 std::ofstream outCoOrdFile;
1123 outCoOrdFile.open ( fName.c_str() );
1125 if ( outCoOrdFile.is_open() )
1127 gemmi::PdbWriteOptions opt;
1128 write_pdb ( gemmiStruct, outCoOrdFile, opt );
1132 std::stringstream hlpMessage;
1133 hlpMessage <<
"Failed to open the PDB file " << fName <<
" for output.";
1134 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." );
1137 outCoOrdFile.close ( );
◆ 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] | fName | The filename (including path) to where the output MAP file should be saved. |
[in] | title | String with the map title to be written into the header - default value is "Created by ProSHADE and written by GEMMI" |
[in] | mode | The type of the data, leave at default 2 (mean float type) unless you specifically required other types. |
Definition at line 1005 of file ProSHADE_data.cpp.
1008 gemmi::Grid<float> mapData;
1009 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 ) );
1010 mapData.set_size_without_checking (
static_cast< int > ( this->
xDimIndices ),
static_cast< int > ( this->
yDimIndices ),
static_cast< int > ( this->
zDimIndices ) );
1011 mapData.axis_order = gemmi::AxisOrder::XYZ;
1012 mapData.spacegroup = &gemmi::get_spacegroup_p1();
1015 gemmi::Ccp4<float> map;
1017 map.update_ccp4_header ( mode );
1031 proshade_unsign arrPos = 0;
1032 for ( proshade_unsign uIt = 0; uIt < this->
xDimIndices; uIt++ )
1034 for ( proshade_unsign vIt = 0; vIt < this->
yDimIndices; vIt++ )
1036 for ( proshade_unsign wIt = 0; wIt < this->
zDimIndices; wIt++ )
1038 arrPos = wIt + this->zDimIndices * ( vIt + this->yDimIndices * uIt );
1039 map.grid.set_value (
static_cast< int > ( uIt ),
static_cast< int > ( vIt ),
static_cast< int > ( wIt ),
static_cast<float> ( this->
internalMap[arrPos] ) );
1045 map.update_ccp4_header ( mode,
true );
1048 map.write_ccp4_map ( fName );
◆ 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] | fileName | The filename (including path) to where the output should be saved. |
[in] | mask | Pointer to the mask map array. |
Definition at line 1151 of file ProSHADE_data.cpp.
◆ 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] | settings | A pointer to settings class containing all the information required for map manipulation. |
[in] | eulA | The Euler alpha angle value, by which the moving structure is to be rotated by. |
[in] | eulB | The Euler beta angle value, by which the moving structure is to be rotated by. |
[in] | eulG | The Euler gamma angle value, by which the moving structure is to be rotated by. |
[in] | rotCentre | The rotation centre position. |
[in] | ultimateTranslation | The final translation as determined by the translation function. |
Definition at line 4457 of file ProSHADE_data.cpp.
4460 std::stringstream fNameHlp;
4469 this->
writePdb ( fNameHlp.str(), eulA, eulB, eulG, ultimateTranslation->at(0), ultimateTranslation->at(1), ultimateTranslation->at(2), rotCentre->at(0), rotCentre->at(1), rotCentre->at(2), settings->
firstModelOnly );
4475 ultimateTranslation->at(0), ultimateTranslation->at(1), ultimateTranslation->at(2),
◆ writePdb()
void ProSHADE_internal_data::ProSHADE_data::writePdb |
( |
std::string |
fName, |
|
|
proshade_double |
euA = 0.0 , |
|
|
proshade_double |
euB = 0.0 , |
|
|
proshade_double |
euG = 0.0 , |
|
|
proshade_double |
trsX = 0.0 , |
|
|
proshade_double |
trsY = 0.0 , |
|
|
proshade_double |
trsZ = 0.0 , |
|
|
proshade_double |
rotX = 0.0 , |
|
|
proshade_double |
rotY = 0.0 , |
|
|
proshade_double |
rotZ = 0.0 , |
|
|
bool |
firstModel = true |
|
) |
| |
This function writes out the co-ordinates file with ProSHADE type rotation and translation applied.
This function first checks if this internal structure originated from co-ordinate file (only if co-ordinates are provided can they be written out). If so, it will proceed to read in the original co-ordinates into gemmi::Structure object and call the gemmi writing out function.
- Parameters
-
[in] | fName | The filename (including path) to where the output PDB file should be saved. |
[in] | euA | The Euler angle alpha by which the co-ordinates should be rotated (leave empty if no rotation is required). |
[in] | euB | The Euler angle beta by which the co-ordinates should be rotated (leave empty if no rotation is required). |
[in] | euG | The Euler angle gamma by which the co-ordinates should be rotated (leave empty if no rotation is required). |
[in] | trsX | The translation to be done along X-axis in Angstroms. |
[in] | trsY | The translation to be done along Y-axis in Angstroms. |
[in] | trsZ | The translation to be done along Z-axis in Angstroms. |
[in] | rotX | The translation to be done along X-axis in Angstroms. |
[in] | rotY | The translation to be done along Y-axis in Angstroms. |
[in] | rotZ | The translation to be done along Z-axis in Angstroms. |
[in] | firstModel | Should only the first model, or rather all of them be used? |
Definition at line 1072 of file ProSHADE_data.cpp.
1077 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." );
1081 gemmi::Structure pdbFile = gemmi::read_structure ( gemmi::MaybeGzipped ( this->
fileName ) );
1084 this->
writeGemmi ( fName, pdbFile, euA, euB, euG, trsX, trsY, trsZ, rotX, rotY, rotZ, firstModel );
◆ 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] | xDim | The X dimension size to which this structure should be padded into. |
[in] | yDim | The Y dimension size to which this structure should be padded into. |
[in] | zDim | The Z dimension size to which this structure should be padded into. |
Definition at line 519 of file ProSHADE_overlay.cpp.
524 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." );
531 proshade_unsign addXPre, addYPre, addZPre, addXPost, addYPost, addZPost;
532 ProSHADE_internal_overlay::computeBeforeAfterZeroCounts ( &addXPre, &addYPre, &addZPre, &addXPost, &addYPost, &addZPost, xDim, yDim, zDim, this->
xDimIndices, this->
yDimIndices, this->
zDimIndices );
535 proshade_double* newMap =
new proshade_double [xDim * yDim * zDim];
538 ProSHADE_internal_overlay::paddMapWithZeroes ( this->
internalMap, newMap, xDim, yDim, zDim, this->
xDimIndices, this->
yDimIndices, this->
zDimIndices, addXPre, addYPre, addZPre );
542 this->
internalMap =
new proshade_double [xDim * yDim * zDim];
543 for ( proshade_unsign iter = 0; iter < static_cast<proshade_unsign> ( xDim * yDim * zDim ); iter++ ) { this->
internalMap[iter] = newMap[iter]; }
549 this->
xDimSize =
static_cast< proshade_single
> ( xDim ) * ( this->
xDimSize /
static_cast< proshade_single
> ( this->
xDimIndices ) );
550 this->
yDimSize =
static_cast< proshade_single
> ( yDim ) * ( this->
yDimSize /
static_cast< proshade_single
> ( this->
yDimIndices ) );
551 this->
zDimSize =
static_cast< proshade_single
> ( zDim ) * ( this->
zDimSize /
static_cast< proshade_single
> ( this->
zDimIndices ) );
554 this->
xFrom -= addXPre ; this->
yFrom -= addYPre ; this->
zFrom -= addZPre;
555 this->
xTo += addXPost; this->
yTo += addYPost; this->
zTo += addZPost;
The documentation for this class was generated from the following files:
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.
proshade_double noIQRsFromMedianNaivePeak
When doing peak searching, how many IQRs from the median the threshold for peak height should be (in ...
void normaliseEMatrices(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function normalises the E matrices.
bool sortProSHADESymmetryByPeak(proshade_double *a, proshade_double *b)
This function allows using std::sort to sort vectors of ProSHADE symmetry format..
proshade_double originalMapYCom
The COM of the first map to be loaded/computed without any furhter changes being reflacted along the ...
proshade_unsign maxBandwidth
The bandwidth of spherical harmonics decomposition for the largest sphere.
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.
proshade_double mapMovFromsChangeX
When the map is translated, the xFrom and xTo values are changed. This variable holds how much they h...
std::string recommendedSymmetryType
The symmetry type that ProSHADE finds the best fitting for the structure. Possible values are "" for ...
void allocateRotatedSHMemory(void)
This function allocates the memory required for storing the rotated Spherical Harmonics coefficients.
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.
std::string fileName
This is the original file from which the data were obtained.
proshade_signed zFrom
This is the starting index along the z axis.
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...
std::string rotTrsJSONFile
The filename to which the rotation and translation operations are to be saved into.
proshade_unsign xDimIndices
This is the size of the map cell x dimension in indices.
proshade_single getZDimSize(void)
This function allows access to the map size in angstroms along the Z axis.
void changePDBBFactors(gemmi::Structure *pdbFile, proshade_double newBFactorValue, bool firstModel)
Function for changing the PDB B-factor values to a specific single value.
void readInMAP(ProSHADE_settings *settings, proshade_double *maskArr=nullptr, proshade_unsign maskXDim=0, proshade_unsign maskYDim=0, proshade_unsign maskZDim=0, proshade_double *weightsArr=nullptr, proshade_unsign weigXDim=0, proshade_unsign weigYDim=0, proshade_unsign weigZDim=0)
Function for reading map data using gemmi library.
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.
proshade_single zDimSizeOriginal
This is the size of the map cell z dimension in Angstroms.
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 ...
void vectorMeanAndSD(std::vector< proshade_double > *vec, proshade_double *&ret)
Function to get vector mean and standard deviation.
void addToDblPtrVector(std::vector< proshade_double * > *vecToAddTo, proshade_double *elementToAdd)
Adds the element to the vector.
bool isFilePDB(std::string fName)
Function determining if the input data type is PDB.
proshade_unsign getLocalBandwidth(void)
This function returns the local bandwidth.
proshade_unsign maxSymmetryFold
The highest symmetry fold to search for.
proshade_unsign xGridIndices
As far as I know, this is identical to the xDimIndices.
proshade_complex * translationMap
This is where the translation map will be held, if at all used.
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.
proshade_unsign xAxisOrder
This is the order of the x axis.
proshade_complex ** rotSphericalHarmonics
A set of rotated spherical harmonics values arrays for each sphere, used only if map rotation is requ...
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.
proshade_complex ** sphericalHarmonics
A set of spherical harmonics values arrays for each sphere.
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.
void interpolateMapFromSpheres(proshade_double *&densityMapRotated)
This function interpolates the density map from the sphere mapped data.
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 ...
proshade_single cAngle
This is the angle c of the map cell in degrees.
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.
proshade_complex * so3CoeffsInverse
The inverse coefficients obtained by inverse SO(3) Fourier Transform (SOFT) - i.e....
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.
proshade_signed * getXAxisOrigin(void)
This function allows access to the map X axis origin value.
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...
proshade_double yCom
The COM of the map after processing along the Y-axis.
proshade_single boundsExtraSpace
The number of extra angstroms to be added to all re-boxing bounds just for safety.
This class contains all inputed data for the rotation function angle-axis converted spheres.
This class is the representation of ProSHADE exception.
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...
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.
std::vector< std::vector< proshade_unsign > > allDetectedDAxes
The vector of all detected dihedral symmetry axes indices in allDetectedCAxes.
proshade_single blurFactor
This is the amount by which B-factors should be increased to create the blurred map for masking.
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.
bool maskMap
Should the map be masked from noise?
proshade_unsign requestedSymmetryFold
The fold of the requested symmetry (only applicable to C and D symmetry types).
std::string requestedSymmetryType
The symmetry type requested by the user. Allowed values are C, D, T, O and I.
void allocateRRPMemory()
This function allocates the required memory for the RRP matrices.
proshade_single getXDimSize(void)
This function allows access to the map size in angstroms along the X axis.
void addToUnsignVectorVector(std::vector< std::vector< proshade_unsign > > *vecToAddTo, std::vector< proshade_unsign > elementToAdd)
Adds the element to the vector of vectors.
proshade_double *& getInternalMap(void)
This function allows access to the first map array value address.
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.
proshade_unsign noSpheres
The number of spheres with map projected onto them.
bool removeNegativeDensity
Should the negative density be removed from input files?
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...
void printSymmetryCompletion(proshade_unsign noSyms, proshade_signed verbose)
This function simply prints the summary and warnings for cyclic symmetries detection completion.
proshade_single getYDimSize(void)
This function allows access to the map size in angstroms along the Y axis.
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.
proshade_unsign inputOrder
This value is the input order - it is useful to know for writing out files, so that they would not ov...
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.
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.
proshade_single zDimSize
This is the size of the map cell z dimension in Angstroms.
proshade_complex * so3Coeffs
The coefficients obtained by SO(3) Fourier Transform (SOFT), in this case derived from the E matrices...
bool saveMask
Should the mask be saved?
proshade_single requestedResolution
The resolution to which the calculations are to be done.
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.
proshade_double mapCOMProcessChangeX
The change in X axis between the creation of the structure (originalMapXCom) and just before rotation...
proshade_double minSymPeak
Minimum average peak for symmetry axis to be considered as "real".
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.
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.
proshade_double originalMapXCom
The COM of the first map to be loaded/computed without any furhter changes being reflacted along the ...
void setDetectedSymmetry(proshade_double *sym)
Sets the final detected symmetry axes information.
proshade_unsign xDimIndicesOriginal
This is the size of the map cell x dimension in indices.
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.
bool progressiveSphereMapping
If true, each shell will have its own angular resolution dependent on the actual number of map points...
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.
proshade_single maxSphereDists
The distance between spheres in spherical mapping for the largest sphere.
proshade_unsign maxShellBand
The maximum band for any shell of the object.
proshade_double symMissPeakThres
Percentage of peaks that could be missing that would warrant starting the missing peaks search proced...
proshade_double originalPdbRotCenY
The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map...
void getSpherePositions(ProSHADE_settings *settings)
This function determines the sphere positions (radii) for sphere mapping.
void invertMirrorMap(ProSHADE_settings *settings)
Function for inverting the map to its mirror image.
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).
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.
bool checkElementsFormGroup(std::vector< std::vector< proshade_double > > *elements, proshade_double matrixTolerance)
This function checks if all group element products produce another group element.
std::vector< proshade_double > getMapCOMProcessChange(void)
This function allows access to the translation caused by structure processing.
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...
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.
proshade_double mapCOMProcessChangeZ
The change in Z axis between the creation of the structure (originalMapZCom) and just before rotation...
proshade_single maskingThresholdIQRs
Number of inter-quartile ranges from the median to be used for thresholding the blurred map for maski...
bool usePhase
If true, the full data will be used, if false, Patterson maps will be used instead and phased data wi...
proshade_single xDimSizeOriginal
This is the size of the map cell x dimension in Angstroms.
std::vector< proshade_unsign > allDetectedTAxes
The vector of all detected tetrahedral symmetry axes indices in allDetectedCAxes.
void printWarningMessage(proshade_signed verbose, std::string message, std::string warnCode)
General stderr message printing (used for warnings).
InputType figureDataType(std::string fName)
Function determining input data type.
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.
proshade_signed zAxisOriginOriginal
This is the origin position along the z axis.
This class contains all inputed and derived data for a single sphere.
proshade_double getRotatedMappedData(proshade_unsign pos)
This function gets the rotated mapped data value for a particular position.
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.
std::string maskFileName
The filename to which mask should be saved.
std::vector< proshade_unsign > allDetectedOAxes
The vector of all detected octahedral symmetry axes indices in allDetectedCAxes.
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...
proshade_complex *** eMatrices
The trace sigma and full rotation function c*conj(c) integral tables.
void centreMapOnCOM(ProSHADE_settings *settings)
This function shits the map so that its COM is in the centre of the map.
proshade_signed * getXFromPtr(void)
This function allows access to the map start along the X axis.
proshade_signed verbose
Should the software report on the progress, or just be quiet? Value between -1 (nothing) and 4 (loud)
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.
proshade_unsign yDimIndices
This is the size of the map cell y dimension in indices.
proshade_signed xAxisOriginOriginal
This is the origin position along the x axis.
proshade_unsign yGridIndices
As far as I know, this is identical to the yDimIndices.
bool changeMapResolutionTriLinear
Should maps be re-sampled to obtain the required resolution?
proshade_signed zAxisOrigin
This is the origin position along the z axis.
void addToDoubleVector(std::vector< proshade_double > *vecToAddTo, proshade_double elementToAdd)
Adds the element to the vector.
void setPDBMapValues(void)
Function for determining iterator start and stop positions.
void findMapCOM(void)
This function finds the centre of mass of the internal map representation.
proshade_unsign yDimIndicesOriginal
This is the size of the map cell y dimension in indices.
proshade_unsign getXDim(void)
This function allows access to the map size in indices along the X axis.
void removeWaters(gemmi::Structure *pdbFile, bool firstModel)
This function removed all waters from PDB input file.
bool useBiCubicInterpolationOnPeaks
This variable switch decides whether best symmetry is detected from peak indices, or whether bicubic ...
proshade_double originalPdbTransX
The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE inte...
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.
proshade_signed zTo
This is the final index along the z axis.
proshade_signed xTo
This is the final index along the x axis.
void writeMask(std::string fName, proshade_double *mask)
Function for writing out a mask in MRC MAP format.
proshade_double integrationWeight
The Pearson's c.c. type weighting for the integration.
proshade_double peakThresholdMin
The threshold for peak height above which axes are considered possible.
std::vector< proshade_signed > findPeaks1D(std::vector< proshade_double > data)
This function simply finds all the peaks in a 1D data array.
proshade_signed xAxisOrigin
This is the origin position along the x axis.
proshade_double originalPdbTransY
The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE inte...
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.
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.
proshade_double *** rrpMatrices
The energy levels descriptor shell correlation tables.
proshade_signed yTo
This is the final index along the y axis.
bool forceP1
Should the P1 spacegroup be forced on the input PDB files?
proshade_single xDimSize
This is the size of the map cell x dimension in Angstroms.
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.
void computeRotatedSH(void)
This function multiplies the objects spherical harmonics with the Wigner D matrices,...
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.
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...
proshade_double mapMovFromsChangeY
When the map is translated, the yFrom and yTo values are changed. This variable holds how much they h...
proshade_signed yAxisOrigin
This is the origin position along the y axis.
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.
void deepCopyAxisToDblPtrVector(std::vector< proshade_double * > *dblPtrVec, proshade_double *axis)
Does a deep copy of a double array to a vector of double arrays.
proshade_unsign yAxisOrder
This is the order of the y axis.
proshade_double * internalMap
The internal map data representation, which may be amended as the run progresses.
void writePdb(std::string fName, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true)
This function writes out the co-ordinates file with ProSHADE type rotation and translation applied.
proshade_unsign zDimIndicesOriginal
This is the size of the map cell z dimension in indices.
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...
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.
proshade_signed xFrom
This is the starting index along the x axis.
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.
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.
proshade_unsign getMaxBand(void)
This function returns the maximum band value for the object.
std::string appliedMaskFileName
The filename from which mask data will be read from.
void invertSHCoefficients(void)
This function computes the shell mapped data from inverting the Spherical Harmonics coefficients.
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...
bool normaliseMap
Should the map be normalised to mean 0 sd 1?
void writeGemmi(std::string fName, gemmi::Structure gemmiStruct, proshade_double euA=0.0, proshade_double euB=0.0, proshade_double euG=0.0, proshade_double trsX=0.0, proshade_double trsY=0.0, proshade_double trsZ=0.0, proshade_double rotX=0.0, proshade_double rotY=0.0, proshade_double rotZ=0.0, bool firstModel=true)
This function writes out the gemmi::Structure object with ProSHADE type rotation and translation appl...
proshade_single addExtraSpace
If this value is non-zero, this many angstroms of empty space will be added to the internal map.
proshade_unsign getYDim(void)
This function allows access to the map size in indices along the Y axis.
proshade_unsign maxCompBand
The largest comparison band - this variable tells how large arrays will be allocated for the comparis...
void maskMap(ProSHADE_settings *settings)
Function for computing the map mask using blurring and X IQRs from median.
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.
proshade_double xCom
The COM of the map after processing along the X-axis.
proshade_double fscThreshold
The threshold for FSC value under which the axis is considered to be likely noise.
void readInGemmi(gemmi::Structure gemmiStruct, ProSHADE_settings *settings)
Function for reading co-ordinate data from Gemmi object.
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.
proshade_double originalPdbTransZ
The optimal translation vector as it relates to the original PDB positions (and not the ProSHADE inte...
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.
void applyMask(proshade_double *&map, std::string maskFile, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_signed verbose, proshade_double *maskArray=nullptr, proshade_unsign maXInds=0, proshade_unsign maYInds=0, proshade_unsign maZInds=0)
This function reads and applies the mask to the map.
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.
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.
proshade_complex * getTranslationFnPointer(void)
This function allows access to the translation function through a pointer.
void setRecommendedSymmetry(std::string val)
Sets the ProSHADE detected symmetry type.
proshade_double zCom
The COM of the map after processing along the Z-axis.
std::vector< proshade_single > spherePos
Vector of sphere radii from the centre of the map.
bool invertMap
Should the map be inverted? Only use this if you think you have the wrong hand in your map.
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.
proshade_unsign getZDim(void)
This function allows access to the map size in indices along the Z axis.
void removeMapPhase(fftw_complex *&mapCoeffs, proshade_unsign xDim, proshade_unsign yDim, proshade_unsign zDim)
This function removes the phase from reciprocal (frequency) map.
proshade_signed boundsSimilarityThreshold
Number of indices which can be added just to make sure same size in indices is achieved.
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.
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.
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.
bool changeMapResolution
Should maps be re-sampled to obtain the required resolution?
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.
proshade_double mapMovFromsChangeZ
When the map is translated, the zFrom and zTo values are changed. This variable holds how much they h...
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...
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.
This class contains peak groups detected in the rotation function mapped spheres.
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...
std::string overlayStructureName
The filename to which the rotated and translated moving structure is to be saved.
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.
proshade_double getMapValue(proshade_unsign pos)
This function returns the internal map representation value of a particular array position.
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.
proshade_signed * getYToPtr(void)
This function allows access to the map last position along the Y axis.
bool moveToCOM
Logical value stating whether the structure should be moved to have its Centre Of Mass (COM) in the m...
proshade_unsign peakNeighbours
Number of points in any direction that have to be lower than the considered index in order to conside...
proshade_complex *** wignerMatrices
These matrices are computed for a particular rotation to be done in spherical harmonics.
ProSHADE_internal_io::InputType fileType
This is the type of the input file.
std::vector< proshade_double > rotateMapRealSpace(proshade_double axX, proshade_double axY, proshade_double axZ, proshade_double axAng, proshade_double *&map)
This function rotates a map based on the given angle-axis rotation.
proshade_signed * getZAxisOrigin(void)
This function allows access to the map Z axis origin value.
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.
proshade_double smoothingFactor
This factor decides how small the group sizes should be - larger factor means more smaller groups.
proshade_signed myRound(proshade_double x)
Calls the appropriate version of round function depending on compiler version.
proshade_single yDimSizeOriginal
This is the size of the map cell y dimension in Angstroms.
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.
proshade_unsign zAxisOrder
This is the order of the z axis.
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.
void reSampleMap(ProSHADE_settings *settings)
This function changes the internal map sampling to conform to particular resolution value.
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.
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.
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.
proshade_signed * getXToPtr(void)
This function allows access to the map last position along the X axis.
proshade_signed * getYFromPtr(void)
This function allows access to the map start along the Y axis.
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.
proshade_double mapCOMProcessChangeY
The change in Y axis between the creation of the structure (originalMapYCom) and just before rotation...
proshade_single bAngle
This is the angle b of the map cell in degrees.
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.
proshade_signed yAxisOriginOriginal
This is the origin position along the y axis.
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.
proshade_single aAngle
This is the angle a of the map cell in degrees.
void addToDoubleVectorVector(std::vector< std::vector< proshade_double > > *vecToAddTo, std::vector< proshade_double > elementToAdd)
Adds the element to the vector of vectors.
void figureIndexStartStop(void)
Function for determining iterator start and stop positions.
bool isEmpty
This variable stated whether the class contains any information.
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...
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.
proshade_complex * getInvSO3Coeffs(void)
This function allows access to the inverse SO(3) coefficients array.
std::vector< proshade_unsign > allDetectedIAxes
The vector of all detected icosahedral symmetry axes indices in allDetectedCAxes.
proshade_signed * forceBounds
These will be the boundaries to be forced upon the map.
std::string fourierWeightsFileName
The filename from which Fourier weights data will be read from.
std::vector< proshade_double * > detectedSymmetry
The vector of detected symmetry axes.
proshade_signed yFrom
This is the starting index along the y axis.
proshade_unsign recommendedSymmetryFold
The fold of the recommended symmetry C or D type, 0 otherwise.
void addToUnsignVector(std::vector< proshade_unsign > *vecToAddTo, proshade_unsign elementToAdd)
Adds the element to the vector.
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 ...
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.
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.
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...
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.
proshade_signed * getYAxisOrigin(void)
This function allows access to the map Y axis origin value.
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...
proshade_double originalPdbRotCenZ
The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map...
void computeTranslationsFromPeak(ProSHADE_internal_data::ProSHADE_data *staticStructure, ProSHADE_internal_data::ProSHADE_data *movingStructure, proshade_double *trsX, proshade_double *trsY, proshade_double *trsZ)
This function computes the translation in Angstroms that corresponds to the translation function peak...
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...
void addToSingleVector(std::vector< proshade_single > *vecToAddTo, proshade_single elementToAdd)
Adds the element to the vector.
bool firstModelOnly
Shoud only the first PDB model be used, or should all models be used?
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...
bool sortProSHADESymmetryByFSC(proshade_double *a, proshade_double *b)
This function allows using std::sort to sort vectors of ProSHADE symmetry format.
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.
proshade_double axisErrTolerance
Allowed error on vector axis in in dot product ( acos ( 1 - axErr ) is the allowed difference in radi...
bool useSameBounds
Switch to say that the same boundaries as used for the first should be used for all input maps.
proshade_unsign zDimIndices
This is the size of the map cell z dimension in indices.
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 ...
proshade_double pdbBFactorNewVal
Change all PDB B-factors to this value (for smooth maps).
void allocateRotatedMap(void)
This function allocates the rotated map memory.
proshade_unsign zGridIndices
As far as I know, this is identical to the zDimIndices.
void setRecommendedFold(proshade_unsign val)
Sets the ProSHADE detected symmetry fold.
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.
void applyWeights(proshade_double *&map, std::string weightsFile, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_signed verbose, proshade_double *weightsArray=nullptr, proshade_unsign waXInds=0, proshade_unsign waYInds=0, proshade_unsign waZInds=0)
This function reads and applies the Fourier weights to the map.
void setVariablesLeftOnAuto(void)
Function to determine general values that the user left on auto-determination.
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...
bool removeWaters
Should all waters be removed from input PDB files?
ProSHADE_internal_spheres::ProSHADE_sphere ** spheres
The set of concentric spheres to which the intermal density map has been projected.
void normaliseMap(ProSHADE_settings *settings)
Function for normalising the map values to mean 0 and sd 1..
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...
std::vector< proshade_unsign > findAllPrimes(proshade_unsign upTo)
This function finds all prime numbers up to the supplied limit.
proshade_double originalPdbRotCenX
The centre of rotation as it relates to the original PDB positions (and not the ProSHADE internal map...
proshade_double originalMapZCom
The COM of the first map to be loaded/computed without any furhter changes being reflacted along the ...
void printProgressMessage(proshade_signed verbose, proshade_signed messageLevel, std::string message)
General stdout message printing.
proshade_single yDimSize
This is the size of the map cell y dimension in Angstroms.
void setResolution(proshade_single resolution)
Sets the requested resolution in the appropriate variable.
std::vector< std::vector< proshade_double > > allDetectedCAxes
The vector of all detected cyclic symmetry axes.
void removePhaseInormation(ProSHADE_settings *settings)
This function removes phase from the map, effectively converting it to Patterson map.
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.
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.
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...
void addExtraSpace(ProSHADE_settings *settings)
This function increases the size of the map so that it can add empty space around it.
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...
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.
void addToStringVector(std::vector< std::string > *vecToAddTo, std::string elementToAdd)
Adds the element to the vector.
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.
void readInPDB(ProSHADE_settings *settings)
Function for reading pdb data.
void setRotatedMappedData(proshade_unsign pos, proshade_double value)
This function sets the rotated mapped data value to the given position.
proshade_signed * getZFromPtr(void)
This function allows access to the map start along the Z axis.
proshade_signed * getZToPtr(void)
This function allows access to the map last position along the Z axis.