ProSHADE  0.7.5.3 (FEB 2021)
Protein Shape Detection
ProSHADE_internal_wigner Namespace Reference

This namespace contains all the functionality required to perform object rotation in SO(3) space. More...

Functions

void allocateWignerWorkspace (proshade_double *&matIn, proshade_double *&matOut, proshade_double *&sqrts, proshade_double *&workspace, proshade_double *&alphaExponentReal, proshade_double *&alphaExponentImag, proshade_double *&gammaExponentReal, proshade_double *&gammaExponentImag, proshade_double *&trigs, proshade_unsign compBand)
 This function allocates the memory for the Wigner matrices computation. More...
 
void releaseWignerWorkspace (proshade_double *&matIn, proshade_double *&matOut, proshade_double *&sqrts, proshade_double *&workspace, proshade_double *&alphaExponentReal, proshade_double *&alphaExponentImag, proshade_double *&gammaExponentReal, proshade_double *&gammaExponentImag, proshade_double *&trigs)
 This function releases the memory for the Wigner matrices computation. More...
 
void prepareTrigsSqrtsAndExponents (proshade_double *sqrts, proshade_double *alphaExponentReal, proshade_double *alphaExponentImag, proshade_double *gammaExponentReal, proshade_double *gammaExponentImag, proshade_double *trigs, proshade_unsign compBand, proshade_double angAlpha, proshade_double angBeta, proshade_double angGamma)
 This function sets all the values repeatedly required for the computation. More...
 
void computeWignerMatrices (ProSHADE_settings *settings, ProSHADE_internal_data::ProSHADE_data *obj, proshade_double *alphaExponentReal, proshade_double *alphaExponentImag, proshade_double *gammaExponentReal, proshade_double *gammaExponentImag, proshade_double *matIn, proshade_double *matOut, proshade_double *trigs, proshade_double *sqrts, proshade_double *workspace)
 This function does the actual computation of the Wigner D matrices. More...
 
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. More...
 

Detailed Description

This namespace contains all the functionality required to perform object rotation in SO(3) space.

The ProSHADE namespace wraps around all the functions required to compute Wigner d and D matrices for any perticular rotation (as given by the ZXZ Euler angles) and applying these to the SO(3) coefficients of any object.

Function Documentation

◆ allocateWignerWorkspace()

void ProSHADE_internal_wigner::allocateWignerWorkspace ( proshade_double *&  matIn,
proshade_double *&  matOut,
proshade_double *&  sqrts,
proshade_double *&  workspace,
proshade_double *&  alphaExponentReal,
proshade_double *&  alphaExponentImag,
proshade_double *&  gammaExponentReal,
proshade_double *&  gammaExponentImag,
proshade_double *&  trigs,
proshade_unsign  compBand 
)

This function allocates the memory for the Wigner matrices computation.

This function allocates all the internal computation space, which will be required only for the duration of the computation and not after.

Parameters
[in]matInA pointer to the array holding the inputs for Wigner d matrix computation by SOFT.
[in]matOutA pointer to the array holding the outputs for Wigner d matrix computation by SOFT.
[in]sqrtsArray of square roots of the bands.
[in]workspaceArray required by SOFT for internal computation space.
[in]alphaExponentRealAn array of exponents of the alpha angle for the real part of the Wigner matrices.
[in]alphaExponentImagAn array of exponents of the alpha angle for the imaginary part of the Wigner matrices.
[in]gammaExponentRealAn array of exponents of the gamma angle for the real part of the Wigner matrices.
[in]gammaExponentImagAn array of exponents of the gamma angle for the imaginary part of the Wigner matrices.
[in]trigsArray of 2 doubles holding the trigonometric results for the beta angle.
[in]compBandThe bendwidth of the computation.

Definition at line 77 of file ProSHADE_wignerMatrices.cpp.

