ProSHADE: ProSHADE_internal_io Namespace Reference

| ProSHADE 0.7.5.1 (JAN 2021) Protein Shape Detection

Enumerations | Functions
ProSHADE_internal_io Namespace Reference

This namespace contains the internal input/output functions. None of these should be directly accessed by the user. More...

## Enumerations
enum | InputType { UNKNOWN, PDB, MAP }

## Functions
InputType | figureDataType (std::string fName)
| Function determining input data type. More...
bool | isFilePDB (std::string fName)
| Function determining if the input data type is PDB. More...
bool | isFileMAP (std::string fName)
| Function determining if the input data type is MAP. More...
void | readInMapHeader (gemmi::Ccp4< float > *map, proshade_unsign *xDimInds, proshade_unsign *yDimInds, proshade_unsign *zDimInds, proshade_single *xDim, proshade_single *yDim, proshade_single *zDim, proshade_single *aAng, proshade_single *bAng, proshade_single *cAng, proshade_signed *xFrom, proshade_signed *yFrom, proshade_signed *zFrom, proshade_signed *xAxOrigin, proshade_signed *yAxOrigin, proshade_signed *zAxOrigin, proshade_unsign *xAxOrder, proshade_unsign *yAxOrder, proshade_unsign *zAxOrder, proshade_unsign *xGridInds, proshade_unsign *yGridInds, proshade_unsign *zGridInds)
| This function parses the CCP4 MAP file header as read in by gemmi. More...
void | readInMapData (gemmi::Ccp4< float > *gemmiMap, proshade_double *&map, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_unsign xAxOrder, proshade_unsign yAxOrder, proshade_unsign zAxOrder)
| This function converts the gemmi Ccp4 object data to ProSHADE internal map representation. More...
void | writeOutMapHeader (gemmi::Ccp4< float > *map, proshade_unsign xDimInds, proshade_unsign yDimInds, proshade_unsign zDimInds, proshade_single xDim, proshade_single yDim, proshade_single zDim, proshade_single aAng, proshade_single bAng, proshade_single cAng, proshade_signed xFrom, proshade_signed yFrom, proshade_signed zFrom, proshade_signed xAxOrigin, proshade_signed yAxOrigin, proshade_signed zAxOrigin, proshade_unsign xAxOrder, proshade_unsign yAxOrder, proshade_unsign zAxOrder, proshade_unsign xGridInds, proshade_unsign yGridInds, proshade_unsign zGridInds, std::string title, int mode)
| This function parses the CCP4 MAP file header as read in by gemmi. More...
void | writeRotationTranslationJSON (proshade_double trsX1, proshade_double trsY1, proshade_double trsZ1, proshade_double eulA, proshade_double eulB, proshade_double eulG, proshade_double trsX2, proshade_double trsY2, proshade_double trsZ2, std::string fileName)
| Function for writing out the optimal rotation and translation into a JSON file. More...

## Detailed Description

This namespace contains the internal input/output functions. None of these should be directly accessed by the user.

The ProSHADE_internal_io namespace contains the helper functions for the data input and output. These should never be directly used by the user and these only serve to allow for self-documenting nature of the code. They are called internally by more advanced functions from the higher complexity classes.

## Function Documentation

## ◆ figureDataType()

ProSHADE_internal_io::InputType ProSHADE_internal_io::figureDataType | ( | std::string | fName | ) |

Function determining input data type.

This function determines the type of the input structure. The possible outputs are MAP for MRC map files, PDB for mmCIF or PDB formatted data, or UNKNOWN if gemmi fail to read the file as co-ordinates as well as map.

Parameters

  [in] | fName | The file name of the file for which the type should be determined.
  [out] | X | ProSHADE InputType variable with values UNKNOWN, MAP or PDB depending on the type of the input file.

Definition at line 292 of file ProSHADE_io.cpp.

