ProSHADE: ProSHADE_internal_distances Namespace Reference

| ProSHADE 0.7.5.4 (MAR 2021) Protein Shape Detection

Functions
ProSHADE_internal_distances Namespace Reference

This namespace contains the functions used for computing distances between two structures as represented by the ProSHADE_data class. More...

## Functions
proshade_double | computeEnergyLevelsDescriptor (ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
| This function computes the energy levels descriptor value between two objects. More...
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. More...
void | computeRRPPearsonCoefficients (ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings, proshade_unsign minCommonBands, proshade_unsign minCommonShells, std::vector< proshade_double > *bandDists)
| This function gets the Pearson's coefficients or all bands between two objects. More...
void | allocateTrSigmaWorkspace (proshade_unsign minSpheres, proshade_unsign intOrder, proshade_double *&obj1Vals, proshade_double *&obj2Vals, proshade_double *&GLabscissas, proshade_double *&glWeights, proshade_complex *&radiiVals)
| This helper function is responsible for allocating the workspace memory required for trace sigma descriptor computation. More...
void | computeSphericalHarmonicsMagnitude (ProSHADE_internal_data::ProSHADE_data *obj, proshade_unsign band, proshade_unsign order, proshade_unsign radius, proshade_double *result)
| This function computes the magnitude of a particular spherical harmonics position for a given object, weighting it by the radius^2 (for integration). More...
void | computeEMatricesForLM (ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, proshade_unsign bandIter, proshade_unsign orderIter, proshade_complex *radiiVals, proshade_unsign integOrder, proshade_double *abscissas, proshade_double *weights, proshade_double integRange, proshade_double sphereDist)
| This function computes the E matrix un-weighted values for a given band and order and saves these into the obj2 parameter. More...
proshade_double | computeWeightsForEMatricesForLM (ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, proshade_unsign bandIter, proshade_unsign orderIter, proshade_double *obj1Vals, proshade_double *obj2Vals, proshade_unsign integOrder, proshade_double *abscissas, proshade_double *weights, proshade_double sphereDist)
| This function computes the E matrix weight values for a given band and order and saves these into the appropriate objects. More...
void | releaseTrSigmaWorkspace (proshade_double *&obj1Vals, proshade_double *&obj2Vals, proshade_double *&GLabscissas, proshade_double *&glWeights, proshade_complex *&radiiVals)
| This helper function is responsible for deleting the workspace memory required for trace sigma descriptor computation. More...
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. More...
void | normaliseEMatrices (ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
| This function normalises the E matrices. More...
proshade_double | computeTraceSigmaDescriptor (ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
| This function computes the trace sigma descriptor value between two objects. More...
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. More...
void | allocateInvSOFTWorkspaces (proshade_complex *&work1, proshade_complex *&work2, proshade_double *&work3, proshade_unsign band)
| This function allocates the workspaces required to compute the inverse SOFT transform. More...
void | prepareInvSOFTPlan (fftw_plan *inverseSO3, proshade_unsign band, fftw_complex *work1, proshade_complex *invCoeffs)
| This function prepares the FFTW plan for the inverse SO(3) transform. More...
void | releaseInvSOFTMemory (proshade_complex *&work1, proshade_complex *&work2, proshade_double *&work3)
| This function releases the memory used for computation of the inverse SOFT transform. More...
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. More...
proshade_double | computeRotationunctionDescriptor (ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
| This function computes the rotation function descriptor value between two objects. More...

## Detailed Description

This namespace contains the functions used for computing distances between two structures as represented by the ProSHADE_data class.

The ProSHADE_internal_distances namespace contains all the functionality required to compute distances between two or more ProSHADE_data objects and also all of the pre-computation functions.

## Function Documentation

## ◆ allocateInvSOFTWorkspaces()

void ProSHADE_internal_distances::allocateInvSOFTWorkspaces | ( | proshade_complex *& | work1,
|  | proshade_complex *& | work2,
|  | proshade_double *& | work3,
|  | proshade_unsign | band
| ) |  |

This function allocates the workspaces required to compute the inverse SOFT transform.

Parameters

  [in] | work1 | The first workspace pointer to be allocated.
  [in] | work2 | The second workspace pointer to be allocated.
  [in] | work3 | The third workspace pointer to be allocated.
  [in] | band | The bandwidth of the computations (this determines how much workspace will be required).

Definition at line 766 of file ProSHADE_distances.cpp.

767 {
768 //================================================ Allocate memory
769 work1 = new proshade_complex[8 * static_cast<proshade_unsign> ( pow( static_cast<double> ( band ), 3.0 ) )];
770 work2 = new proshade_complex[14 * static_cast<proshade_unsign> ( pow( static_cast<double> ( band ), 2.0 ) ) + (48 * band)];
771 work3 = new proshade_double [2 * static_cast<proshade_unsign> ( pow( static_cast<double> ( band ), 2.0 ) ) + (24 * band)];
772
773 //================================================ Check the memory allocation
774 ProSHADE_internal_misc::checkMemoryAllocation ( work1, __FILE__, __LINE__, __func__ );
775 ProSHADE_internal_misc::checkMemoryAllocation ( work2, __FILE__, __LINE__, __func__ );
776 ProSHADE_internal_misc::checkMemoryAllocation ( work3, __FILE__, __LINE__, __func__ );
777
778 //================================================ Done
779 return ;
780
781 }

## ◆ allocateTrSigmaWorkspace()

void ProSHADE_internal_distances::allocateTrSigmaWorkspace | ( | proshade_unsign | minSpheres,
|  | proshade_unsign | intOrder,
|  | proshade_double *& | obj1Vals,
|  | proshade_double *& | obj2Vals,
|  | proshade_double *& | GLabscissas,
|  | proshade_double *& | GLweights,
|  | proshade_complex *& | radiiVals
| ) |  |

This helper function is responsible for allocating the workspace memory required for trace sigma descriptor computation.

Parameters

  [in] | minSpheres | The minima of the number of spheres available in the compared objects.
  [in] | intOrder | The integration order for the computation.
  [in] | obj1Vals | Array to hold the shell values for the first object integgration.
  [in] | obj2Vals | Array to hold the shell values for the second object integgration.
  [in] | GLabscissas | An array to hold the pre-computed anscissas for the Gauss-Legendre integration.
  [in] | glWeights | An array to hold the pre-computed weights for the Gauss-Legendre integration.
  [in] | radiiVals | A complex array to hold the results of combining spherical harmonics coefficients of the two objects for each shell.

Definition at line 317 of file ProSHADE_distances.cpp.

318 {
319 //================================================ Allocate the memory
320 obj1Vals = new proshade_double [minSpheres];
321 obj2Vals = new proshade_double [minSpheres];
322 radiiVals = new proshade_complex[minSpheres];
323 GLabscissas = new proshade_double [intOrder];
324 GLweights = new proshade_double [intOrder];
325
326 //================================================ Check the memory allocation
327 ProSHADE_internal_misc::checkMemoryAllocation ( obj1Vals, __FILE__, __LINE__, __func__ );
328 ProSHADE_internal_misc::checkMemoryAllocation ( obj2Vals, __FILE__, __LINE__, __func__ );
329 ProSHADE_internal_misc::checkMemoryAllocation ( radiiVals, __FILE__, __LINE__, __func__ );
330 ProSHADE_internal_misc::checkMemoryAllocation ( GLabscissas, __FILE__, __LINE__, __func__ );
331 ProSHADE_internal_misc::checkMemoryAllocation ( GLweights, __FILE__, __LINE__, __func__ );
332
333 //================================================ Done
334 return ;
335
336 }

## ◆ computeEMatrices()

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

This function allocates the space required for storing the E matrices, allocates all the workspace requierd for the computation and proceeds to compute the values for all band (l), order1(m) and order2(m') E matrix values. It then proceeds to release all non required memory and terminates, leaving all its results in the second ProSHADE data object supplied. This function does NOT apply the weights to the matrices, it needs to be done subsequently!

Parameters

  [in] | obj1 | The first ProSHADE_data object for which the computation is done.
  [in] | obj2 | The second ProSHADE_data object for which the computation is done.
  [in] | settings | A pointer to settings class containing all the information required for the task.

Definition at line 515 of file ProSHADE_distances.cpp.

516 {
517 //================================================ Report progress
518 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Starting computation of E matrices." );
519
520 //================================================ Allocatre memory for E matrices in the second object (first may be compared to more structures and therefore its data would be written over)
521 obj2->allocateEMatrices ( settings, std::min ( obj1->getMaxBand(), obj2->getMaxBand() ) );
522
523 //================================================ Initialise local variables
524 proshade_double *obj1Vals, *obj2Vals, *GLAbscissas, *GLWeights;
525 proshade_complex* radiiVals;
526 proshade_double integRange;
527
528 //================================================ Allocate workspace memory
529 allocateTrSigmaWorkspace ( std::min( obj1->getMaxSpheres(), obj2->getMaxSpheres() ), settings->integOrder, obj1Vals, obj2Vals, GLAbscissas, GLWeights, radiiVals);
530
531 //================================================ Initialise abscissas and weights for integration
532 ProSHADE_internal_maths::getLegendreAbscAndWeights ( settings->integOrder, GLAbscissas, GLWeights, settings->taylorSeriesCap );
533
534 //================================================ For each band (l), compute the E matrix integrals
535 for ( proshade_unsign bandIter = 0; bandIter < std::min ( obj1->getMaxBand(), obj2->getMaxBand() ); bandIter++ )
536 {
537 //============================================ For each order (m)
538 for ( proshade_unsign orderIter = 0; orderIter < ( ( bandIter * 2 ) + 1 ); orderIter++ )
539 {
540 //======================================== Get weights for the required band(l) and order (m)
541 integRange = computeWeightsForEMatricesForLM ( obj1, obj2, bandIter, orderIter, obj1Vals, obj2Vals, settings->integOrder, GLAbscissas, GLWeights, settings->maxSphereDists );
542
543 //======================================== Compute E matrices value for given band (l) and order(m)
544 computeEMatricesForLM ( obj1, obj2, bandIter, orderIter, radiiVals, settings->integOrder, GLAbscissas, GLWeights, integRange, settings->maxSphereDists );
545 }
546
547 //============================================ Report progress
548 if ( settings->verbose > 3 )
549 {
550 std::stringstream hlpSS;
551 hlpSS << "E matrices computed for band " << bandIter;
552 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, hlpSS.str() );
553 }
554 }
555
556 //================================================ Release the workspace memory
557 releaseTrSigmaWorkspace ( obj1Vals, obj2Vals, GLAbscissas, GLWeights, radiiVals );
558
559 //================================================ Report progress
560 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "E matrices computed." );
561
562 //================================================ Done
563 return ;
564
565 }

## ◆ computeEMatricesForLM()

void ProSHADE_internal_distances::computeEMatricesForLM | ( | ProSHADE_internal_data::ProSHADE_data * | obj1,
|  | ProSHADE_internal_data::ProSHADE_data * | obj2,
|  | proshade_unsign | bandIter,
|  | proshade_unsign | orderIter,
|  | proshade_complex * | radiiVals,
|  | proshade_unsign | integOrder,
|  | proshade_double * | abscissas,
|  | proshade_double * | weights,
|  | proshade_double | integRange,
|  | proshade_double | sphereDist
| ) |  |

This function computes the E matrix un-weighted values for a given band and order and saves these into the obj2 parameter.

Parameters

  [in] | obj1 | The ProSHADE_data object for which the comparison is done in regards to.
  [in] | obj2 | The ProSHADE_data object for which the comparison is done in regards from - the E matrices will be saved into this object.
  [in] | band | The bandwidth of the SH value for which this should be done.
  [in] | order | The order of the SH value for which this should be done.
  [in] | radiiVals | Already allocated array of proshade_complex to which integrated values will be saved. It must have size equal to minimum of spheres in the two compared objects.
  [in] | integOrder | The Gauss-Legendre integration order to be used.
  [in] | abscissas | The pre-computed abscissas for the Gauss-Legendre integration.
  [in] | weights | The pre-computed weights for the Gauss-Legendre integration.
  [in] | integRange | The range in angstroms between the smalleds and largest shell which are integrated over (might not be 0 to max for progressive shell sampling).
  [in] | sphereDist | The distance between any two spheres.

Definition at line 375 of file ProSHADE_distances.cpp.

376 {
377 //================================================ Initialise local variables
378 proshade_unsign objCombValsIter = 0;
379 proshade_double hlpReal, hlpImag;
380 proshade_complex arrVal;
381
382 //================================================ For each combination of m and m' for E matrices
383 for ( proshade_unsign order2Iter = 0; order2Iter < ( ( bandIter * 2 ) + 1 ); order2Iter++ )
384 {
385 //============================================ Reset loop
386 objCombValsIter = 0;
387
388 //============================================ Find the c*conj(c) values for different radii
389 for ( proshade_unsign radiusIter = 0; radiusIter < std::min( obj1->getMaxSpheres(), obj2->getMaxSpheres() ); radiusIter++ )
390 {
391
392 //======================================== Get only values where the shell has the band
393 if ( std::min ( obj1->getShellBandwidth ( radiusIter ), obj2->getShellBandwidth ( radiusIter ) ) <= bandIter ) { continue; }
394
395 //======================================== Multiply coeffs
396 ProSHADE_internal_maths::complexMultiplicationConjug ( obj1->getRealSphHarmValue ( bandIter, orderIter, radiusIter ),
397 obj1->getImagSphHarmValue ( bandIter, orderIter, radiusIter ),
398 obj2->getRealSphHarmValue ( bandIter, order2Iter, radiusIter ),
399 obj2->getImagSphHarmValue ( bandIter, order2Iter, radiusIter ),
400 &hlpReal, &hlpImag );
401
402 //======================================== Apply r^2 integral weight
403 radiiVals[objCombValsIter][0] = hlpReal * pow ( ( static_cast<proshade_double> ( obj1->getAnySphereRadius( radiusIter ) ) ), 2.0 );
404 radiiVals[objCombValsIter][1] = hlpImag * pow ( ( static_cast<proshade_double> ( obj1->getAnySphereRadius( radiusIter ) ) ), 2.0 );
405
406 objCombValsIter += 1;
407 }
408
409 //============================================ Integrate over all radii using n-point Gauss-Legendre integration
410 ProSHADE_internal_maths::gaussLegendreIntegration ( radiiVals, objCombValsIter, integOrder, abscissas, weights, integRange, sphereDist, &hlpReal, &hlpImag );
411
412 //============================================ Save the result into E matrices
413 arrVal[0] = hlpReal;
414 arrVal[1] = hlpImag;
415 obj2->setEMatrixValue ( bandIter, orderIter, order2Iter, arrVal );
416 }
417
418 //================================================ Done
419 return ;
420
421 }

## ◆ computeEnergyLevelsDescriptor()

proshade_double ProSHADE_internal_distances::computeEnergyLevelsDescriptor | ( | ProSHADE_internal_data::ProSHADE_data * | obj1,
|  | ProSHADE_internal_data::ProSHADE_data * | obj2,
|  | ProSHADE_settings * | settings
| ) |  |

This function computes the energy levels descriptor value between two objects.

This function is where the enery levels descriptor computation is controlled and done from. It starts by making sure that both input data objects have the RRP matrices computed and then it proceeds to compute the Pearson's coefficients for each band, finally averaging the band values and returning the descriptos.

Parameters

  [in] | obj1 | The first ProSHADE_data object against which comparison is done.
  [in] | obj2 | The second ProSHADE_data object which is compared to the first.
  [in] | settings | A pointer to settings class containing all the information required for the task.

Definition at line 165 of file ProSHADE_distances.cpp.

166 {
167 //================================================ Report starting the task
168 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting energy levels distance computation." );
169
170 //================================================ Initialise local variables
171 proshade_double ret = 0.0;
172 std::vector<proshade_double> bandDists;
173
174 //================================================ Sanity check
175 if ( !settings->computeEnergyLevelsDesc )
176 {
177 throw ProSHADE_exception ( "Attempted computing energy levels descriptors when it was not required.", "ED00017", __FILE__, __LINE__, __func__, "Attempted to pre-compute the RRP matrices, when the user\n : has specifically stated that these should not be computed.\n : Unless you manipulated the code, this error should never\n : occur; if you see this, I made a large blunder. Please let\n : me know!" );
178 }
179
180 //================================================ Get the RRP matrices for both objects
181 obj1->computeRRPMatrices ( settings );
182 obj2->computeRRPMatrices ( settings );
183
184 //================================================ Find the minimium comparable shells and bands
185 proshade_unsign minCommonShells = std::min ( obj1->getMaxSpheres(), obj2->getMaxSpheres() );
186 proshade_unsign minCommonBands = std::min ( obj1->getMaxBand(), obj2->getMaxBand() );
187
188 //================================================ Get the Pearson's coefficients for each common band
189 computeRRPPearsonCoefficients ( obj1, obj2, settings, minCommonBands, minCommonShells, &bandDists );
190
191 //================================================ Get distance (by averaging Patterson's coefficients)
192 ret = static_cast<proshade_double> ( std::accumulate ( bandDists.begin(), bandDists.end(), 0.0 ) ) /
193 static_cast<proshade_double> ( bandDists.size() );
194
195 //================================================ Report completion
196 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Energy levels distance computation complete." );
197
198 //================================================ Done
199 return ( ret );
200
201 }

## ◆ computeInverseSOFTTransform()

void ProSHADE_internal_distances::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 function firstly allocates all the required workspaces for the inverse SO(3) Fourier Transform, then it prepares the FFTW plans for performing the FFTW inverse Fourier transform in the SO(3) space using FFTW and finally it subjects the SO(3) coeffficients available at this point to the computation. The results are saved into the second object, memory is released and function terminates.

Parameters

  [in] | obj1 | The first ProSHADE_data object against which comparison is done.
  [in] | obj2 | The second ProSHADE_data object which is compared to the first.
  [in] | settings | A pointer to settings class containing all the information required for the task.

Definition at line 859 of file ProSHADE_distances.cpp.

860 {
861 //================================================ Report progress
862 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Computing inverse SO(3) Fourier transform." );
863
864 //================================================ Initialise local variables
865 proshade_complex *workspace1, *workspace2;
866 proshade_double *workspace3;
867 fftw_plan inverseSO3;
868
869 //================================================ Allocate memory for the workspaces
870 allocateInvSOFTWorkspaces ( workspace1, workspace2, workspace3, std::min ( obj1->getMaxBand(), obj2->getMaxBand() ) );
871
872 //================================================ Prepare the FFTW plan
873 prepareInvSOFTPlan ( &inverseSO3, std::min ( obj1->getMaxBand(), obj2->getMaxBand() ), workspace1, obj2->getInvSO3Coeffs ( ) );
874
875 //================================================ Compute the transform
876 Inverse_SO3_Naive_fftw ( std::min ( obj1->getMaxBand(), obj2->getMaxBand() ),
877 obj2->getSO3Coeffs ( ),
878 obj2->getInvSO3Coeffs ( ),
879 workspace1,
880 workspace2,
881 workspace3,
882 &inverseSO3,
883 0 );
884
885 //================================================ Release memory
886 releaseInvSOFTMemory ( workspace1, workspace2, workspace3 );
887 fftw_destroy_plan ( inverseSO3 );
888
889 //================================================ Report progress
890 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "Inverse SO(3) Fourier transform computed." );
891
892 //================================================ Done
893 return ;
894
895 }

## ◆ computeRotationunctionDescriptor()

proshade_double ProSHADE_internal_distances::computeRotationunctionDescriptor | ( | ProSHADE_internal_data::ProSHADE_data * | obj1,
|  | ProSHADE_internal_data::ProSHADE_data * | obj2,
|  | ProSHADE_settings * | settings
| ) |  |

This function computes the rotation function descriptor value between two objects.

This function starts by sanity checks and computation and normalisation of the E matrices used for the trace sigma descriptor (these only need to be computed if trace sigma descriptor is NOT computed, otherwise the stored values are used to save time). It then converts the E matrix values to SO(3) transform coefficients and invers these using the SOFT library. From the resulting rotation function map, it selects the highest peak and applies its rotation to the E matrix values. The resulting values are simply summed, as this sum can be proven to be the argmin of the distance between the two objects in their spherical harmonics decomposition space.

Parameters

  [in] | obj1 | The first ProSHADE_data object against which comparison is done.
  [in] | obj2 | The second ProSHADE_data object which is compared to the first.
  [in] | settings | A pointer to settings class containing all the information required for the task.
  [out] | ret | The final normalised value of the rotation function descriptor for the two objects.

Definition at line 911 of file ProSHADE_distances.cpp.

912 {
913 //================================================ Report starting the task
914 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting rotation function distance computation." );
915
916 //================================================ Initialise return variable
917 proshade_double ret = 0.0;
918 proshade_double eulA, eulB, eulG, EMatR, EMatI, WigDR, WigDI;
919
920 //================================================ Sanity check
921 if ( !settings->computeRotationFuncDesc )
922 {
923 throw ProSHADE_exception ( "Attempted computing rotation function descriptors when it\n : was not required.", "ED00023", __FILE__, __LINE__, __func__, "Attempted to compute the SO(3) transform and the rotation \n : function descriptor when the user did not request this. \n : Unless you manipulated the code, this error should never \n : occur; if you see this, I made a large blunder. \n : Please let me know!" );
924 }
925
926 //================================================ Compute weighted E matrices if not already present
927 if ( !settings->computeTraceSigmaDesc )
928 {
929 computeEMatrices ( obj1, obj2, settings );
930 normaliseEMatrices ( obj1, obj2, settings );
931 }
932
933 //================================================ Generate SO(3) coefficients
934 generateSO3CoeffsFromEMatrices ( obj1, obj2, settings );
935
936 //================================================ Compute the inverse SO(3) Fourier Transform (SOFT) on the newly computed coefficients
937 computeInverseSOFTTransform ( obj1, obj2, settings );
938
939 //================================================ Get inverse SO(3) map top peak Euler angle values
940 ProSHADE_internal_peakSearch::getBestPeakEulerAngsNaive ( obj2->getInvSO3Coeffs (),
941 std::min ( obj1->getMaxBand(), obj2->getMaxBand() ) * 2,
942 &eulA, &eulB, &eulG, settings );
943
944 //================================================ Compute the Wigner D matrices for the Euler angles
945 ProSHADE_internal_wigner::computeWignerMatricesForRotation ( settings, obj2, eulA, eulB, eulG );
946
947 //================================================ Compute the distance
948 for ( proshade_unsign bandIter = 0; bandIter < obj2->getComparisonBand(); bandIter++ )
949 {
950 //============================================ For each order1
951 for ( proshade_unsign order1 = 0; order1 < ( ( bandIter * 2 ) + 1 ); order1++ )
952 {
953 //======================================== For each order2
954 for ( proshade_unsign order2 = 0; order2 < ( ( bandIter * 2 ) + 1 ); order2++ )
955 {
956 //==================================== Multiply D_{l} * E_{l} and get sum over l of traces (i.e. just sum all together)
957 obj2->getEMatrixValue ( bandIter, order1, order2, &EMatR, &EMatI );
958 obj2->getWignerMatrixValue ( bandIter, order2, order1, &WigDR, &WigDI );
959 ret += ProSHADE_internal_maths::complexMultiplicationRealOnly ( &WigDR, &WigDI, &EMatR, &EMatI );
960 }
961 }
962 }
963
964 //================================================ Report completion
965 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Rotation function distance computation complete." );
966
967 //================================================ Done
968 return ( ret );
969
970 }

## ◆ computeRRPPearsonCoefficients()

void ProSHADE_internal_distances::computeRRPPearsonCoefficients | ( | ProSHADE_internal_data::ProSHADE_data * | obj1,
|  | ProSHADE_internal_data::ProSHADE_data * | obj2,
|  | ProSHADE_settings * | settings,
|  | proshade_unsign | minCommonBands,
|  | proshade_unsign | minCommonShells,
|  | std::vector< proshade_double > * | bandDists
| ) |  |

This function gets the Pearson's coefficients or all bands between two objects.

This function takes two data objects with their RRP matrices computed and proceeds to compute the Pearson's correlation coefficient for each band, saving it into the supplied vector.

Parameters

  [in] | obj1 | The first ProSHADE_data object against which comparison is done.
  [in] | obj2 | The second ProSHADE_data object which is compared to the first.
  [in] | settings | A pointer to settings class containing all the information required for the task.
  [in] | minCommonBands | The number of common bands between the two objects.
  [in] | minCommonShells | The index of highest common shell in both objects.
  [in] | bandDists | Empty vector of proshade_doubles to which the Pearson's Coefficients will be saved for each band.

Definition at line 215 of file ProSHADE_distances.cpp.

216 {
217 //================================================ Report completion
218 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Correlating RRP matrices." );
219
220 //================================================ Initialise local variables
221 proshade_double *str1Vals = new proshade_double[minCommonShells * minCommonShells];
222 proshade_double *str2Vals = new proshade_double[minCommonShells * minCommonShells];
223 ProSHADE_internal_misc::checkMemoryAllocation ( str1Vals, __FILE__, __LINE__, __func__ );
224 ProSHADE_internal_misc::checkMemoryAllocation ( str2Vals, __FILE__, __LINE__, __func__ );
225 proshade_unsign arrIter = 0;
226
227 //================================================ Start computation: For each band (l)
228 for ( proshade_unsign band = 0; band < minCommonBands; band++ )
229 {
230 //============================================ Reset local counter
231 arrIter = 0;
232
233 //============================================ For each shell pair
234 for ( proshade_unsign shell1 = 0; shell1 < minCommonShells; shell1++ )
235 {
236 //======================================== Check if band exists (progressive only)
237 if ( settings->progressiveSphereMapping ) { if ( !obj1->shellBandExists( shell1, band ) || !obj2->shellBandExists( shell1, band ) ) { continue; } }
238
239 for ( proshade_unsign shell2 = 0; shell2 < minCommonShells; shell2++ )
240 {
241 //============================ Check the other shell as well
242 if ( !obj1->shellBandExists( shell2, band ) || !obj2->shellBandExists( shell2, band ) ) { continue; }
243
244 //==================================== Set values between which the Person's correlation coefficient should be computed
245 str1Vals[arrIter] = obj1->getRRPValue ( band, shell1, shell2 ) *
246 pow ( static_cast<proshade_double> ( shell1 ), settings->enLevMatrixPowerWeight ) *
247 pow ( static_cast<proshade_double> ( shell2 ), settings->enLevMatrixPowerWeight );
248 str2Vals[arrIter] = obj2->getRRPValue ( band, shell1, shell2 ) *
249 pow ( static_cast<proshade_double> ( shell1 ), settings->enLevMatrixPowerWeight ) *
250 pow ( static_cast<proshade_double> ( shell2 ), settings->enLevMatrixPowerWeight );
251
252 arrIter += 1;
253 }
254 }
255
256 //============================================ Get Pearson's Correlation Coefficient
257 ProSHADE_internal_misc::addToDoubleVector ( bandDists, ProSHADE_internal_maths::pearsonCorrCoeff ( str1Vals, str2Vals, arrIter ) );
258 }
259
260 //================================================ Clean up
261 delete[] str1Vals;
262 delete[] str2Vals;
263
264 //================================================ Report completion
265 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "RRP matrices correlation computed." );
266
267 //================================================ Done
268 return ;
269 }

## ◆ computeSphericalHarmonicsMagnitude()

void ProSHADE_internal_distances::computeSphericalHarmonicsMagnitude | ( | ProSHADE_internal_data::ProSHADE_data * | obj,
|  | proshade_unsign | band,
|  | proshade_unsign | order,
|  | proshade_unsign | radius,
|  | proshade_double * | result
| ) |  |

This function computes the magnitude of a particular spherical harmonics position for a given object, weighting it by the radius^2 (for integration).

Parameters

  [in] | obj | The ProSHADE_data object for which the computation is to be done.
  [in] | band | The bandwidth of the SH value for which this should be done.
  [in] | order | The order of the SH value for which this should be done.
  [in] | radius | The shell of the SH value for which this should be done.
  [in] | result | The location where the result is to be saved.

Definition at line 346 of file ProSHADE_distances.cpp.

347 {
348 //================================================ Find the magnitude
349 *result = ProSHADE_internal_maths::complexMultiplicationConjugRealOnly ( obj->getRealSphHarmValue ( band, order, radius ),
350 obj->getImagSphHarmValue ( band, order, radius ),
351 obj->getRealSphHarmValue ( band, order, radius ),
352 obj->getImagSphHarmValue ( band, order, radius ) );
353
354 //================================================ Weight by radius^2 for the integration that will follow
355 *result *= pow ( static_cast<proshade_double> ( obj->getAnySphereRadius( radius ) ), 2.0 );
356
357 //================================================ Done
358 return ;
359
360 }

## ◆ computeTraceSigmaDescriptor()

proshade_double ProSHADE_internal_distances::computeTraceSigmaDescriptor | ( | ProSHADE_internal_data::ProSHADE_data * | obj1,
|  | ProSHADE_internal_data::ProSHADE_data * | obj2,
|  | ProSHADE_settings * | settings
| ) |  |

This function computes the trace sigma descriptor value between two objects.

This function starts by checking if the trace sigma descriptor was requested and if so, proceeds to compute the E matrices. These are 3D matrices with each l,m,m' value being the combination of the c_{l,m} and c*_{l,m'} spherical harmonics coefficients. Once computed, the E matrices are normalised by the magnitudes of the objects spherical harmonics coefficients and the SVD is computed for each l (i.e. on each m x m' matrix). The sum of the trace of the sigmas of the SVD is then the trace sigma descriptor, whose value is returned.

Parameters

  [in] | obj1 | The first ProSHADE_data object against which comparison is done.
  [in] | obj2 | The second ProSHADE_data object which is compared to the first.
  [in] | settings | A pointer to settings class containing all the information required for the task.
  [out] | ret | The final normalised value of the trace sigma descriptor for the two objects.

Definition at line 621 of file ProSHADE_distances.cpp.

622 {
623 //================================================ Report starting the task
624 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 1, "Starting trace sigma distance computation." );
625
626 //================================================ Initialise return variable
627 proshade_double ret = 0.0;
628
629 //================================================ Sanity check
630 if ( !settings->computeTraceSigmaDesc )
631 {
632 throw ProSHADE_exception ( "Attempted computing trace sigma descriptors when it was\n : not required.", "ED00018", __FILE__, __LINE__, __func__, "Attempted to pre-compute the E matrices, when the user\n : has specifically stated that these should not be computed.\n : Unless you manipulated the code, this error should never\n : occur; if you see this, I made a large blunder. Please let\n : me know!" );
633 }
634
635 //================================================ Empty the cumulative weights back to 0.0 for each structure
636 obj1->setIntegrationWeight ( 0.0 );
637 obj1->setIntegrationWeight ( 0.0 );
638
639 //================================================ Compute un-weighted E matrices and their weights
640 computeEMatrices ( obj1, obj2, settings );
641
642 //================================================ Normalise E matrices by the magnitudes
643 normaliseEMatrices ( obj1, obj2, settings );
644
645 //================================================ Allocate the required memory
646 double* singularValues = new double[( ( std::min ( obj1->getMaxBand(), obj2->getMaxBand() ) * 2 ) + 1 )];
647 ProSHADE_internal_misc::checkMemoryAllocation ( singularValues, __FILE__, __LINE__, __func__ );
648
649 //================================================ Compute the distance
650 for ( proshade_unsign lIter = 0; lIter < std::min ( obj1->getMaxBand(), obj2->getMaxBand() ); lIter++ )
651 {
652 //============================================ Find the complex matrix SVD singular values
653 ProSHADE_internal_maths::complexMatrixSVDSigmasOnly ( obj2->getEMatrixByBand ( lIter ), static_cast<int> ( ( lIter * 2 ) + 1 ), singularValues );
654
655 //============================================ Now sum the trace
656 for ( proshade_unsign iter = 0; iter < ( ( lIter * 2 ) + 1 ); iter++ )
657 {
658 ret += singularValues[iter];
659 }
660 }
661
662 //================================================ Report completion
663 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "E matrices decomposed to singular values." );
664
665 //================================================ Release the memory
666 delete[] singularValues;
667
668 //================================================ Report completion
669 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Trace sigma distance computation complete." );
670
671 //================================================ Done
672 return ( ret );
673
674 }