78 {
79  //================================================ Allocate the memory
80  matIn = new proshade_double[static_cast<proshade_unsign> ( 4 * pow( compBand, 2.0 ) - 4 * compBand + 1 )];
81 
82  matOut = new proshade_double[static_cast<proshade_unsign> ( 4 * pow( compBand, 2.0 ) - 4 * compBand + 1 )];
83  sqrts = new proshade_double[static_cast<proshade_unsign> ( 2 * compBand )];
84  workspace = new proshade_double[static_cast<proshade_unsign> ( 4 * pow( compBand, 2.0 ) )];
85  alphaExponentReal = new proshade_double[static_cast<proshade_unsign> ( 2 * compBand - 1 )];
86  alphaExponentImag = new proshade_double[static_cast<proshade_unsign> ( 2 * compBand - 1 )];
87  gammaExponentReal = new proshade_double[static_cast<proshade_unsign> ( 2 * compBand - 1 )];
88  gammaExponentImag = new proshade_double[static_cast<proshade_unsign> ( 2 * compBand - 1 )];
89  trigs = new proshade_double[2];
90 
91  //================================================ Check memory allocation
92  ProSHADE_internal_misc::checkMemoryAllocation ( matIn, __FILE__, __LINE__, __func__ );
93  ProSHADE_internal_misc::checkMemoryAllocation ( matOut, __FILE__, __LINE__, __func__ );
94  ProSHADE_internal_misc::checkMemoryAllocation ( sqrts, __FILE__, __LINE__, __func__ );
95  ProSHADE_internal_misc::checkMemoryAllocation ( workspace, __FILE__, __LINE__, __func__ );
96  ProSHADE_internal_misc::checkMemoryAllocation ( alphaExponentReal, __FILE__, __LINE__, __func__ );
97  ProSHADE_internal_misc::checkMemoryAllocation ( alphaExponentImag, __FILE__, __LINE__, __func__ );
98  ProSHADE_internal_misc::checkMemoryAllocation ( gammaExponentReal, __FILE__, __LINE__, __func__ );
99  ProSHADE_internal_misc::checkMemoryAllocation ( gammaExponentImag, __FILE__, __LINE__, __func__ );
100  ProSHADE_internal_misc::checkMemoryAllocation ( trigs, __FILE__, __LINE__, __func__ );
101 
102  //================================================ Done
103  return ;
104 
105 }

◆ computeWignerMatrices()

void ProSHADE_internal_wigner::computeWignerMatrices ( ProSHADE_settings settings,
ProSHADE_internal_data::ProSHADE_data obj,
proshade_double *  alphaExponentReal,
proshade_double *  alphaExponentImag,
proshade_double *  gammaExponentReal,
proshade_double *  gammaExponentImag,
proshade_double *  matIn,
proshade_double *  matOut,
proshade_double *  trigs,
proshade_double *  sqrts,
proshade_double *  workspace 
)

This function does the actual computation of the Wigner D matrices.