293 {
294 //================================================ Try readin as PDB
295 if ( isFilePDB ( fName ) )
296 {
297 return ( PDB );
298 }
299
300 //================================================ If not, try readin as MAP
301 if ( isFileMAP ( fName ) )
302 {
303 return ( MAP );
304 }
305
306 //================================================ No luck? UNKNOWN it is ...
307 return ( UNKNOWN );
308
309 //================================================ Done
310
311 }

## ◆ isFileMAP()

bool ProSHADE_internal_io::isFileMAP | ( | std::string | fName | ) |

Function determining if the input data type is MAP.

This function checks if the input file is a MAP file and can be read by the CMAP library.

Parameters

  [in] | fName | The file name of the file for which the type should be determined.
  [out] | X | Bool value true if the file is a MAP file readable by CMAP and false otherwise.

Definition at line 57 of file ProSHADE_io.cpp.

58 {
59 gemmi::Ccp4<float> map;
60 try
61 {
62 map.read_ccp4 ( gemmi::MaybeGzipped (fName.c_str() ) );
63 }
64 catch ( std::runtime_error& e )
65 {
66 //============================================ Failed to read the map
67 return ( false );
68 }
69
70 //================================================ Done
71 return ( true );
72
73 }

## ◆ isFilePDB()

bool ProSHADE_internal_io::isFilePDB | ( | std::string | fName | ) |

Function determining if the input data type is PDB.

This function checks if the input file is a PDB file and can be read by the gemmi library.

Parameters

  [in] | fName | The file name of the file for which the type should be determined.
  [out] | X | Bool value true if the file is a PDB file readable by gemmi and false otherwise.

Definition at line 32 of file ProSHADE_io.cpp.

33 {
34 //================================================ Try reading the file using Gemmi
35 try
36 {
37 gemmi::Structure structure = gemmi::read_structure ( gemmi::MaybeGzipped ( fName ) );
38 }
39 catch ( std::runtime_error& e )
40 {
41 //============================================ Read failed. Done
42 return ( false );
43 }
44
45 //================================================ Read successfull. Done
46 return ( true );
47
48 }

## ◆ readInMapData()

void ProSHADE_internal_io::readInMapData | ( | gemmi::Ccp4< float > * | gemmiMap,
|  | proshade_double *& | map,
|  | proshade_unsign | xDimInds,
|  | proshade_unsign | yDimInds,
|  | proshade_unsign | zDimInds,
|  | proshade_unsign | xAxOrder,
|  | proshade_unsign | yAxOrder,
|  | proshade_unsign | zAxOrder
| ) |  |

This function converts the gemmi Ccp4 object data to ProSHADE internal map representation.

This function firstly allocates the required memory for the ProSHADE internal map representation variable according to the grid size. Then, it iterates over the axes in such a way, so that the resulting ProSHADE variable would have XYZ axis order independently on the axis order of the Ccp4 gemmi object. This should not be necessary as the gemmi setup function should have been called by now, but one never knows.

Parameters

  [in] | gemmiMap | Pointer to a gemmi Ccp4 object containing the read in MAP file information.
  [in] | map | Pointer reference to a variable to save the map data.
  [in] | xDimInds | The size of x dimension in indices.
  [in] | yDimInds | The size of y dimension in indices.
  [in] | zDimInds | The size of z dimension in indices.
  [in] | xAxOrder | The order of the x-axis.
  [in] | yAxOrder | The order of the y-axis.
  [in] | zAxOrder | The order of the z-axis.

Definition at line 172 of file ProSHADE_io.cpp.