## ◆ computeWeightsForEMatricesForLM()

proshade_double ProSHADE_internal_distances::computeWeightsForEMatricesForLM | ( | ProSHADE_internal_data::ProSHADE_data * | obj1,
|  | ProSHADE_internal_data::ProSHADE_data * | obj2,
|  | proshade_unsign | bandIter,
|  | proshade_unsign | orderIter,
|  | proshade_double * | obj1Vals,
|  | proshade_double * | obj2Vals,
|  | proshade_unsign | integOrder,
|  | proshade_double * | abscissas,
|  | proshade_double * | weights,
|  | proshade_double | sphereDist
| ) |  |

This function computes the E matrix weight values for a given band and order and saves these into the appropriate objects.

Parameters

  [in] | obj1 | The ProSHADE_data object for which the comparison is done in regards to.
  [in] | obj2 | The ProSHADE_data object for which the comparison is done in regards from - the E matrices will be saved into this object.
  [in] | band | The bandwidth of the SH value for which this should be done.
  [in] | order | The order of the SH value for which this should be done.
  [in] | obj1Vals | Already allocated array of proshade_double to which integrated values will be saved. It must have size equal to minimum of spheres in the two compared objects.
  [in] | obj2Vals | Already allocated array of proshade_double to which integrated values will be saved. It must have size equal to minimum of spheres in the two compared objects.
  [in] | integOrder | The Gauss-Legendre integration order to be used.
  [in] | abscissas | The pre-computed abscissas for the Gauss-Legendre integration.
  [in] | weights | The pre-computed weights for the Gauss-Legendre integration.
  [in] | integRange | The range in angstroms between the smalleds and largest shell which are integrated over (might not be 0 to max for progressive shell sampling).
  [in] | sphereDist | The distance between any two spheres.
  [out] | sphereRange | The distance between the smallest and largest usable sphere (usable as in having the required band).