This function is the workhorse of the Wigner D matrices computation. It does iterate throught all the appropriate bands and order combinations and it computes the Wigner D matrix (l,m,m') values using the Wigner d matrices (which only take into account the beta Euler ZXZ angle) and the exponents obtained using the Euler ZXZ alpha and gamma angles. It also deals with the signs, but it does not deal with the memory allocation, release and general value set-up.

Parameters
[in]settingsA pointer to settings class containing all the information required for the task.
[in]objA ProSHADE_data class object for which the Wigner matrices should be computed.
[in]alphaExponentRealAn array of exponents of the alpha angle for the real part of the Wigner matrices.
[in]alphaExponentImagAn array of exponents of the alpha angle for the imaginary part of the Wigner matrices.
[in]gammaExponentRealAn array of exponents of the gamma angle for the real part of the Wigner matrices.
[in]gammaExponentImagAn array of exponents of the gamma angle for the imaginary part of the Wigner matrices.
[in]matInA pointer to the array holding the inputs for Wigner d matrix computation by SOFT.
[in]matOutA pointer to the array holding the outputs for Wigner d matrix computation by SOFT.
[in]trigsproshade_complex pointer which holds the beta angle trigonometric function results.
[in]sqrtsArray of square roots of the bands.
[in]workspaceArray required by SOFT for internal computation space.

Definition at line 189 of file ProSHADE_wignerMatrices.cpp.

190 {
191  //================================================ Report progress
192  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 2, "Start Wigner D matrix computation." );
193 
194  //================================================ For each band, find the Wigned d matrix
195  proshade_double *expARStart, *expAIStart, *expGRStart, *expGIStart;
196  proshade_double Dij, eARi, eAIi, eGRj, eGIj, iSign, rSign;
197  proshade_complex hlpVal;
198  proshade_unsign noOrders, arrConvIter;
199  for ( proshade_unsign bandIter = 0; bandIter < obj->getComparisonBand(); bandIter++ )
200  {
201  //============================================ Initialise loop
202  noOrders = 2 * bandIter + 1;
203  arrConvIter = 0;
204  expARStart = &alphaExponentReal[ (obj->getComparisonBand() - 1) - bandIter ];
205  expAIStart = &alphaExponentImag[ (obj->getComparisonBand() - 1) - bandIter ];
206  expGRStart = &gammaExponentReal[ (obj->getComparisonBand() - 1) - bandIter ];
207  expGIStart = &gammaExponentImag[ (obj->getComparisonBand() - 1) - bandIter ];
208  iSign = 1.0;
209  rSign = 1.0;
210 
211  //============================================ Get wigner d matrix values using beta angles only
212  wignerdmat ( bandIter, matIn, matOut, trigs, sqrts, workspace );
213 
214  //============================================ Multiply the wigner d matrix by alpha and gamma values and save the wigner D matrix to output array
215  for ( proshade_unsign d1Iter = 0; d1Iter < noOrders; d1Iter++ )
216  {
217  eARi = expARStart[d1Iter];
218  eAIi = expAIStart[d1Iter];
219 
220  for ( proshade_unsign d2Iter = 0; d2Iter < noOrders; d2Iter++ )
221  {
222  Dij = matOut[arrConvIter];
223  eGRj = expGRStart[d2Iter];
224  eGIj = expGIStart[d2Iter];
225 
226  hlpVal[0] = ( Dij * eGRj * eARi - Dij * eGIj * eAIi ) * rSign;
227  hlpVal[1] = ( Dij * eGRj * eAIi + Dij * eGIj * eARi ) * iSign;
228  obj->setWignerMatrixValue ( hlpVal, bandIter, d1Iter, d2Iter );
229 
230  arrConvIter += 1;
231  iSign *= -1.0;
232  rSign *= -1.0;
233  }
234  }
235 
236  //============================================ Get ready for next wigner matrix calculation
237  memcpy ( matIn, matOut, sizeof ( proshade_double ) * ( noOrders * noOrders ) );
238  }
239 
240  //================================================ Report progress
241  ProSHADE_internal_messages::printProgressMessage ( settings->verbose, 3, "Wigner D matrices obtained." );
242 
243  //================================================ Done
244  return ;
245 
246 }

◆ computeWignerMatricesForRotation()

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

This function starts by allocating the required memory to store the Wigner D matrices for a particular object and then it proceeds to allocate all the computation memory as well. Subsequently, it prepares all the values needed for the computation and it calls the workhhorse computing function. Once complete, it deletes all the now redundant memory and exits.

Parameters
[in]settingsA pointer to settings class containing all the information required for the task.
[in]objA ProSHADE_data class object for which the Wigner matrices should be computed.
[in]eulerAlphaThe Euler ZXZ convention alpha angle value for the rotation in SO(3) space.
[in]eulerBetaThe Euler ZXZ convention beta angle value for the rotation in SO(3) space.
[in]eulerGammaThe Euler ZXZ convention gamma angle value for the rotation in SO(3) space.

Definition at line 260 of file ProSHADE_wignerMatrices.cpp.

