ProSHADE  0.7.6.0 (JUL 2021)
Protein Shape Detection
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 readInMapData (gemmi::Ccp4< int8_t > *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 mask 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]fNameThe file name of the file for which the type should be determined.
[out]XProSHADE InputType variable with values UNKNOWN, MAP or PDB depending on the type of the input file.

Definition at line 356 of file ProSHADE_io.cpp.

357 {
358  //================================================ Try readin as PDB
359  if ( isFilePDB ( fName ) )
360  {
361  return ( PDB );
362  }
363 
364  //================================================ If not, try readin as MAP
365  if ( isFileMAP ( fName ) )
366  {
367  return ( MAP );
368  }
369 
370  //================================================ No luck? UNKNOWN it is ...
371  return ( UNKNOWN );
372 
373  //================================================ Done
374 
375 }

◆ 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]fNameThe file name of the file for which the type should be determined.
[out]XBool value true if the file is a MAP file readable by CMAP and false otherwise.

Definition at line 60 of file ProSHADE_io.cpp.

61 {
62  gemmi::Ccp4<float> map;
63  try
64  {
65  map.read_ccp4 ( gemmi::MaybeGzipped (fName.c_str() ) );
66  }
67  catch ( std::runtime_error& e )
68  {
69  //============================================ Supress MSVC C4101 Unferenced variable warning / clang and gcc -Wunused-exception-parameter
70  (void)e;
71 
72  //============================================ Failed to read the map
73  return ( false );
74  }
75 
76  //================================================ Done
77  return ( true );
78 
79 }

◆ 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]fNameThe file name of the file for which the type should be determined.
[out]XBool 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  //============================================ Supress MSVC C4101 Unferenced variable warning / clang and gcc -Wunused-exception-parameter
42  (void)e;
43 
44  //============================================ Read failed. Done
45  return ( false );
46  }
47 
48  //================================================ Read successfull. Done
49  return ( true );
50 
51 }

◆ readInMapData() [1/2]

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]gemmiMapPointer to a gemmi Ccp4 object containing the read in MAP file information.
[in]mapPointer reference to a variable to save the map data.
[in]xDimIndsThe size of x dimension in indices.
[in]yDimIndsThe size of y dimension in indices.
[in]zDimIndsThe size of z dimension in indices.
[in]xAxOrderThe order of the x-axis.
[in]yAxOrderThe order of the y-axis.
[in]zAxOrderThe order of the z-axis.

Definition at line 178 of file ProSHADE_io.cpp.

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

◆ readInMapData() [2/2]

void ProSHADE_internal_io::readInMapData ( gemmi::Ccp4< int8_t > *  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 mask representation.

This function firstly allocates the required memory for the ProSHADE mask 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]gemmiMapPointer to a gemmi Ccp4 object containing the read in mask file information.
[in]mapPointer reference to a variable to save the map data.
[in]xDimIndsThe size of x dimension in indices.
[in]yDimIndsThe size of y dimension in indices.
[in]zDimIndsThe size of z dimension in indices.
[in]xAxOrderThe order of the x-axis.
[in]yAxOrderThe order of the y-axis.
[in]zAxOrderThe order of the z-axis.

Definition at line 234 of file ProSHADE_io.cpp.

235 {
236  //================================================ Allocate internal variables
237  proshade_unsign *axOrdArr = new proshade_unsign[3];
238  proshade_unsign *axDimArr = new proshade_unsign[3];
239  proshade_unsign arrPos = 0;
240 
241  //================================================ Check memory allocation and fill in values
242  ProSHADE_internal_misc::checkMemoryAllocation ( axOrdArr, __FILE__, __LINE__, __func__ );
243  ProSHADE_internal_misc::checkMemoryAllocation ( axDimArr, __FILE__, __LINE__, __func__ );
244  axDimArr[0] = xDimInds;
245  axDimArr[1] = yDimInds;
246  axDimArr[2] = zDimInds;
247 
248  //================================================ Allocate the ProSHADE internal map variable memory
249  map = new proshade_double [xDimInds * yDimInds * zDimInds];
250  ProSHADE_internal_misc::checkMemoryAllocation ( map, __FILE__, __LINE__, __func__ );
251 
252  //================================================ Copy read in data to internal map variable
253  for ( axOrdArr[0] = 0; axOrdArr[0] < axDimArr[xAxOrder-1]; axOrdArr[0]++ )
254  {
255  for ( axOrdArr[1] = 0; axOrdArr[1] < axDimArr[yAxOrder-1]; axOrdArr[1]++ )
256  {
257  for ( axOrdArr[2] = 0; axOrdArr[2] < axDimArr[zAxOrder-1]; axOrdArr[2]++ )
258  {
259  arrPos = axOrdArr[2] + axDimArr[zAxOrder-1] * ( axOrdArr[1] + axDimArr[yAxOrder-1] * axOrdArr[0] );
260  map[arrPos] = static_cast< proshade_double > ( gemmiMap->grid.get_value_q( static_cast< int > ( axOrdArr[xAxOrder-1] ),
261  static_cast< int > ( axOrdArr[yAxOrder-1] ),
262  static_cast< int > ( axOrdArr[zAxOrder-1] ) ) );
263  }
264  }
265  }
266 
267  //================================================ Release internal variables memory
268  delete[] axDimArr;
269  delete[] axOrdArr;
270 
271  //================================================ Done
272  return ;
273 
274 }