Definition at line 438 of file ProSHADE_distances.cpp.

439 {
440 //================================================ Initialise local values
441 proshade_unsign obj1ValsIter = 0;
442 proshade_unsign obj2ValsIter = 0;
443
444 //================================================ Set sphere counters
445 proshade_unsign minSphere = std::min( obj1->getMaxSpheres(), obj2->getMaxSpheres() );
446 proshade_unsign maxSphere = 0;
447
448 //================================================ For each radius, deal with weights
449 for ( proshade_unsign radiusIter = 0; radiusIter < std::min( obj1->getMaxSpheres(), obj2->getMaxSpheres() ); radiusIter++ )
450 {
451 //============================================ Get only values where the shell has the band
452 if ( std::min ( obj1->getShellBandwidth ( radiusIter ), obj2->getShellBandwidth ( radiusIter ) ) <= bandIter ) { continue; }
453 minSphere = std::min ( radiusIter, minSphere );
454 maxSphere = std::max ( radiusIter, maxSphere );
455
456 //============================================ Get the magnitudes for weighting
457 computeSphericalHarmonicsMagnitude ( obj1, bandIter, orderIter, radiusIter, &(obj1Vals[obj1ValsIter]) );
458 computeSphericalHarmonicsMagnitude ( obj2, bandIter, orderIter, radiusIter, &(obj2Vals[obj2ValsIter]) );
459 obj1ValsIter += 1;
460 obj2ValsIter += 1;
461 }
462
463 //================================================ Integrate weights
464 proshade_double minSphereRad = obj1->getSpherePosValue ( minSphere ) - ( sphereDist * 0.5 );
465 proshade_double maxSphereRad = obj1->getSpherePosValue ( maxSphere ) + ( sphereDist * 0.5 );
466
467 obj1->setIntegrationWeightCumul ( ProSHADE_internal_maths::gaussLegendreIntegrationReal ( obj1Vals, obj1ValsIter, integOrder, abscissas, weights, maxSphereRad - minSphereRad, sphereDist ) );
468 obj2->setIntegrationWeightCumul ( ProSHADE_internal_maths::gaussLegendreIntegrationReal ( obj2Vals, obj2ValsIter, integOrder, abscissas, weights, maxSphereRad - minSphereRad, sphereDist ) );
469
470 //================================================ Done
471 return ( maxSphereRad - minSphereRad );
472
473 }