261 {
262  //================================================ Initialise local variables
263  proshade_double *matIn, *matOut, *sqrts, *workspace, *alphaExponentReal, *alphaExponentImag, *gammaExponentReal, *gammaExponentImag, *trigs;
264 
265  //================================================ Allocate memory for Wigner matrices
266  obj->allocateWignerMatricesSpace ( settings );
267 
268  //================================================ Allocate the workspace memory
269  allocateWignerWorkspace ( matIn, matOut, sqrts, workspace, alphaExponentReal, alphaExponentImag,
270  gammaExponentReal, gammaExponentImag, trigs, obj->getComparisonBand() );
271 
272  //================================================ Prepare all values for the computation
273  prepareTrigsSqrtsAndExponents ( sqrts, alphaExponentReal, alphaExponentImag, gammaExponentReal, gammaExponentImag,
274  trigs, obj->getComparisonBand(), eulerAlpha, eulerBeta, eulerGamma );
275 
276  //================================================ Compute the values
277  computeWignerMatrices ( settings, obj, alphaExponentReal, alphaExponentImag, gammaExponentReal, gammaExponentImag,
278  matIn, matOut, trigs, sqrts, workspace );
279 
280  //================================================ Release the workspace memory
281  releaseWignerWorkspace ( matIn, matOut, sqrts, workspace, alphaExponentReal, alphaExponentImag,
282  gammaExponentReal, gammaExponentImag, trigs );
283 
284  //================================================ Done
285  return ;
286 
287 }

◆ prepareTrigsSqrtsAndExponents()

void ProSHADE_internal_wigner::prepareTrigsSqrtsAndExponents ( proshade_double *  sqrts,
proshade_double *  alphaExponentReal,
proshade_double *  alphaExponentImag,
proshade_double *  gammaExponentReal,
proshade_double *  gammaExponentImag,
proshade_double *  trigs,
proshade_unsign  compBand,
proshade_double  angAlpha,
proshade_double  angBeta,
proshade_double  angGamma 
)

This function sets all the values repeatedly required for the computation.

Parameters
[in]sqrtsArray of square roots of the bands.
[in]alphaExponentRealAn array of exponents of the alpha angle for the real part of the Wigner matrices.
[in]alphaExponentImagAn array of exponents of the alpha angle for the imaginary part of the Wigner matrices.
[in]gammaExponentRealAn array of exponents of the gamma angle for the real part of the Wigner matrices.
[in]gammaExponentImagAn array of exponents of the gamma angle for the imaginary part of the Wigner matrices.
[in]trigsproshade_complex pointer which will hold the beta angle trigonometric function results.
[in]compBandThe bendwidth of the computation.
[in]angAlphaThe Euler alpha angle by which to rotate.
[in]angBetaThe Euler beta angle by which to rotate.
[in]angGammaThe Euler gamma angle by which to rotate.

Definition at line 149 of file ProSHADE_wignerMatrices.cpp.

150 {
151  //================================================ Compute the square roots
152  for ( proshade_unsign iter = 0; iter < ( 2 * compBand ); iter++ )
153  {
154  sqrts[iter] = static_cast<proshade_double> ( sqrt ( static_cast<proshade_double> ( iter ) ) );
155  }
156 
157  //================================================ Compute the trig values
158  trigs[0] = static_cast<proshade_double> ( cos ( 0.5 * -angBeta ) );
159  trigs[1] = static_cast<proshade_double> ( sin ( 0.5 * -angBeta ) );
160 
161  //================================================ Get alpha and gamma exponents
162  genExp ( compBand, angAlpha, alphaExponentReal, alphaExponentImag );
163  genExp ( compBand, angGamma, gammaExponentReal, gammaExponentImag );
164 
165  //================================================ Done
166  return ;
167 
168 }

◆ releaseWignerWorkspace()

void ProSHADE_internal_wigner::releaseWignerWorkspace ( proshade_double *&  matIn,
proshade_double *&  matOut,
proshade_double *&  sqrts,
proshade_double *&  workspace,
proshade_double *&  alphaExponentReal,
proshade_double *&  alphaExponentImag,
proshade_double *&  gammaExponentReal,
proshade_double *&  gammaExponentImag,
proshade_double *&  trigs 
)

This function releases the memory for the Wigner matrices computation.

