ProSHADE  0.7.6.0 (JUL 2021)
Protein Shape Detection
ProSHADE_internal_data Namespace Reference

This namespace contains the structure and functions required for data reading and storing their derivates. More...

Classes

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

Functions

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 any cyclic point group given as axis and fold. More...
 
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. More...
 

Detailed Description

This namespace contains the structure and functions required for data reading and storing their derivates.

The ProSHADE_internal_data namespace contains the data structure. It also has the data derivates storing variables, but it does not provide the computation code except for the forward declarations. The user should not need to access this namespace when using the library.

Function Documentation

◆ computeGroupElementsForGroup()

std::vector< std::vector< proshade_double > > ProSHADE_internal_data::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 any cyclic point group given as axis and fold.

Parameters
[in]xAxThe x-axis element of the axis vector of the point group axis.
[in]yAxThe y-axis element of the axis vector of the point group axis.
[in]zAxThe z-axis element of the axis vector of the point group axis.
[in]foldThe fold of the point group.
[out]valA vector containing vectors of 9 (rotation matrix) for each group element for the requested group, except for the identity element.

Definition at line 2980 of file ProSHADE_data.cpp.

2981 {
2982  //================================================ Initialise variables
2983  std::vector< proshade_double > angList;
2984  std::vector<std::vector< proshade_double > > ret;
2985 
2986  //================================================ Allocate memory
2987  proshade_double* rotMat = new proshade_double[9];
2988  ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
2989 
2990 
2991  //================================================ Normalise the axis to have magnitude of 1.0
2992  proshade_double normF = std::sqrt( std::pow ( xAx, 2.0 ) + std::pow ( yAx, 2.0 ) + std::pow ( zAx, 2.0 ) );
2993  xAx /= normF;
2994  yAx /= normF;
2995  zAx /= normF;
2996 
2997  //================================================ Determine the list of angles
2998  if ( fold % 2 == 0 )
2999  {
3000  //============================================ If fold is even, add the negative angles
3001  for ( proshade_double iter = static_cast < proshade_double > ( -( ( fold / 2 ) - 1 ) ); iter <= static_cast < proshade_double > ( fold / 2 ); iter++ )
3002  {
3003  ProSHADE_internal_misc::addToDoubleVector ( &angList, ( ( 2.0 * M_PI ) / static_cast<proshade_double> ( fold ) ) * iter );
3004  }
3005  }
3006  else
3007  {
3008  //============================================ If fold is odd, do the same as for even, but start one index earlier
3009  for ( proshade_double iter = static_cast < proshade_double > ( -fold / 2 ); iter <= static_cast < proshade_double > ( fold / 2 ); iter++ )
3010  {
3011  ProSHADE_internal_misc::addToDoubleVector ( &angList, ( ( 2.0 * M_PI ) / static_cast<proshade_double> ( fold ) ) * iter );
3012  }
3013  }
3014 
3015  //================================================ For each detected angle
3016  for ( proshade_unsign iter = 0; iter < static_cast < proshade_unsign > ( angList.size() ); iter++ )
3017  {
3018  //============================================ Compute the rotation matrix
3019  ProSHADE_internal_maths::getRotationMatrixFromAngleAxis ( rotMat, xAx, yAx, zAx, angList.at(iter) );
3020 
3021  //============================================ Convert to vector of vectors of doubles and save to ret
3022  std::vector < proshade_double > retEl;
3023  for ( proshade_unsign matIt = 0; matIt < 9; matIt++ )
3024  {
3025  ProSHADE_internal_misc::addToDoubleVector ( &retEl, rotMat[matIt] );
3026  }
3028  }
3029 
3030  //================================================ Release memory
3031  delete[] rotMat;
3032 
3033  //================================================ Done
3034  return ( ret );
3035 
3036 }

◆ joinElementsFromDifferentGroups()

std::vector< std::vector< proshade_double > > ProSHADE_internal_data::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.