## ◆ generateSO3CoeffsFromEMatrices()

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

This function starts by allocating the memory for the SO(3) coefficients and their inverse. It then proceeds to convert the E matrix values into the SO(3) transform coefficients by applying the Wigner normalisation factor and changing the sign as required by SOFT library. Upon termination, the coeffs will be saved in the obj2 class.

Parameters

  [in] | obj1 | The first ProSHADE_data object against which comparison is done.
  [in] | obj2 | The second ProSHADE_data object which is compared to the first.
  [in] | settings | A pointer to settings class containing all the information required for the task.

Definition at line 706 of file ProSHADE_distances.cpp.

707 {
708 //================================================ Report progress
709 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Converting E matrices to SO(3) coefficients." );
710
711 //================================================ Allocate memory for the coefficients
712 obj2->allocateSO3CoeffsSpace ( std::min ( obj1->getMaxBand(), obj2->getMaxBand() ) );
713
714 //================================================ Initialise local variables
715 proshade_double wigNorm, hlpValReal, hlpValImag;
716 proshade_double signValue = 1.0;
717 proshade_unsign indexO;
718 proshade_complex hlpVal;
719
720 //================================================ For each band (l)
721 for ( proshade_signed bandIter = 0; bandIter < static_cast<proshade_signed> ( std::min ( obj1->getMaxBand(), obj2->getMaxBand() ) ); bandIter++ )
722 {
723 //============================================ Get wigner normalisation factor
724 wigNorm = 2.0 * M_PI * sqrt ( 2.0 / (2.0 * bandIter + 1.0 ) ) ;
725
726 //============================================ For each order (m)
727 for ( proshade_signed orderIter = 0; orderIter < ( ( bandIter * 2 ) + 1 ); orderIter++ )
728 {
729 //======================================== Set the sign
730 if ( ( orderIter - bandIter + bandIter ) % 2 ) { signValue = -1.0 ; }
731 else { signValue = 1.0 ; }
732
733 //======================================== For each order2 (m')
734 for ( proshade_signed order2Iter = 0; order2Iter < ( ( bandIter * 2 ) + 1 ); order2Iter++ )
735 {
736 //==================================== Find output index
737 indexO = static_cast<proshade_unsign> ( so3CoefLoc ( orderIter - bandIter, order2Iter - bandIter, bandIter, std::min ( obj1->getMaxBand(), obj2->getMaxBand() ) ) );
738
739 //==================================== Compute and save the SO(3) coefficients
740 obj2->getEMatrixValue ( bandIter, orderIter, order2Iter, &hlpValReal, &hlpValImag );
741 hlpVal[0] = hlpValReal * wigNorm * signValue;
742 hlpVal[1] = hlpValImag * wigNorm * signValue;
743 obj2->setSO3CoeffValue ( indexO, hlpVal );
744
745 //==================================== Switch the sign value
746 signValue *= -1.0;
747 }
748 }
749 }
750
751 //================================================ Report progress
752 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "SO(3) coefficients obtained." );
753
754 //================================================ Done
755 return ;
756
757 }