◆ 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]mapA gemmi Ccp4 objecct containing all the data read in from a MAP file.
[in]xDimIndsAddress to a variable to save the x-axis size in indices.
[in]yDimIndsAddress to a variable to save the y-axis size in indices.
[in]zDimIndsAddress to a variable to save the z-axis size in indices.
[in]xDimAddress to a variable to save the x dimension size in angstroms.
[in]yDimAddress to a variable to save the y dimension size in angstroms.
[in]zDimAddress to a variable to save the z dimension size in angstroms.
[in]aAngAddress to a variable to save the a angle in degrees.
[in]bAngAddress to a variable to save the b angle in degrees.
[in]cAngAddress to a variable to save the c angle in degrees.
[in]xFromAddress to a variable to save the starting index along the x-axis.
[in]yFromAddress to a variable to save the starting index along the y-axis.
[in]zFromAddress to a variable to save the starting index along the z-axis.
[in]xAxOriginAddress to a variable to save the map origin positon along the x-axis.
[in]yAxOriginAddress to a variable to save the map origin positon along the y-axis.
[in]zAxOriginAddress to a variable to save the map origin positon along the z-axis.
[in]xAxOrderAddress to a variable to save the order of x axis.
[in]yAxOrderAddress to a variable to save the order of y axis.
[in]zAxOrderAddress to a variable to save the order of z axis.
[in]xGridIndsAddress to a variable to save the grid indices count along the x-axis.
[in]yGridIndsAddress to a variable to save the grid indices count along the y-axis.
[in]zGridIndsAddress to a variable to save the grid indices count along the z-axis.

Definition at line 109 of file ProSHADE_io.cpp.

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

◆ 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]mapA gemmi Ccp4 objecct containing all the data read in from a MAP file.
[in]xDimIndsVariable holding the x-axis size in indices.
[in]yDimIndsVariable holding the y-axis size in indices.
[in]zDimIndsVariable holding the z-axis size in indices.
[in]xDimVariable holding the x dimension size in angstroms.
[in]yDimVariable holding the y dimension size in angstroms.
[in]zDimVariable holding the z dimension size in angstroms.
[in]aAngVariable holding the a angle in degrees.
[in]bAngVariable holding the b angle in degrees.
[in]cAngVariable holding the c angle in degrees.
[in]xFromVariable holding the starting index along the x-axis.
[in]yFromVariable holding the starting index along the y-axis.
[in]zFromVariable holding the starting index along the z-axis.
[in]xAxOriginVariable holding the map origin positon along the x-axis.
[in]yAxOriginVariable holding the map origin positon along the y-axis.
[in]zAxOriginVariable holding the map origin positon along the z-axis.
[in]xAxOrderVariable holding the order of x axis.
[in]yAxOrderVariable holding the order of y axis.
[in]zAxOrderVariable holding the order of z axis.
[in]xGridIndsVariable holding the grid indices count along the x-axis.
[in]yGridIndsVariable holding the grid indices count along the y-axis.
[in]zGridIndsVariable holding the grid indices count along the z-axis.
[in]titleThe title to be written into the MAP file.
[in]modeThe variable type of the data, please leave two (float) unless you require any specific other mode.

Definition at line 306 of file ProSHADE_io.cpp.