173 {
174 //================================================ Allocate internal variables
175 proshade_unsign *axOrdArr = new proshade_unsign[3];
176 proshade_unsign *axDimArr = new proshade_unsign[3];
177 proshade_unsign arrPos = 0;
178
179 //================================================ Check memory allocation and fill in values
180 ProSHADE_internal_misc::checkMemoryAllocation ( axOrdArr, __FILE__, __LINE__, __func__ );
181 ProSHADE_internal_misc::checkMemoryAllocation ( axDimArr, __FILE__, __LINE__, __func__ );
182 axDimArr[0] = xDimInds;
183 axDimArr[1] = yDimInds;
184 axDimArr[2] = zDimInds;
185
186 //================================================ Allocate the ProSHADE internal map variable memory
187 map = new proshade_double [xDimInds * yDimInds * zDimInds];
188 ProSHADE_internal_misc::checkMemoryAllocation ( map, __FILE__, __LINE__, __func__ );
189
190 //================================================ Copy read in data to internal map variable
191 for ( axOrdArr[0] = 0; axOrdArr[0] < axDimArr[xAxOrder-1]; axOrdArr[0]++ )
192 {
193 for ( axOrdArr[1] = 0; axOrdArr[1] < axDimArr[yAxOrder-1]; axOrdArr[1]++ )
194 {
195 for ( axOrdArr[2] = 0; axOrdArr[2] < axDimArr[zAxOrder-1]; axOrdArr[2]++ )
196 {
197 arrPos = axOrdArr[2] + axDimArr[zAxOrder-1] * ( axOrdArr[1] + axDimArr[yAxOrder-1] * axOrdArr[0] );
198 map[arrPos] = gemmiMap->grid.get_value_q( axOrdArr[xAxOrder-1], axOrdArr[yAxOrder-1], axOrdArr[zAxOrder-1] );
199 }
200 }
201 }
202
203 //================================================ Release internal variables memory
204 delete[] axDimArr;
205 delete[] axOrdArr;
206
207 //================================================ Done
208 return ;
209
210 }

## ◆ readInMapHeader()

void ProSHADE_internal_io::readInMapHeader | ( | gemmi::Ccp4< float > * | map,
|  | proshade_unsign * | xDimInds,
|  | proshade_unsign * | yDimInds,
|  | proshade_unsign * | zDimInds,
|  | proshade_single * | xDim,
|  | proshade_single * | yDim,
|  | proshade_single * | zDim,
|  | proshade_single * | aAng,
|  | proshade_single * | bAng,
|  | proshade_single * | cAng,
|  | proshade_signed * | xFrom,
|  | proshade_signed * | yFrom,
|  | proshade_signed * | zFrom,
|  | proshade_signed * | xAxOrigin,
|  | proshade_signed * | yAxOrigin,
|  | proshade_signed * | zAxOrigin,
|  | proshade_unsign * | xAxOrder,
|  | proshade_unsign * | yAxOrder,
|  | proshade_unsign * | zAxOrder,
|  | proshade_unsign * | xGridInds,
|  | proshade_unsign * | yGridInds,
|  | proshade_unsign * | zGridInds
| ) |  |

This function parses the CCP4 MAP file header as read in by gemmi.

This function uses the gemmi Ccp4 object, which contains all the information read in from a MAP file (including the header), to parse out the ProSHADE required information from the header and saving it to the supplied variables.

Parameters

  [in] | map | A gemmi Ccp4 objecct containing all the data read in from a MAP file.
  [in] | xDimInds | Address to a variable to save the x-axis size in indices.
  [in] | yDimInds | Address to a variable to save the y-axis size in indices.
  [in] | zDimInds | Address to a variable to save the z-axis size in indices.
  [in] | xDim | Address to a variable to save the x dimension size in angstroms.
  [in] | yDim | Address to a variable to save the y dimension size in angstroms.
  [in] | zDim | Address to a variable to save the z dimension size in angstroms.
  [in] | aAng | Address to a variable to save the a angle in degrees.
  [in] | bAng | Address to a variable to save the b angle in degrees.
  [in] | cAng | Address to a variable to save the c angle in degrees.
  [in] | xFrom | Address to a variable to save the starting index along the x-axis.
  [in] | yFrom | Address to a variable to save the starting index along the y-axis.
  [in] | zFrom | Address to a variable to save the starting index along the z-axis.
  [in] | xAxOrigin | Address to a variable to save the map origin positon along the x-axis.
  [in] | yAxOrigin | Address to a variable to save the map origin positon along the y-axis.
  [in] | zAxOrigin | Address to a variable to save the map origin positon along the z-axis.
  [in] | xAxOrder | Address to a variable to save the order of x axis.
  [in] | yAxOrder | Address to a variable to save the order of y axis.
  [in] | zAxOrder | Address to a variable to save the order of z axis.
  [in] | xGridInds | Address to a variable to save the grid indices count along the x-axis.
  [in] | yGridInds | Address to a variable to save the grid indices count along the y-axis.
  [in] | zGridInds | Address to a variable to save the grid indices count along the z-axis.