## ◆ isBandWithinShell()

bool ProSHADE_internal_distances::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.

This function simply checks if a particular sphere bandwidth limit is higher than a requested band, returning true if it is and false if not.

Parameters

  [in] | bandInQuestion | The value of the band existence of which is to be checked.
  [in] | shellInQuestion | The index of the shell for which the band existence is checked.
  [in] | spheres | The ProSHADE structure holding all the shells and their information.

Definition at line 143 of file ProSHADE_distances.cpp.

144 {
145 if ( bandInQuestion < spheres[shellInQuestion]->getLocalBandwidth() )
146 {
147 return ( true );
148 }
149 else
150 {
151 return ( false );
152 }
153 }

## ◆ normaliseEMatrices()

void ProSHADE_internal_distances::normaliseEMatrices | ( | ProSHADE_internal_data::ProSHADE_data * | obj1,
|  | ProSHADE_internal_data::ProSHADE_data * | obj2,
|  | ProSHADE_settings * | settings
| ) |  |

This function normalises the E matrices.

This function assumes that the E matrices and integration magnitude weights were already computed. It now proceeds to compute the weighting factor (sqrt of the product of the magnitudes of the two objects) and apply it to the E matrices. This normalisation is similar in formula and meaning to the Pearson's correlation coefficient normalisation.