307 {
308  //================================================ Fill in the map file header
309  map->set_header_i32 ( 1 , static_cast<int32_t> ( xDimInds ) ); // Number of columns in 3D data array (fast axis)
310  map->set_header_i32 ( 2 , static_cast<int32_t> ( yDimInds ) ); // Number of columns in 3D data array (medium axis)
311  map->set_header_i32 ( 3 , static_cast<int32_t> ( zDimInds ) ); // Number of columns in 3D data array (slow axis)
312  map->set_header_i32 ( 4 , static_cast<int32_t> ( mode ) ); // Map mode
313  map->set_header_i32 ( 5 , static_cast<int32_t> ( xFrom ) ); // Starting index (fast axis)
314  map->set_header_i32 ( 6 , static_cast<int32_t> ( yFrom ) ); // Starting index (medium axis)
315  map->set_header_i32 ( 7 , static_cast<int32_t> ( zFrom ) ); // Starting index (slow axis)
316  map->set_header_i32 ( 8 , static_cast<int32_t> ( xGridInds ) ); // Grid sampling (fast axis)
317  map->set_header_i32 ( 9 , static_cast<int32_t> ( yGridInds ) ); // Grid sampling (medium axis)
318  map->set_header_i32 ( 10, static_cast<int32_t> ( zGridInds ) ); // Grid sampling (slow axis)
319  map->set_header_float ( 11, static_cast<float> ( xDim ) ); // Grid dimension in Angstrom (fast axis)
320  map->set_header_float ( 12, static_cast<float> ( yDim ) ); // Grid dimension in Angstrom (medium axis)
321  map->set_header_float ( 13, static_cast<float> ( zDim ) ); // Grid dimension in Angstrom (slow axis)
322  map->set_header_float ( 14, static_cast<float> ( aAng ) ); // Alpha angle in degrees
323  map->set_header_float ( 15, static_cast<float> ( bAng ) ); // Beta angle in degrees
324  map->set_header_float ( 16, static_cast<float> ( cAng ) ); // Gamma angle in degrees
325  map->set_header_i32 ( 17, static_cast<int32_t> ( xAxOrder ) ); // MAPC
326  map->set_header_i32 ( 18, static_cast<int32_t> ( yAxOrder ) ); // MAPR
327  map->set_header_i32 ( 19, static_cast<int32_t> ( zAxOrder ) ); // MAPS
328  if ( map->grid.spacegroup ) { map->set_header_i32 ( 23, static_cast<int32_t> ( map->grid.spacegroup->ccp4 ) ); } // Space group
329  else { map->set_header_i32 ( 23, static_cast<int32_t> ( 1 ) ); }
330  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
331  map->set_header_str ( 27, "CCP4" ); // Code for the type of extended header
332  map->set_header_i32 ( 28, static_cast<int32_t> ( 20140 ) ); // Version
333  map->set_header_i32 ( 50, static_cast<int32_t> ( xAxOrigin ) ); // Origin of the map (fast axis)
334  map->set_header_i32 ( 51, static_cast<int32_t> ( yAxOrigin ) ); // Origin of the map (medium axis)
335  map->set_header_i32 ( 52, static_cast<int32_t> ( zAxOrigin ) ); // Origin of the map (slow axis)
336  map->set_header_str ( 53, "MAP" ); // File format
337  if ( gemmi::is_little_endian() ) { map->set_header_i32 ( 54, static_cast<int32_t> ( 0x00004144 ) ); } // Machine stamp encoding byte ordering of data
338  else { map->set_header_i32 ( 54, static_cast<int32_t> ( 0x11110000 ) ); }
339  map->set_header_i32 ( 56, static_cast<int32_t> ( 1 ) ); // Number of labels used
340  std::memset ( reinterpret_cast<void*> ( &(map->ccp4_header.at( 56 )) ), ' ', static_cast< size_t > ( 800 + map->grid.spacegroup->operations().order() * 80 ) ); // 56 is used because the vector is indexed from 0
341  map->set_header_str ( 57, title ); // Title
342 
343  //================================================ Done
344  return ;
345 
346 }

◆ 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]trsX1The translation required to get the rotation centre to origin along the x-axis.
[in]trsY1The translation required to get the rotation centre to origin along the y-axis.
[in]trsZ1The translation required to get the rotation centre to origin along the z-axis.
[in]eulAThe optimal rotation Euler angle alpha.
[in]eulBThe optimal rotation Euler angle beta.
[in]eulGThe optimal rotation Euler angle gamma.
[in]trsX2The optimal translation along the x-axis + reverse of the trsX1.
[in]trsY2The optimal translation along the y-axis + reverse of the trsY1.
[in]trsZ2The optimal translation along the z-axis + reverse of the trsZ1.
[in]fileNameThe file name of the file for which the information should be written into.

Definition at line 398 of file ProSHADE_io.cpp.

399 {
400  //================================================ Open file for writing
401  std::ofstream jsonFile;
402  jsonFile.open ( fileName );
403 
404  //================================================ Check file opening success
405  if ( !jsonFile.is_open( ) )
406  {
407  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." );
408  }
409 
410  //================================================ Get rotation matrix from Euler angles
411  proshade_double* rotMat = new proshade_double[9];
412  ProSHADE_internal_misc::checkMemoryAllocation ( rotMat, __FILE__, __LINE__, __func__ );
414 
415  //================================================ Write the info
416  jsonFile << "{\n";
417  jsonFile << " \"translationToOrigin\" : [ " << trsX1 << ", " << trsY1 << ", " << trsZ1 << " ], \n";
418 
419  jsonFile << " \"rotationMatrix:\" : [ " << rotMat[0] << ", " << rotMat[1] << ", " << rotMat[2] << ", \n";
420  jsonFile << " " << rotMat[3] << ", " << rotMat[4] << ", " << rotMat[5] << ", \n";
421  jsonFile << " " << rotMat[6] << ", " << rotMat[7] << ", " << rotMat[8] << "], \n";
422 
423  jsonFile << " \"translationFromRotCenToOverlay\" : [ " << trsX2 << ", " << trsY2 << ", " << trsZ2 << " ] \n";
424  jsonFile << "}\n";
425 
426  //================================================ Close file
427  jsonFile.close ( );
428 
429  //================================================ Release memory
430  delete[] rotMat;
431 
432  //================================================ Done
433  return ;
434 
435 }
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:1011
ProSHADE_internal_io::isFileMAP
bool isFileMAP(std::string fName)
Function determining if the input data type is MAP.
Definition: ProSHADE_io.cpp:60
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