Definition at line 103 of file ProSHADE_io.cpp.

104 {
105 //================================================ Read in the map file header
106 *xDimInds = static_cast<proshade_unsign> ( map->header_i32 ( 1 ) );
107 *yDimInds = static_cast<proshade_unsign> ( map->header_i32 ( 2 ) );
108 *zDimInds = static_cast<proshade_unsign> ( map->header_i32 ( 3 ) );
109
110 *xFrom = static_cast<proshade_signed> ( map->header_i32 ( 5 ) );
111 *yFrom = static_cast<proshade_signed> ( map->header_i32 ( 6 ) );
112 *zFrom = static_cast<proshade_signed> ( map->header_i32 ( 7 ) );
113
114 *xDim = static_cast<proshade_single> ( map->header_float ( 11 ) );
115 *yDim = static_cast<proshade_single> ( map->header_float ( 12 ) );
116 *zDim = static_cast<proshade_single> ( map->header_float ( 13 ) );
117
118 *aAng = static_cast<proshade_single> ( map->header_float ( 14 ) );
119 *bAng = static_cast<proshade_single> ( map->header_float ( 15 ) );
120 *cAng = static_cast<proshade_single> ( map->header_float ( 16 ) );
121
122 *xAxOrigin = static_cast<proshade_signed> ( map->header_i32 ( 50 ) ) + (*xFrom);
123 *yAxOrigin = static_cast<proshade_signed> ( map->header_i32 ( 51 ) ) + (*yFrom);
124 *zAxOrigin = static_cast<proshade_signed> ( map->header_i32 ( 52 ) ) + (*zFrom);
125
126 *xAxOrder = static_cast<proshade_unsign> ( map->header_i32 ( 17 ) );
127 *yAxOrder = static_cast<proshade_unsign> ( map->header_i32 ( 18 ) );
128 *zAxOrder = static_cast<proshade_unsign> ( map->header_i32 ( 19 ) );
129
130 *xGridInds = static_cast<proshade_unsign> ( map->header_i32 ( 8 ) );
131 *yGridInds = static_cast<proshade_unsign> ( map->header_i32 ( 9 ) );
132 *zGridInds = static_cast<proshade_unsign> ( map->header_i32 ( 10 ) );
133
134 //================================================ Deal with sampling being different from cell size
135 if ( *xGridInds != *xDimInds )
136 {
137 *xDim = *xDim * ( static_cast<proshade_single> ( *xDimInds ) / static_cast<proshade_single> ( *xGridInds ) );
138 *xGridInds = *xDimInds;
139 }
140
141 if ( *yGridInds != *yDimInds )
142 {
143 *yDim = *yDim * ( static_cast<proshade_single> ( *yDimInds ) / static_cast<proshade_single> ( *yGridInds ) );
144 *yGridInds = *yDimInds;
145 }
146
147 if ( *zGridInds != *zDimInds )
148 {
149 *zDim = *zDim * ( static_cast<proshade_single> ( *zDimInds ) / static_cast<proshade_single> ( *zGridInds ) );
150 *zGridInds = *zDimInds;
151 }
152
153 //================================================ Done
154 return ;
155
156 }