Parameters
[in]matInA pointer to the array holding the inputs for Wigner d matrix computation by SOFT.
[in]matOutA pointer to the array holding the outputs for Wigner d matrix computation by SOFT.
[in]sqrtsArray of square roots of the bands.
[in]workspaceArray required by SOFT for internal computation space.
[in]alphaExponentRealAn array of exponents of the alpha angle for the real part of the Wigner matrices.
[in]alphaExponentImagAn array of exponents of the alpha angle for the imaginary part of the Wigner matrices.
[in]gammaExponentRealAn array of exponents of the gamma angle for the real part of the Wigner matrices.
[in]gammaExponentImagAn array of exponents of the gamma angle for the imaginary part of the Wigner matrices.

Definition at line 118 of file ProSHADE_wignerMatrices.cpp.

119 {
120  //================================================ Allocate the memory
121  if ( matIn != NULL ) { delete[] matIn; }
122  if ( matOut != NULL ) { delete[] matOut; }
123  if ( sqrts != NULL ) { delete[] sqrts; }
124  if ( workspace != NULL ) { delete[] workspace; }
125  if ( trigs != NULL ) { delete[] trigs; }
126  if ( alphaExponentReal != NULL ) { delete[] alphaExponentReal; }
127  if ( alphaExponentImag != NULL ) { delete[] alphaExponentImag; }
128  if ( gammaExponentReal != NULL ) { delete[] gammaExponentReal; }
129  if ( gammaExponentImag != NULL ) { delete[] gammaExponentImag; }
130 
131  //================================================ Done
132  return ;
133 
134 }
ProSHADE_internal_wigner::prepareTrigsSqrtsAndExponents
void prepareTrigsSqrtsAndExponents(proshade_double *sqrts, proshade_double *alphaExponentReal, proshade_double *alphaExponentImag, proshade_double *gammaExponentReal, proshade_double *gammaExponentImag, proshade_double *trigs, proshade_unsign compBand, proshade_double angAlpha, proshade_double angBeta, proshade_double angGamma)
This function sets all the values repeatedly required for the computation.
Definition: ProSHADE_wignerMatrices.cpp:149
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:3188
ProSHADE_internal_data::ProSHADE_data::setWignerMatrixValue
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.
Definition: ProSHADE_data.cpp:3471
ProSHADE_internal_wigner::releaseWignerWorkspace
void releaseWignerWorkspace(proshade_double *&matIn, proshade_double *&matOut, proshade_double *&sqrts, proshade_double *&workspace, proshade_double *&alphaExponentReal, proshade_double *&alphaExponentImag, proshade_double *&gammaExponentReal, proshade_double *&gammaExponentImag, proshade_double *&trigs)
This function releases the memory for the Wigner matrices computation.
Definition: ProSHADE_wignerMatrices.cpp:118
ProSHADE_internal_wigner::computeWignerMatrices
void computeWignerMatrices(ProSHADE_settings *settings, ProSHADE_internal_data::ProSHADE_data *obj, proshade_double *alphaExponentReal, proshade_double *alphaExponentImag, proshade_double *gammaExponentReal, proshade_double *gammaExponentImag, proshade_double *matIn, proshade_double *matOut, proshade_double *trigs, proshade_double *sqrts, proshade_double *workspace)
This function does the actual computation of the Wigner D matrices.
Definition: ProSHADE_wignerMatrices.cpp:189
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:192
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_wigner::allocateWignerWorkspace
void allocateWignerWorkspace(proshade_double *&matIn, proshade_double *&matOut, proshade_double *&sqrts, proshade_double *&workspace, proshade_double *&alphaExponentReal, proshade_double *&alphaExponentImag, proshade_double *&gammaExponentReal, proshade_double *&gammaExponentImag, proshade_double *&trigs, proshade_unsign compBand)
This function allocates the memory for the Wigner matrices computation.
Definition: ProSHADE_wignerMatrices.cpp:77
ProSHADE_internal_data::ProSHADE_data::allocateWignerMatricesSpace
void allocateWignerMatricesSpace(ProSHADE_settings *settings)
This function allocates the memory for the Wigner matrices for the calling object.
Definition: ProSHADE_wignerMatrices.cpp:29
ProSHADE_internal_messages::printProgressMessage
void printProgressMessage(proshade_signed verbose, proshade_signed messageLevel, std::string message)
General stdout message printing.
Definition: ProSHADE_messages.cpp:70