Parameters

  [in] | obj1 | The first ProSHADE_data object for which the computation is done.
  [in] | obj2 | The second ProSHADE_data object for which the computation is done.
  [in] | settings | A pointer to settings class containing all the information required for the task.

Definition at line 577 of file ProSHADE_distances.cpp.

578 {
579 //================================================ Report progress
580 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "Starting E matrices normalisation." );
581
582 //================================================ Normalise by the Pearson's c.c. like formula
583 proshade_double eMatNormFactor = std::sqrt ( obj1->getIntegrationWeight() * obj2->getIntegrationWeight() );
584
585 //================================================ If this is self-correlation (i.e. obj1 == obj2), then divide normalisation factor by 2 as the weight was applied cumulatively!
586 if ( settings->task == Symmetry ) { eMatNormFactor /= 2.0; }
587
588 for ( proshade_unsign bandIter = 0; bandIter < std::min ( obj1->getMaxBand(), obj2->getMaxBand() ); bandIter++ )
589 {
590 //============================================ For each combination of m and m' for E matrices
591 for ( proshade_unsign orderIter = 0; orderIter < ( ( bandIter * 2 ) + 1 ); orderIter++ )
592 {
593 for ( proshade_unsign order2Iter = 0; order2Iter < ( ( bandIter * 2 ) + 1 ); order2Iter++ )
594 {
595 obj2->normaliseEMatrixValue ( bandIter, orderIter, order2Iter, eMatNormFactor );
596 }
597 }
598 }
599
600 //================================================ Report progress
601 ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 4, "E matrices normalised." );
602
603 //================================================ Done
604 return ;
605
606 }

## ◆ prepareInvSOFTPlan()

void ProSHADE_internal_distances::prepareInvSOFTPlan | ( | fftw_plan * | inverseSO3,
|  | proshade_unsign | band,
|  | fftw_complex * | work1,
|  | proshade_complex * | invCoeffs
| ) |  |

This function prepares the FFTW plan for the inverse SO(3) transform.

Parameters

  [in] | inverseSO3 | The FFTW_PLAN pointer where the result will be saved.
  [in] | band | The bandwidth of the computations.
  [in] | work1 | The workspace to be used for the computation.
  [in] | invCoeffs | The pointer to where the inverse SOFT transform results will be saved.

Definition at line 790 of file ProSHADE_distances.cpp.

791 {
792 //================================================ Prepare the plan describing variables
793 int howmany = 4 * band * band;
794 int idist = 2 * band;
795 int odist = 2 * band;
796 int rank = 2;
797
798 int inembed[2], onembed[2];
799 inembed[0] = 2 * band;
800 inembed[1] = 4 * band * band;
801 onembed[0] = 2 * band;
802 onembed[1] = 4 * band * band;
803
804 int istride = 1;
805 int ostride = 1;
806
807 int na[2];
808 na[0] = 1;
809 na[1] = 2 * band;
810
811 //================================================ Create the plan
812 *inverseSO3 = fftw_plan_many_dft ( rank,
813 na,
814 howmany,
815 work1,
816 inembed,
817 istride,
818 idist,
819 invCoeffs,
820 onembed,
821 ostride,
822 odist,
823 FFTW_FORWARD,
824 FFTW_ESTIMATE );
825
826 //================================================ Done
827 return ;
828
829 }

## ◆ releaseInvSOFTMemory()

void ProSHADE_internal_distances::releaseInvSOFTMemory | ( | proshade_complex *& | work1,
|  | proshade_complex *& | work2,
|  | proshade_double *& | work3
| ) |  |

This function releases the memory used for computation of the inverse SOFT transform.

Parameters

  [in] | work1 | The first workspace pointer to be released.
  [in] | work2 | The second workspace pointer to be released.
  [in] | work3 | The third workspace pointer to be released.

Definition at line 837 of file ProSHADE_distances.cpp.

838 {
839 //================================================ Release memory
840 delete[] work1;
841 delete[] work2;
842 delete[] work3;
843
844 //================================================ Done
845 return ;
846 }

## ◆ releaseTrSigmaWorkspace()

void ProSHADE_internal_distances::releaseTrSigmaWorkspace | ( | proshade_double *& | obj1Vals,
|  | proshade_double *& | obj2Vals,
|  | proshade_double *& | GLabscissas,
|  | proshade_double *& | GLweights,
|  | proshade_complex *& | radiiVals
| ) |  |

This helper function is responsible for deleting the workspace memory required for trace sigma descriptor computation.

Parameters

  [in] | obj1Vals | Array to hold the shell values for the first object integgration.
  [in] | obj2Vals | Array to hold the shell values for the second object integgration.
  [in] | GLabscissas | An array to hold the pre-computed anscissas for the Gauss-Legendre integration.
  [in] | glWeights | An array to hold the pre-computed weights for the Gauss-Legendre integration.
  [in] | radiiVals | A complex array to hold the results of combining spherical harmonics coefficients of the two objects for each shell.

Definition at line 483 of file ProSHADE_distances.cpp.