## ◆ writeOutMapHeader()

void ProSHADE_internal_io::writeOutMapHeader | ( | gemmi::Ccp4< float > * | map,
|  | proshade_unsign | xDimInds,
|  | proshade_unsign | yDimInds,
|  | proshade_unsign | zDimInds,
|  | proshade_single | xDim,
|  | proshade_single | yDim,
|  | proshade_single | zDim,
|  | proshade_single | aAng,
|  | proshade_single | bAng,
|  | proshade_single | cAng,
|  | proshade_signed | xFrom,
|  | proshade_signed | yFrom,
|  | proshade_signed | zFrom,
|  | proshade_signed | xAxOrigin,
|  | proshade_signed | yAxOrigin,
|  | proshade_signed | zAxOrigin,
|  | proshade_unsign | xAxOrder,
|  | proshade_unsign | yAxOrder,
|  | proshade_unsign | zAxOrder,
|  | proshade_unsign | xGridInds,
|  | proshade_unsign | yGridInds,
|  | proshade_unsign | zGridInds,
|  | std::string | title,
|  | int | mode
| ) |  |

This function parses the CCP4 MAP file header as read in by gemmi.

This function uses the gemmi Ccp4 object, which contains all the information read in from a MAP file (including the header), to parse out the ProSHADE required information from the header and saving it to the supplied variables.

Parameters

  [in] | map | A gemmi Ccp4 objecct containing all the data read in from a MAP file.
  [in] | xDimInds | Variable holding the x-axis size in indices.
  [in] | yDimInds | Variable holding the y-axis size in indices.
  [in] | zDimInds | Variable holding the z-axis size in indices.
  [in] | xDim | Variable holding the x dimension size in angstroms.
  [in] | yDim | Variable holding the y dimension size in angstroms.
  [in] | zDim | Variable holding the z dimension size in angstroms.
  [in] | aAng | Variable holding the a angle in degrees.
  [in] | bAng | Variable holding the b angle in degrees.
  [in] | cAng | Variable holding the c angle in degrees.
  [in] | xFrom | Variable holding the starting index along the x-axis.
  [in] | yFrom | Variable holding the starting index along the y-axis.
  [in] | zFrom | Variable holding the starting index along the z-axis.
  [in] | xAxOrigin | Variable holding the map origin positon along the x-axis.
  [in] | yAxOrigin | Variable holding the map origin positon along the y-axis.
  [in] | zAxOrigin | Variable holding the map origin positon along the z-axis.
  [in] | xAxOrder | Variable holding the order of x axis.
  [in] | yAxOrder | Variable holding the order of y axis.
  [in] | zAxOrder | Variable holding the order of z axis.
  [in] | xGridInds | Variable holding the grid indices count along the x-axis.
  [in] | yGridInds | Variable holding the grid indices count along the y-axis.
  [in] | zGridInds | Variable holding the grid indices count along the z-axis.
  [in] | title | The title to be written into the MAP file.
  [in] | mode | The variable type of the data, please leave two (float) unless you require any specific other mode.

Definition at line 242 of file ProSHADE_io.cpp.

