ProSHADE  0.7.6.1 (AUG 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 2949 of file ProSHADE_data.cpp.

2950 {
2951  //================================================ Initialise variables
2952  std::vector< proshade_double > angList;
2953  std::vector<std::vector< proshade_double > > ret;
2954 
2955  //================================================ Allocate memory
2956  proshade_double* rotMat = new proshade_double[9];
2957  ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
2958 
2959 
2960  //================================================ Normalise the axis to have magnitude of 1.0
2961  proshade_double normF = std::sqrt( std::pow ( xAx, 2.0 ) + std::pow ( yAx, 2.0 ) + std::pow ( zAx, 2.0 ) );
2962  xAx /= normF;
2963  yAx /= normF;
2964  zAx /= normF;
2965 
2966  //================================================ Determine the list of angles
2967  if ( fold % 2 == 0 )
2968  {
2969  //============================================ If fold is even, add the negative angles
2970  for ( proshade_double iter = static_cast < proshade_double > ( -( ( fold / 2 ) - 1 ) ); iter <= static_cast < proshade_double > ( fold / 2 ); iter++ )
2971  {
2972  ProSHADE_internal_misc::addToDoubleVector ( &angList, ( ( 2.0 * M_PI ) / static_cast<proshade_double> ( fold ) ) * iter );
2973  }
2974  }
2975  else
2976  {
2977  //============================================ If fold is odd, do the same as for even, but start one index earlier
2978  for ( proshade_double iter = static_cast < proshade_double > ( -fold / 2 ); iter <= static_cast < proshade_double > ( fold / 2 ); iter++ )
2979  {
2980  ProSHADE_internal_misc::addToDoubleVector ( &angList, ( ( 2.0 * M_PI ) / static_cast<proshade_double> ( fold ) ) * iter );
2981  }
2982  }
2983 
2984  //================================================ For each detected angle
2985  for ( proshade_unsign iter = 0; iter < static_cast < proshade_unsign > ( angList.size() ); iter++ )
2986  {
2987  //============================================ Compute the rotation matrix
2988  ProSHADE_internal_maths::getRotationMatrixFromAngleAxis ( rotMat, xAx, yAx, zAx, angList.at(iter) );
2989 
2990  //============================================ Convert to vector of vectors of doubles and save to ret
2991  std::vector < proshade_double > retEl;
2992  for ( proshade_unsign matIt = 0; matIt < 9; matIt++ )
2993  {
2994  ProSHADE_internal_misc::addToDoubleVector ( &retEl, rotMat[matIt] );
2995  }
2997  }
2998 
2999  //================================================ Release memory
3000  delete[] rotMat;
3001 
3002  //================================================ Done
3003  return ( ret );
3004 
3005 }

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

3103 {
3104  //================================================ Initialise variables
3105  std::vector< std::vector< proshade_double > > ret;
3106 
3107  //================================================ Add the first list to ret, checking for uniqueness
3108  for ( proshade_unsign elIt = 0; elIt < static_cast<proshade_unsign> ( first->size() ); elIt++ )
3109  {
3110  if ( !checkElementAlreadyExists( &ret, &first->at(elIt), matrixTolerance ) )
3111  {
3112  ProSHADE_internal_misc::addToDoubleVectorVector ( &ret, first->at(elIt) );
3113  }
3114  }
3115 
3116  //================================================ Add the second list to ret, checking for uniqueness
3117  for ( proshade_unsign elIt = 0; elIt < static_cast<proshade_unsign> ( second->size() ); elIt++ )
3118  {
3119  if ( !checkElementAlreadyExists( &ret, &second->at(elIt), matrixTolerance ) )
3120  {
3121  ProSHADE_internal_misc::addToDoubleVectorVector ( &ret, second->at(elIt) );
3122  }
3123  }
3124 
3125  //================================================ Multiply all combinations of first and second and check for uniqueness
3126  if ( combine )
3127  {
3128  for ( proshade_unsign gr1 = 0; gr1 < static_cast<proshade_unsign> ( first->size() ); gr1++ )
3129  {
3130  for ( proshade_unsign gr2 = 0; gr2 < static_cast<proshade_unsign> ( second->size() ); gr2++ )
3131  {
3132  //==================================== Multiply the two rotation matrices
3133  std::vector< proshade_double > product = ProSHADE_internal_maths::multiplyGroupElementMatrices ( &first->at(gr1), &second->at(gr2) );
3134 
3135  //==================================== Add
3136  if ( !checkElementAlreadyExists( &ret, &product, matrixTolerance ) )
3137  {
3139  }
3140 
3141  }
3142  }
3143  }
3144 
3145  //================================================ Done
3146  return ( ret );
3147 
3148 }
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:1444
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:2241
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:3035