pdb.h File Reference

#include <vector>
#include "cif++.hpp"
#include "core/xmipp_error.h"

Include dependency graph for pdb.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	Matrix1D< T >
class	Matrix2D< T >
class	MultidimArray< T >
struct	pdbInfo
class	Atom
class	PDBPhantom
class	RichAtom
class	PDBRichPhantom
class	AtomInterpolator

Functions
int	atomCharge (const std::string &atom)
double	atomRadius (const std::string &atom)
double	atomCovalentRadius (const std::string &atom)
void	computePDBgeometry (const std::string &fnPDB, Matrix1D< double > &centerOfMass, Matrix1D< double > &limit0, Matrix1D< double > &limitF, const std::string &intensityColumn)
void	applyGeometryToPDBFile (const std::string &fn_in, const std::string &fn_out, const Matrix2D< double > &A, bool centerPDB=true, const std::string &intensityColumn="occupancy")
void	analyzePDBAtoms (const FileName &fn_pdb, const std::string &typeOfAtom, int &numberOfAtoms, pdbInfo &at_pos)
void	atomDescriptors (const std::string &atom, Matrix1D< double > &descriptors)
double	electronFormFactorFourier (double f, const Matrix1D< double > &descriptors)
double	electronFormFactorRealSpace (double r, const Matrix1D< double > &descriptors)
void	atomRadialProfile (int M, double T, const std::string &atom, Matrix1D< double > &profile)
void	atomProjectionRadialProfile (int M, const Matrix1D< double > &profileCoefficients, Matrix1D< double > &projectionProfile)
void	projectPDB (const PDBPhantom &phantomPDB, const AtomInterpolator &interpolator, Projection &proj, int Ydim, int Xdim, double rot, double tilt, double psi)
void	distanceHistogramPDB (const PDBPhantom &phantomPDB, size_t Nnearest, double maxDistance, int Nbins, Histogram1D &hist)
const char *	hy36encode (unsigned width, int value, char *result)
const char *	hy36decode (unsigned width, const char *s, unsigned s_size, int *result)
void	hy36encodeSafe (unsigned width, int value, char *result)
void	hy36decodeSafe (unsigned width, const char *s, unsigned s_size, int *result)

Function Documentation

hy36decode()

const char* hy36decode	(	unsigned	width,
		const char *	s,
		unsigned	s_size,
		int *	result
	)

hybrid-36 decoder: converts string s to integer result width: must be 4 (e.g. for residue sequence numbers) or 5 (e.g. for atom serial numbers) s: string to be converted does not have to be null-terminated s_size: size of s must be equal to width, or an error message is returned otherwise result: integer holding the conversion result return value: pointer to error message, if any, or 0 on success Example usage (from C++): int result; const char* errmsg = hy36decode(width, "A1T5", 4, &result); if (errmsg) throw std::runtime_error(errmsg);

Definition at line 1892 of file pdb.cpp.

{
  static int first_call = 1;
  static int digits_values_upper[128U];
  static int digits_values_lower[128U];
  static const char*
    ie_range = "internal error hy36decode: integer value out of range.";
  unsigned i;
  int di;
  const char* errmsg;
  if (first_call) {
    first_call = 0;
    for(i=0;i<128U;i++) digits_values_upper[i] = -1;
    for(i=0;i<128U;i++) digits_values_lower[i] = -1;
    for(i=0;i<36U;i++) {
      di = digits_upper()[i];
      if (di < 0 || di > 127) {
        *result = 0;
        return ie_range;
      }
      digits_values_upper[di] = i;
    }
    for(i=0;i<36U;i++) {
      di = digits_lower()[i];
      if (di < 0 || di > 127) {
        *result = 0;
        return ie_range;
      }
      digits_values_lower[di] = i;
    }
  }
  if (s_size == width) {
    di = s[0];
    if (di >= 0 && di <= 127) {
      if (digits_values_upper[di] >= 10) {
        errmsg = decode_pure(digits_values_upper, 36U, s, s_size, result);
        if (errmsg == 0) {
          /* result - 10*36**(width-1) + 10**width */
          if      (width == 4U) (*result) -= 456560;
          else if (width == 5U) (*result) -= 16696160;
          else {
            *result = 0;
            return unsupported_width();
          }
          return 0;
        }
      }
      else if (digits_values_lower[di] >= 10) {
        errmsg = decode_pure(digits_values_lower, 36U, s, s_size, result);
        if (errmsg == 0) {
          /* result + 16*36**(width-1) + 10**width */
          if      (width == 4U) (*result) += 756496;
          else if (width == 5U) (*result) += 26973856;
          else {
            *result = 0;
            return unsupported_width();
          }
          return 0;
        }
      }
      else {
        errmsg = decode_pure(digits_values_upper, 10U, s, s_size, result);
        if (errmsg) return errmsg;
        if (!(width == 4U || width == 5U)) {
          *result = 0;
          return unsupported_width();
        }
        return 0;
      }
    }
  }
  *result = 0;
  return invalid_number_literal();
}

hy36decodeSafe()

void hy36decodeSafe	(	unsigned	width,
		const char *	s,
		unsigned	s_size,
		int *	result
	)

Definition at line 1968 of file pdb.cpp.

{
    auto* errmsg = hy36decode(width, s, s_size, result); 
    if (errmsg) {
        REPORT_ERROR(ERR_VALUE_INCORRECT, errmsg);
    }
}

hy36encode()

const char* hy36encode	(	unsigned	width,
		int	value,
		char *	result
	)

hybrid-36 encoder: converts integer value to string result width: must be 4 (e.g. for residue sequence numbers) or 5 (e.g. for atom serial numbers) value: integer value to be converted result: pointer to char array of size width+1 or greater on return result is null-terminated return value: pointer to error message, if any, or 0 on success Example usage (from C++): char result[4+1]; const char* errmsg = hy36encode(4, 12345, result); if (errmsg) throw std::runtime_error(errmsg);

Definition at line 1824 of file pdb.cpp.

{
  int i = value;
  if (width == 4U) {
    if (i >= -999) {
      if (i < 10000) {
        encode_pure(digits_upper(), 10U, 4U, i, result);
        return 0;
      }
      i -= 10000;
      if (i < 1213056 /* 26*36**3 */) {
        i += 466560 /* 10*36**3 */;
        encode_pure(digits_upper(), 36U, 0U, i, result);
        return 0;
      }
      i -= 1213056;
      if (i < 1213056) {
        i += 466560;
        encode_pure(digits_lower(), 36U, 0U, i, result);
        return 0;
      }
    }
  }
  else if (width == 5U) {
    if (i >= -9999) {
      if (i < 100000) {
        encode_pure(digits_upper(), 10U, 5U, i, result);
        return 0;
      }
      i -= 100000;
      if (i < 43670016 /* 26*36**4 */) {
        i += 16796160 /* 10*36**4 */;
        encode_pure(digits_upper(), 36U, 0U, i, result);
        return 0;
      }
      i -= 43670016;
      if (i < 43670016) {
        i += 16796160;
        encode_pure(digits_lower(), 36U, 0U, i, result);
        return 0;
      }
    }
  }
  else {
    fill_with_stars(width, result);
    return unsupported_width();
  }
  fill_with_stars(width, result);
  return value_out_of_range();
}

hy36encodeSafe()

void hy36encodeSafe	(	unsigned	width,
		int	value,
		char *	result
	)

Definition at line 1977 of file pdb.cpp.

{
    const char* errmsg = hy36encode(width, value, result); 
    if (errmsg) {
        REPORT_ERROR(ERR_VALUE_INCORRECT, errmsg);
    }
}