243 {
244 //================================================ Fill in the map file header
245 map->set_header_i32 ( 1 , static_cast<int32_t> ( xDimInds ) ); // Number of columns in 3D data array (fast axis)
246 map->set_header_i32 ( 2 , static_cast<int32_t> ( yDimInds ) ); // Number of columns in 3D data array (medium axis)
247 map->set_header_i32 ( 3 , static_cast<int32_t> ( zDimInds ) ); // Number of columns in 3D data array (slow axis)
248 map->set_header_i32 ( 4 , static_cast<int32_t> ( mode ) ); // Map mode
249 map->set_header_i32 ( 5 , static_cast<int32_t> ( xFrom ) ); // Starting index (fast axis)
250 map->set_header_i32 ( 6 , static_cast<int32_t> ( yFrom ) ); // Starting index (medium axis)
251 map->set_header_i32 ( 7 , static_cast<int32_t> ( zFrom ) ); // Starting index (slow axis)
252 map->set_header_i32 ( 8 , static_cast<int32_t> ( xGridInds ) ); // Grid sampling (fast axis)
253 map->set_header_i32 ( 9 , static_cast<int32_t> ( yGridInds ) ); // Grid sampling (medium axis)
254 map->set_header_i32 ( 10, static_cast<int32_t> ( zGridInds ) ); // Grid sampling (slow axis)
255 map->set_header_float ( 11, static_cast<float> ( xDim ) ); // Grid dimension in Angstrom (fast axis)
256 map->set_header_float ( 12, static_cast<float> ( yDim ) ); // Grid dimension in Angstrom (medium axis)
257 map->set_header_float ( 13, static_cast<float> ( zDim ) ); // Grid dimension in Angstrom (slow axis)
258 map->set_header_float ( 14, static_cast<float> ( aAng ) ); // Alpha angle in degrees
259 map->set_header_float ( 15, static_cast<float> ( bAng ) ); // Beta angle in degrees
260 map->set_header_float ( 16, static_cast<float> ( cAng ) ); // Gamma angle in degrees
261 map->set_header_i32 ( 17, static_cast<int32_t> ( xAxOrder ) ); // MAPC
262 map->set_header_i32 ( 18, static_cast<int32_t> ( yAxOrder ) ); // MAPR
263 map->set_header_i32 ( 19, static_cast<int32_t> ( zAxOrder ) ); // MAPS
264 if ( map->grid.spacegroup ) { map->set_header_i32 ( 23, static_cast<int32_t> ( map->grid.spacegroup->ccp4 ) ); } // Space group
265 else { map->set_header_i32 ( 23, static_cast<int32_t> ( 1 ) ); }
266 map->set_header_i32 ( 24, static_cast<int32_t> ( map->grid.spacegroup->operations().order() * 80 ) ); // NSYMBT - size of extended header (which follows main header) in bytes
267 map->set_header_str ( 27, "CCP4" ); // Code for the type of extended header
268 map->set_header_i32 ( 28, static_cast<int32_t> ( 20140 ) ); // Version
269 map->set_header_i32 ( 50, static_cast<int32_t> ( xAxOrigin ) ); // Origin of the map (fast axis)
270 map->set_header_i32 ( 51, static_cast<int32_t> ( yAxOrigin ) ); // Origin of the map (medium axis)
271 map->set_header_i32 ( 52, static_cast<int32_t> ( zAxOrigin ) ); // Origin of the map (slow axis)
272 map->set_header_str ( 53, "MAP" ); // File format
273 if ( gemmi::is_little_endian() ) { map->set_header_i32 ( 54, static_cast<int32_t> ( 0x00004144 ) ); } // Machine stamp encoding byte ordering of data
274 else { map->set_header_i32 ( 54, static_cast<int32_t> ( 0x11110000 ) ); }
275 map->set_header_i32 ( 56, static_cast<int32_t> ( 1 ) ); // Number of labels used
276 std::memset ( reinterpret_cast<void*> ( &(map->ccp4_header.at( 56 )) ), ' ', 800 + map->grid.spacegroup->operations().order() * 80); // 56 is used because the vector is indexed from 0
277 map->set_header_str ( 57, title ); // Title
278
279 //================================================ Done
280 return ;
281
282 }

## ◆ writeRotationTranslationJSON()

void ProSHADE_internal_io::writeRotationTranslationJSON | ( | proshade_double | trsX1,
|  | proshade_double | trsY1,
|  | proshade_double | trsZ1,
|  | proshade_double | eulA,
|  | proshade_double | eulB,
|  | proshade_double | eulG,
|  | proshade_double | trsX2,
|  | proshade_double | trsY2,
|  | proshade_double | trsZ2,
|  | std::string | fileName
| ) |  |