484 {
485 //================================================ Release memory
486 delete[] obj1Vals;
487 delete[] obj2Vals;
488 delete[] radiiVals;
489 delete[] GLabscissas;
490 delete[] GLweights;
491
492 //================================================ Set to NULL
493 obj1Vals = NULL;
494 obj2Vals = NULL;
495 radiiVals = NULL;
496 GLabscissas = NULL;
497 GLweights = NULL;
498
499 //================================================ Done
500 return ;
501
502 }
ProSHADE_internal_distances::normaliseEMatrices
void normaliseEMatrices(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function normalises the E matrices.
Definition: ProSHADE_distances.cpp:577
ProSHADE_settings::integOrder
proshade_unsign integOrder
The order required for full Gauss-Legendre integration between the spheres.
Definition: ProSHADE_settings.hpp:119
ProSHADE_internal_data::ProSHADE_data::getEMatrixByBand
proshade_complex ** getEMatrixByBand(proshade_unsign band)
This function allows access to E matrix for a particular band.
Definition: ProSHADE_data.cpp:3201
ProSHADE_internal_maths::gaussLegendreIntegration
void gaussLegendreIntegration(proshade_complex *vals, proshade_unsign valsSize, proshade_unsign order, proshade_double *abscissas, proshade_double *weights, proshade_double integralOverRange, proshade_double maxSphereDists, proshade_double *retReal, proshade_double *retImag)
Function to compute the complete complex Gauss-Legendre integration over spherical harmonic values in...
Definition: ProSHADE_maths.cpp:709
ProSHADE_settings::computeTraceSigmaDesc
bool computeTraceSigmaDesc
If true, the trace sigma descriptor will be computed, otherwise all its computations will be omitted.
Definition: ProSHADE_settings.hpp:160
ProSHADE_internal_maths::gaussLegendreIntegrationReal
proshade_double gaussLegendreIntegrationReal(proshade_double *vals, proshade_unsign valsSize, proshade_unsign order, proshade_double *abscissas, proshade_double *weights, proshade_double integralOverRange, proshade_double maxSphereDists)
Function to compute real part of the Gauss-Legendre integration over spherical harmonic values in dif...
Definition: ProSHADE_maths.cpp:619
ProSHADE_settings::computeRotationFuncDesc
bool computeRotationFuncDesc
If true, the rotation function descriptor will be computed, otherwise all its computations will be om...
Definition: ProSHADE_settings.hpp:161
ProSHADE_settings::taylorSeriesCap
proshade_unsign taylorSeriesCap
The max limit on the Taylor series expansion done for the abscissas of the Gauss-Legendre integration...
Definition: ProSHADE_settings.hpp:120
ProSHADE_internal_data::ProSHADE_data::getComparisonBand
proshade_unsign getComparisonBand(void)
This function allows access to the maximum band for the comparison.
Definition: ProSHADE_data.cpp:3253
ProSHADE_internal_distances::allocateTrSigmaWorkspace
void allocateTrSigmaWorkspace(proshade_unsign minSpheres, proshade_unsign intOrder, proshade_double *&obj1Vals, proshade_double *&obj2Vals, proshade_double *&GLabscissas, proshade_double *&glWeights, proshade_complex *&radiiVals)
This helper function is responsible for allocating the workspace memory required for trace sigma desc...
Definition: ProSHADE_distances.cpp:317
ProSHADE_internal_data::ProSHADE_data::setIntegrationWeight
void setIntegrationWeight(proshade_double intW)
This function allows setting the integration weight for the object.
Definition: ProSHADE_data.cpp:3453
ProSHADE_internal_distances::computeWeightsForEMatricesForLM
proshade_double computeWeightsForEMatricesForLM(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, proshade_unsign bandIter, proshade_unsign orderIter, proshade_double *obj1Vals, proshade_double *obj2Vals, proshade_unsign integOrder, proshade_double *abscissas, proshade_double *weights, proshade_double sphereDist)
This function computes the E matrix weight values for a given band and order and saves these into the...
Definition: ProSHADE_distances.cpp:438
ProSHADE_internal_data::ProSHADE_data::normaliseEMatrixValue
void normaliseEMatrixValue(proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_double normF)
This function allows normalising the E matrix value.
Definition: ProSHADE_data.cpp:3502
ProSHADE_exception
This class is the representation of ProSHADE exception.
Definition: ProSHADE_exceptions.hpp:37
ProSHADE_internal_data::ProSHADE_data::getEMatrixValue
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.
Definition: ProSHADE_data.cpp:3216
ProSHADE_internal_distances::releaseInvSOFTMemory
void releaseInvSOFTMemory(proshade_complex *&work1, proshade_complex *&work2, proshade_double *&work3)
This function releases the memory used for computation of the inverse SOFT transform.
Definition: ProSHADE_distances.cpp:837
ProSHADE_internal_data::ProSHADE_data::getMaxSpheres
proshade_unsign getMaxSpheres(void)
This function returns the number of spheres which contain the whole object.
Definition: ProSHADE_data.cpp:2983
ProSHADE_internal_data::ProSHADE_data::setSO3CoeffValue
void setSO3CoeffValue(proshade_unsign position, proshade_complex val)
This function allows setting the SOFT coefficient values using array position and value.
Definition: ProSHADE_data.cpp:3518
ProSHADE_internal_data::ProSHADE_data::computeRRPMatrices
void computeRRPMatrices(ProSHADE_settings *settings)
This function pre-computes the RRP matrices for a data object.
Definition: ProSHADE_distances.cpp:61
ProSHADE_internal_data::ProSHADE_data::getAnySphereRadius
proshade_double getAnySphereRadius(proshade_unsign shell)
This function allows access to the radius of any particular sphere.
Definition: ProSHADE_data.cpp:3154
ProSHADE_settings::progressiveSphereMapping
bool progressiveSphereMapping
If true, each shell will have its own angular resolution dependent on the actual number of map points...
Definition: ProSHADE_settings.hpp:152
ProSHADE_internal_data::ProSHADE_data::getSO3Coeffs
proshade_complex * getSO3Coeffs(void)
This function allows access to the SO(3) coefficients array.
Definition: ProSHADE_data.cpp:3242
ProSHADE_settings::maxSphereDists
proshade_single maxSphereDists
The distance between spheres in spherical mapping for the largest sphere.
Definition: ProSHADE_settings.hpp:116
ProSHADE_internal_data::ProSHADE_data::getSpherePosValue
proshade_double getSpherePosValue(proshade_unsign shell)
This function allows access to sphere positions.
Definition: ProSHADE_data.cpp:3189
ProSHADE_internal_data::ProSHADE_data::getIntegrationWeight
proshade_double getIntegrationWeight(void)
This function allows access to the integration weight for the object.
Definition: ProSHADE_data.cpp:3165
ProSHADE_internal_data::ProSHADE_data::setIntegrationWeightCumul
void setIntegrationWeightCumul(proshade_double intW)
This function allows setting the cumulative integration weight for the object.
Definition: ProSHADE_data.cpp:3467
ProSHADE_settings::verbose
proshade_signed verbose
Should the software report on the progress, or just be quiet? Value between -1 (nothing) and 4 (loud)
Definition: ProSHADE_settings.hpp:188
ProSHADE_internal_maths::complexMatrixSVDSigmasOnly
void complexMatrixSVDSigmasOnly(proshade_complex **mat, int dim, double *&singularValues)
Function to compute the complete complex matrix SVD and return only the sigmas.
Definition: ProSHADE_maths.cpp:802
ProSHADE_internal_data::ProSHADE_data::getWignerMatrixValue
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.
Definition: ProSHADE_data.cpp:3268
ProSHADE_internal_data::ProSHADE_data::getShellBandwidth
proshade_unsign getShellBandwidth(proshade_unsign shell)
This function allows access to the bandwidth of a particular shell.
Definition: ProSHADE_data.cpp:3177
ProSHADE_internal_misc::addToDoubleVector
void addToDoubleVector(std::vector< proshade_double > *vecToAddTo, proshade_double elementToAdd)
Adds the element to the vector.
Definition: ProSHADE_misc.cpp:77
ProSHADE_internal_distances::computeRRPPearsonCoefficients
void computeRRPPearsonCoefficients(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings, proshade_unsign minCommonBands, proshade_unsign minCommonShells, std::vector< proshade_double > *bandDists)
This function gets the Pearson's coefficients or all bands between two objects.
Definition: ProSHADE_distances.cpp:215
ProSHADE_internal_distances::prepareInvSOFTPlan
void prepareInvSOFTPlan(fftw_plan *inverseSO3, proshade_unsign band, fftw_complex *work1, proshade_complex *invCoeffs)
This function prepares the FFTW plan for the inverse SO(3) transform.
Definition: ProSHADE_distances.cpp:790
ProSHADE_internal_maths::pearsonCorrCoeff
proshade_double pearsonCorrCoeff(proshade_double *valSet1, proshade_double *valSet2, proshade_unsign length)
Function for computing the Pearson's correlation coefficient.
Definition: ProSHADE_maths.cpp:244
ProSHADE_internal_wigner::computeWignerMatricesForRotation
void computeWignerMatricesForRotation(ProSHADE_settings *settings, ProSHADE_internal_data::ProSHADE_data *obj, proshade_double eulerAlpha, proshade_double eulerBeta, proshade_double eulerGamma)
This function computes the Wigner D matrices for a particular set of Euler angles.
Definition: ProSHADE_wignerMatrices.cpp:260
ProSHADE_internal_peakSearch::getBestPeakEulerAngsNaive
void getBestPeakEulerAngsNaive(proshade_complex *map, proshade_unsign dim, proshade_double *eulA, proshade_double *eulB, proshade_double *eulG, ProSHADE_settings *settings)
This function finds the highest peaks optimised Euler angles using the "naive" approach.
Definition: ProSHADE_peakSearch.cpp:351
ProSHADE_settings::task
ProSHADE_Task task
This custom type variable determines which task to perfom (i.e. symmetry detection,...
Definition: ProSHADE_settings.hpp:92
ProSHADE_internal_data::ProSHADE_data::getRealSphHarmValue
proshade_double * getRealSphHarmValue(proshade_unsign band, proshade_unsign order, proshade_unsign shell)
This function allows access to the private internal real spherical harmonics values.
Definition: ProSHADE_data.cpp:3128
ProSHADE_internal_maths::complexMultiplicationConjugRealOnly
proshade_double complexMultiplicationConjugRealOnly(proshade_double *r1, proshade_double *i1, proshade_double *r2, proshade_double *i2)
Function to conjuggate multiply two complex numbers and return the real part only.
Definition: ProSHADE_maths.cpp:103
ProSHADE_internal_data::ProSHADE_data::shellBandExists
bool shellBandExists(proshade_unsign shell, proshade_unsign bandVal)
This function checks if particular shell has a particular band.
Definition: ProSHADE_data.cpp:3030
ProSHADE_internal_data::ProSHADE_data::getMaxBand
proshade_unsign getMaxBand(void)
This function returns the maximum band value for the object.
Definition: ProSHADE_data.cpp:3004
ProSHADE_internal_data::ProSHADE_data::getImagSphHarmValue
proshade_double * getImagSphHarmValue(proshade_unsign band, proshade_unsign order, proshade_unsign shell)
This function allows access to the private internal imaginary spherical harmonics values.
Definition: ProSHADE_data.cpp:3141
ProSHADE_internal_distances::computeEMatrices
void computeEMatrices(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function computes the complete E matrices and their weights between any two objects.
Definition: ProSHADE_distances.cpp:515
ProSHADE_internal_data::ProSHADE_data::getRRPValue
proshade_double getRRPValue(proshade_unsign band, proshade_unsign sh1, proshade_unsign sh2)
This function allows access to the priva internal RRP matrices.
Definition: ProSHADE_data.cpp:3014
ProSHADE_internal_distances::computeInverseSOFTTransform
void computeInverseSOFTTransform(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function computes the inverse SO(3) transform.
Definition: ProSHADE_distances.cpp:859
ProSHADE_internal_distances::computeEMatricesForLM
void computeEMatricesForLM(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, proshade_unsign bandIter, proshade_unsign orderIter, proshade_complex *radiiVals, proshade_unsign integOrder, proshade_double *abscissas, proshade_double *weights, proshade_double integRange, proshade_double sphereDist)
This function computes the E matrix un-weighted values for a given band and order and saves these int...
Definition: ProSHADE_distances.cpp:375
ProSHADE_internal_maths::getLegendreAbscAndWeights
void getLegendreAbscAndWeights(proshade_unsign order, proshade_double *abscissas, proshade_double *weights, proshade_unsign taylorSeriesCap)
Function to prepare abscissas and weights for Gauss-Legendre integration.
Definition: ProSHADE_maths.cpp:287
ProSHADE_internal_distances::computeSphericalHarmonicsMagnitude
void computeSphericalHarmonicsMagnitude(ProSHADE_internal_data::ProSHADE_data *obj, proshade_unsign band, proshade_unsign order, proshade_unsign radius, proshade_double *result)
This function computes the magnitude of a particular spherical harmonics position for a given object,...
Definition: ProSHADE_distances.cpp:346
ProSHADE_internal_data::ProSHADE_data::allocateEMatrices
void allocateEMatrices(ProSHADE_settings *settings, proshade_unsign band)
This function allocates the required memory for the E matrices.
Definition: ProSHADE_distances.cpp:280
ProSHADE_internal_misc::checkMemoryAllocation
void checkMemoryAllocation(chVar checkVar, std::string fileP, unsigned int lineP, std::string funcP, std::string infoP="This error may occurs when ProSHADE requests memory to be\n : allocated to it and this operation fails. This could\n : happen when not enough memory is available, either due to\n : other processes using a lot of memory, or when the machine\n : does not have sufficient memory available. Re-run to see\n : if this problem persists.")
Checks if memory was allocated properly.
Definition: ProSHADE_misc.hpp:65
ProSHADE_internal_distances::releaseTrSigmaWorkspace
void releaseTrSigmaWorkspace(proshade_double *&obj1Vals, proshade_double *&obj2Vals, proshade_double *&GLabscissas, proshade_double *&glWeights, proshade_complex *&radiiVals)
This helper function is responsible for deleting the workspace memory required for trace sigma descri...
Definition: ProSHADE_distances.cpp:483
ProSHADE_internal_distances::allocateInvSOFTWorkspaces
void allocateInvSOFTWorkspaces(proshade_complex *&work1, proshade_complex *&work2, proshade_double *&work3, proshade_unsign band)
This function allocates the workspaces required to compute the inverse SOFT transform.
Definition: ProSHADE_distances.cpp:766
ProSHADE_internal_data::ProSHADE_data::getInvSO3Coeffs
proshade_complex * getInvSO3Coeffs(void)
This function allows access to the inverse SO(3) coefficients array.
Definition: ProSHADE_data.cpp:3231
ProSHADE_internal_maths::complexMultiplicationConjug
void complexMultiplicationConjug(proshade_double *r1, proshade_double *i1, proshade_double *r2, proshade_double *i2, proshade_double *retReal, proshade_double *retImag)
Function to multiply two complex numbers by using the second number's conjugate.
Definition: ProSHADE_maths.cpp:62
ProSHADE_internal_distances::generateSO3CoeffsFromEMatrices
void generateSO3CoeffsFromEMatrices(ProSHADE_internal_data::ProSHADE_data *obj1, ProSHADE_internal_data::ProSHADE_data *obj2, ProSHADE_settings *settings)
This function converts the E matrices to SO(3) coefficients.
Definition: ProSHADE_distances.cpp:706
ProSHADE_internal_data::ProSHADE_data::setEMatrixValue
void setEMatrixValue(proshade_unsign band, proshade_unsign order1, proshade_unsign order2, proshade_complex val)
This function allows setting the E matrix value.
Definition: ProSHADE_data.cpp:3484
ProSHADE_internal_data::ProSHADE_data::allocateSO3CoeffsSpace
void allocateSO3CoeffsSpace(proshade_unsign band)
This function allocates the memory for the SO(3) coefficients and the inverse for that calling object...
Definition: ProSHADE_distances.cpp:680
ProSHADE_internal_messages::printProgressMessage
void printProgressMessage(proshade_signed verbose, proshade_signed messageLevel, std::string message)
General stdout message printing.
Definition: ProSHADE_messages.cpp:70
ProSHADE_settings::enLevMatrixPowerWeight
proshade_double enLevMatrixPowerWeight
If RRP matrices shell position is to be weighted by putting the position as an exponent,...
Definition: ProSHADE_settings.hpp:159
ProSHADE_internal_maths::complexMultiplicationRealOnly
proshade_double complexMultiplicationRealOnly(proshade_double *r1, proshade_double *i1, proshade_double *r2, proshade_double *i2)
Function to multiply two complex numbers and return the real part only.
Definition: ProSHADE_maths.cpp:83
ProSHADE_settings::computeEnergyLevelsDesc
bool computeEnergyLevelsDesc
If true, the energy levels descriptor will be computed, otherwise all its computations will be omitte...
Definition: ProSHADE_settings.hpp:158