Parameters
[in]firstVector of group elements.
[in]secondVector of group elements.
[in]matrixToleranceThe maximum trace error for rotation matrices to be still considered the same.
[in]combineShould the element combinations be added as well?
[out]retA vector of group elements containing all unique elements from both input element groups.

Definition at line 3133 of file ProSHADE_data.cpp.

3134 {
3135  //================================================ Initialise variables
3136  std::vector< std::vector< proshade_double > > ret;
3137 
3138  //================================================ Add the first list to ret, checking for uniqueness
3139  for ( proshade_unsign elIt = 0; elIt < static_cast<proshade_unsign> ( first->size() ); elIt++ )
3140  {
3141  if ( !checkElementAlreadyExists( &ret, &first->at(elIt), matrixTolerance ) )
3142  {
3143  ProSHADE_internal_misc::addToDoubleVectorVector ( &ret, first->at(elIt) );
3144  }
3145  }
3146 
3147  //================================================ Add the second list to ret, checking for uniqueness
3148  for ( proshade_unsign elIt = 0; elIt < static_cast<proshade_unsign> ( second->size() ); elIt++ )
3149  {
3150  if ( !checkElementAlreadyExists( &ret, &second->at(elIt), matrixTolerance ) )
3151  {
3152  ProSHADE_internal_misc::addToDoubleVectorVector ( &ret, second->at(elIt) );
3153  }
3154  }
3155 
3156  //================================================ Multiply all combinations of first and second and check for uniqueness
3157  if ( combine )
3158  {
3159  for ( proshade_unsign gr1 = 0; gr1 < static_cast<proshade_unsign> ( first->size() ); gr1++ )
3160  {
3161  for ( proshade_unsign gr2 = 0; gr2 < static_cast<proshade_unsign> ( second->size() ); gr2++ )
3162  {
3163  //==================================== Multiply the two rotation matrices
3164  std::vector< proshade_double > product = ProSHADE_internal_maths::multiplyGroupElementMatrices ( &first->at(gr1), &second->at(gr2) );
3165 
3166  //==================================== Add
3167  if ( !checkElementAlreadyExists( &ret, &product, matrixTolerance ) )
3168  {
3170  }
3171 
3172  }
3173  }
3174  }
3175 
3176  //================================================ Done
3177  return ( ret );
3178 
3179 }
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_maths::getRotationMatrixFromAngleAxis
void getRotationMatrixFromAngleAxis(proshade_double *rotMat, proshade_double x, proshade_double y, proshade_double z, proshade_double ang)
This function converts the axis-angle representation to the rotation matrix representation.
Definition: ProSHADE_maths.cpp:1448
ProSHADE_internal_misc::checkMemoryAllocation
void checkMemoryAllocation(chVar checkVar, std::string fileP, unsigned int lineP, std::string funcP, std::string infoP="This error may occurs when ProSHADE requests memory to be\n : allocated to it and this operation fails. This could\n : happen when not enough memory is available, either due to\n : other processes using a lot of memory, or when the machine\n : does not have sufficient memory available. Re-run to see\n : if this problem persists.")
Checks if memory was allocated properly.
Definition: ProSHADE_misc.hpp:67
ProSHADE_internal_misc::addToDoubleVectorVector
void addToDoubleVectorVector(std::vector< std::vector< proshade_double > > *vecToAddTo, std::vector< proshade_double > elementToAdd)
Adds the element to the vector of vectors.
Definition: ProSHADE_misc.cpp:233
ProSHADE_internal_maths::multiplyGroupElementMatrices
std::vector< proshade_double > multiplyGroupElementMatrices(std::vector< proshade_double > *el1, std::vector< proshade_double > *el2)
This function computes matrix multiplication using the ProSHADE group element matrix format as input ...
Definition: ProSHADE_maths.cpp:2245
checkElementAlreadyExists
bool checkElementAlreadyExists(std::vector< std::vector< proshade_double > > *elements, std::vector< proshade_double > *elem, proshade_double matrixTolerance)
This function checks if the element list already contains a given matrix.
Definition: ProSHADE_data.cpp:3066