Function for writing out the optimal rotation and translation into a JSON file.

This function takes the initial translation (assuming that the centre of rotation is not at the centre of indices), the rotation (in terms of the Euler angles) and the translation detected by the overlay task and proceeds to write a JSON file containing all of these information in the order in which they should be applied with the exception that depending on around which point the rotation should be done, either the translation to origin or to the map centre should be applied.

This function assumes that the second translation includes the reverse of the first translation already.

Parameters

  [in] | trsX1 | The translation required to get the rotation centre to origin along the x-axis.
  [in] | trsY1 | The translation required to get the rotation centre to origin along the y-axis.
  [in] | trsZ1 | The translation required to get the rotation centre to origin along the z-axis.
  [in] | eulA | The optimal rotation Euler angle alpha.
  [in] | eulB | The optimal rotation Euler angle beta.
  [in] | eulG | The optimal rotation Euler angle gamma.
  [in] | trsX2 | The optimal translation along the x-axis + reverse of the trsX1.
  [in] | trsY2 | The optimal translation along the y-axis + reverse of the trsY1.
  [in] | trsZ2 | The optimal translation along the z-axis + reverse of the trsZ1.
  [in] | fileName | The file name of the file for which the information should be written into.

Definition at line 334 of file ProSHADE_io.cpp.

335 {
336 //================================================ Open file for writing
337 std::ofstream jsonFile;
338 jsonFile.open ( fileName );
339
340 //================================================ Check file opening success
341 if ( !jsonFile.is_open( ) )
342 {
343 throw ProSHADE_exception ( "Failed to open JSON output file.", "E000056", __FILE__, __LINE__, __func__, "Failed to open json file to which the rotation and\n : translation would be written into. Most likely cause is\n : lack of rights to write in the current folder." );
344 }
345
346 //================================================ Get rotation matrix from Euler angles
347 proshade_double* rotMat = new proshade_double[9];
348 ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
349 ProSHADE_internal_maths::getRotationMatrixFromEulerZXZAngles ( eulA, eulB, eulG, rotMat );
350
351 //================================================ Write the info
352 jsonFile << "{\n";
353 jsonFile << " \"translationToOrigin\" : [ " << trsX1 << ", " << trsY1 << ", " << trsZ1 << " ], \n";
354
355 jsonFile << " \"rotationMatrix:\" : [ " << rotMat[0] << ", " << rotMat[1] << ", " << rotMat[2] << ", \n";
356 jsonFile << " " << rotMat[3] << ", " << rotMat[4] << ", " << rotMat[5] << ", \n";
357 jsonFile << " " << rotMat[6] << ", " << rotMat[7] << ", " << rotMat[8] << "], \n";
358
359 jsonFile << " \"translationFromRotCenToOverlay\" : [ " << trsX2 << ", " << trsY2 << ", " << trsZ2 << " ] \n";
360 jsonFile << "}\n";
361
362 //================================================ Close file
363 jsonFile.close ( );
364
365 //================================================ Release memory
366 delete[] rotMat;
367
368 //================================================ Done
369 return ;
370
371 }
ProSHADE_internal_io::isFilePDB
bool isFilePDB(std::string fName)
Function determining if the input data type is PDB.
Definition: ProSHADE_io.cpp:32
ProSHADE_exception
This class is the representation of ProSHADE exception.
Definition: ProSHADE_exceptions.hpp:37
ProSHADE_internal_maths::getRotationMatrixFromEulerZXZAngles
void getRotationMatrixFromEulerZXZAngles(proshade_double eulerAlpha, proshade_double eulerBeta, proshade_double eulerGamma, proshade_double *matrix)
Function to find the rotation matrix from Euler angles (ZXZ convention).
Definition: ProSHADE_maths.cpp:1005
ProSHADE_internal_io::isFileMAP
bool isFileMAP(std::string fName)
Function determining if the input data type is MAP.
Definition: ProSHADE_io.cpp:57
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