Xmipp  v3.23.11-Nereus
Functions
lib_pio.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

void read_pdb_silent (char *, unsigned *, PDB **)
 
void read_pdb (char *, unsigned *, PDB **)
 
int coord_precision (double)
 
void write_pdb (char *, unsigned, PDB *)
 
void append_pdb (char *, unsigned, PDB *)
 
void fld2s (char *, char *)
 
void fld2i (char *, unsigned, int *)
 
void get_fld (char *, unsigned, unsigned, char *)
 
void print_space (FILE *, unsigned)
 

Function Documentation

◆ append_pdb()

void append_pdb ( char *  ,
unsigned  ,
PDB *   
)

Definition at line 284 of file lib_pio.cpp.

285 {
286  unsigned i, j, k, space_count;
287  FILE *fout;
288  const char *program = "lib_pio";
289 
290 
291  fout = fopen(filename, "a");
292  if (fout == NULL) {
293  error_open_filename(12420, program, filename);
294  }
295 
296  for (i = 0; i < num_atoms; i++) {
297  space_count = 6 - strlen(out_pdb[i].recd);
298  fprintf(fout, "%s", out_pdb[i].recd);
299  print_space(fout, space_count);
300 
301  /* renumber atoms using 5 digits */
302  if (out_pdb[i].serial / 100000 == 0) {
303  fprintf(fout, "%5d", out_pdb[i].serial);
304  } else {
305  k = out_pdb[i].serial - (out_pdb[i].serial / 100000) * 100000;
306  fprintf(fout, "%05d", k);
307  }
308  print_space(fout, 1);
309 
310  space_count = 2 - strlen(out_pdb[i].type);
311  print_space(fout, space_count);
312  fprintf(fout, "%s", out_pdb[i].type);
313  space_count = 2 - strlen(out_pdb[i].loc);
314  fprintf(fout, "%s", out_pdb[i].loc);
315  print_space(fout, space_count);
316  print_space(fout, 1);
317 
318  j = strlen(out_pdb[i].res);
319  space_count = 3 - j;
320  if (j < 4) {
321  print_space(fout, space_count);
322  fprintf(fout, "%s", out_pdb[i].res);
323  print_space(fout, 1);
324  } else fprintf(fout, "%s", out_pdb[i].res);
325 
326  space_count = 1 - strlen(out_pdb[i].chain);
327  print_space(fout, space_count);
328  fprintf(fout, "%s", out_pdb[i].chain);
329  fprintf(fout, "%4d", out_pdb[i].seq);
330  space_count = 1 - strlen(out_pdb[i].icode);
331  print_space(fout, space_count);
332  fprintf(fout, "%s", out_pdb[i].icode);
333 
334  print_space(fout, 3);
335 
336  fprintf(fout, "%8.*f", coord_precision(out_pdb[i].x), out_pdb[i].x);
337  fprintf(fout, "%8.*f", coord_precision(out_pdb[i].y), out_pdb[i].y);
338  fprintf(fout, "%8.*f", coord_precision(out_pdb[i].z), out_pdb[i].z);
339  fprintf(fout, "%6.2f", out_pdb[i].occupancy);
340  fprintf(fout, "%6.2f", out_pdb[i].beta);
341 
342  print_space(fout, 1);
343 
344  fprintf(fout, "%3d", out_pdb[i].footnote);
345 
346  print_space(fout, 2);
347 
348  space_count = 4 - strlen(out_pdb[i].segid);
349  fprintf(fout, "%s", out_pdb[i].segid);
350  print_space(fout, space_count);
351 
352  space_count = 2 - strlen(out_pdb[i].element);
353  print_space(fout, space_count);
354  fprintf(fout, "%s", out_pdb[i].element);
355 
356  space_count = 2 - strlen(out_pdb[i].charge);
357  fprintf(fout, "%s", out_pdb[i].charge);
358  print_space(fout, space_count);
359 
360  fprintf(fout, "\n");
361  }
362  fclose(fout);
363  return;
364 }
print_space
void print_space(FILE *fout, unsigned space_count)
Definition: lib_pio.cpp:401
alglib::beta
double beta(const double a, const double b)
Definition: specialfunctions.cpp:962
y
static double * y
Definition: numerical_recipes.cpp:8487
x
doublereal * x
Definition: numerical_recipes.cpp:2230
i
#define i
Definition: numerical_recipes.cpp:2493
k
ql0001_ & k(htemp+1),(cvec+1),(atemp+1),(bj+1),(bl+1),(bu+1),(x+1),(clamda+1), &iout, infoqp, &zero,(w+1), &lenw,(iw+1), &leniw, &glob_grd.epsmac
error_open_filename
void error_open_filename(int error_number, const char *program, char *argv)
Definition: lib_err.cpp:67
type
viol type
Definition: numerical_recipes.cpp:5198
z
double z
Definition: numerical_recipes.cpp:8490
j
#define j
Definition: numerical_recipes.cpp:2493
fprintf
fprintf(glob_prnt.io, "\)
coord_precision
int coord_precision(double fcoord)
Definition: lib_pio.cpp:184

◆ coord_precision()

int coord_precision ( double  )

Definition at line 184 of file lib_pio.cpp.

185 {
186  if (fcoord < 9999.9995 && fcoord >= -999.9995) return 3;
187  else if (fcoord < 99999.995 && fcoord >= -9999.995) return 2;
188  else if (fcoord < 999999.95 && fcoord >= -99999.95) return 1;
189  else if (fcoord < 99999999.5 && fcoord >= -9999999.5) return 0;
190  else {
191  fprintf(stderr, "lib_pio> Error: PDB coordinate out of range, PDB output aborted.\n");
192  exit(0);
193  }
194 }
fprintf
fprintf(glob_prnt.io, "\)

◆ fld2i()

void fld2i ( char *  ,
unsigned  ,
int *   
)

Definition at line 385 of file lib_pio.cpp.

386 {
387  unsigned i;
388  for (i = 0; i < n; i++) {
389  if (field[i] != ' ') {
390  sscanf(field, "%d", num);
391  return;
392  }
393  }
394  if (i == n) {
395  *num = 0;
396  return;
397  }
398 }
i
#define i
Definition: numerical_recipes.cpp:2493
n
int * n
Definition: numerical_recipes.cpp:2229

◆ fld2s()

void fld2s ( char *  ,
char *   
)

Definition at line 377 of file lib_pio.cpp.

378 {
379  if (sscanf(field, "%s", str) < 1) {
380  str[0] = '\0';
381  }
382 }

◆ get_fld()

void get_fld ( char *  ,
unsigned  ,
unsigned  ,
char *   
)

Definition at line 367 of file lib_pio.cpp.

368 {
369  unsigned i;
370  for (i = i1; i <= i2; i++) {
371  field[i - i1] = line[i - 1];
372  }
373  field[i - i1] = '\0';
374 }
i
#define i
Definition: numerical_recipes.cpp:2493

◆ print_space()

void print_space ( FILE *  ,
unsigned   
)

Definition at line 401 of file lib_pio.cpp.

402 {
403  unsigned j;
404  for (j = 0; j < space_count; j++)
405  fprintf(fout, " ");
406 }
j
#define j
Definition: numerical_recipes.cpp:2493
fprintf
fprintf(glob_prnt.io, "\)

◆ read_pdb()

void read_pdb ( char *  ,
unsigned *  ,
PDB **   
)

Definition at line 175 of file lib_pio.cpp.

176 {
177 
178  read_pdb_silent(file_name, num_atoms, in_pdb);
179  printf("lib_pio> %d atoms read from file %s.\n", *num_atoms, file_name);
180  return;
181 }
read_pdb_silent
void read_pdb_silent(char *file_name, unsigned *num_atoms, PDB **in_pdb)
Definition: lib_pio.cpp:24

◆ read_pdb_silent()

void read_pdb_silent ( char *  ,
unsigned *  ,
PDB **   
)

Definition at line 24 of file lib_pio.cpp.

25 {
26  PDB *new_pdb;
27  FILE *fin;
28  char line[101];
29  char field00[7], field01[6], field02[2], field03[3], field04[3],
30  field05[2], field06[5], field08[2], field09[5],
31  field10[2], field11[4], field12[9], field13[9], field14[9],
32  field15[7], field16[7], field17[2], field18[4], field19[3],
33  field20[5], field21[3], field22[3];
34  char recd_name[7]; /* 1 - 6 */
35  const char *element_name[] = {
36  "H", "HE", "LI", "BE", "B", "C", "N", "O", "F", "NE",
37  "NA", "MG", "AL", "SI", "P", "S", "CL", "AR", "K", "CA",
38  "SC", "TI", "V", "CR", "MN", "FE", "CO", "NI", "CU", "ZN"
39  };
40  float element_mass[30] = {
41  1.008f , 4.003f, 6.940f, 9.012f, 10.810f, 12.011f, 14.007f, 16.000f, 18.998f, 20.179f,
42  22.990f, 24.305f, 26.982f, 28.086f, 30.974f, 32.060f, 35.453f, 39.948f, 39.098f, 40.080f,
43  44.956f, 47.880f, 50.942f, 51.996f, 54.938f, 55.847f, 58.933f, 58.710f, 63.546f, 65.380f
44  };
45  int frequent_element[5] = {5, 6, 7, 14, 15};
46  unsigned i, j, k, line_width, atom_count;
47  const char *program = "lib_pio";
48 
49  fin = fopen(file_name, "r");
50  if (fin == NULL) {
51  error_open_filename(12110, program, file_name);
52  }
53 
54  /* count number of atom records */
55  atom_count = 0;
56  for (;;) {
57  if (line != fgets(line, 100, fin)) error_fgets(program);
58  if (feof(fin)) break;
59  if (sscanf(line, "%6s", recd_name) != 1) continue;
60  if (strcmp(recd_name, "ATOM") == 0 || strcmp(recd_name, "HETATM") == 0 || strcmp(recd_name, "LABEL") == 0) atom_count++;
61  }
62  rewind(fin);
63 
64  /* allocate memory */
65  new_pdb = (PDB *) alloc_vect(atom_count, sizeof(PDB));
66  /* now read fields */
67  i = 0;
68  for (;;) {
69  if (line != fgets(line, 100, fin)) error_fgets(program);
70  if (feof(fin)) break;
71  if (sscanf(line, "%6s", recd_name) != 1) continue;
72  if (strcmp(recd_name, "ATOM") == 0 || strcmp(recd_name, "HETATM") == 0 || strcmp(recd_name, "LABEL") == 0) {
73  line_width = 80;
74  for (j = 0; j < 80; j++) {
75  if (line[j] == '\n') {
76  line_width = j;
77  break;
78  }
79  }
80  for (j = line_width; j < 80; j++) {
81  line[j] = ' ';
82  }
83  get_fld(line, 1, 6, field00);
84  fld2s(field00, new_pdb[i].recd);
85  get_fld(line, 7, 11, field01);
86  fld2i(field01, 5, &(new_pdb[i].serial));
87  get_fld(line, 12, 12, field02);
88  get_fld(line, 13, 14, field03);
89  fld2s(field03, new_pdb[i].type);
90  get_fld(line, 15, 16, field04);
91  fld2s(field04, new_pdb[i].loc);
92  get_fld(line, 17, 17, field05);
93  fld2s(field05, new_pdb[i].alt);
94  get_fld(line, 18, 21, field06);
95  fld2s(field06, new_pdb[i].res);
96  get_fld(line, 22, 22, field08);
97  fld2s(field08, new_pdb[i].chain);
98  get_fld(line, 23, 26, field09);
99  fld2i(field09, 4, &(new_pdb[i].seq));
100  get_fld(line, 27, 27, field10);
101  fld2s(field10, new_pdb[i].icode);
102  get_fld(line, 28, 30, field11);
103  get_fld(line, 31, 38, field12);
104  new_pdb[i].x = (float) atof(field12);
105  get_fld(line, 39, 46, field13);
106  new_pdb[i].y = (float) atof(field13);
107  get_fld(line, 47, 54, field14);
108  new_pdb[i].z = (float) atof(field14);
109  get_fld(line, 55, 60, field15);
110  new_pdb[i].occupancy = (float) atof(field15);
111  get_fld(line, 61, 66, field16);
112  new_pdb[i].beta = (float) atof(field16);
113  get_fld(line, 67, 67, field17);
114  get_fld(line, 68, 70, field18);
115  fld2i(field18, 3, &(new_pdb[i].footnote));
116  get_fld(line, 71, 72, field19);
117  get_fld(line, 73, 76, field20);
118  fld2s(field20, new_pdb[i].segid);
119  get_fld(line, 77, 78, field21);
120  fld2s(field21, new_pdb[i].element);
121  get_fld(line, 79, 80, field22);
122  fld2s(field22, new_pdb[i].charge);
123 
124  /* check if codebook vector, assign zero mass */
125  if ((strcmp(new_pdb[i].type, "QV") == 0 && strcmp(new_pdb[i].loc, "OL") == 0) || (strcmp(new_pdb[i].type, "QP") == 0 && strcmp(new_pdb[i].loc, "DB") == 0)) {
126  new_pdb[i].weight = 0;
127  }
128  /* check if map density, assign mass from occupancy field */
129  else if (strcmp(new_pdb[i].type, "DE") == 0 && strcmp(new_pdb[i].loc, "NS") == 0) {
130  new_pdb[i].weight = new_pdb[i].occupancy;
131  }
132  /* looks like we have a standard atom */
133  else { /* check if found in element table */
134  for (j = 1; j < 30; ++j) {
135  /* check if hydrogen */
136  if (new_pdb[i].type[0] == 'H' || (new_pdb[i].type[0] == ' ' && new_pdb[i].type[1] == 'H')) {
137  new_pdb[i].weight = element_mass[0];
138  break;
139  } /* note: above false hydrogen positives possible for Hg, Hf, Ho (these are very rare in proteins) */
140  else if (strcmp(new_pdb[i].type, element_name[j]) == 0) {
141  new_pdb[i].weight = element_mass[j];
142  break;
143  }
144  }
145  /* if this fails, use first letter only of most frequent elements */
146  k = 0;
147  if (j == 30) for (k = 0; k < 5; ++k) {
148  if (strncmp(new_pdb[i].type, element_name[frequent_element[k]], 1) == 0) {
149  new_pdb[i].weight = element_mass[frequent_element[k]];
150  break;
151  }
152  }
153  /* if this fails again, assign carbon mass and print warning */
154  if (k == 6) {
155  printf("lib_pio> Warning: Unable to identify atom type %s, assigning carbon mass.\n", new_pdb[i].type);
156  new_pdb[i].weight = element_mass[5];
157  }
158  }
159  ++i;
160  }
161  }
162  fclose(fin);
163 
164  if (i != atom_count) {
165  error_atom_count(12210, program, i, atom_count);
166  }
167 
168  *num_atoms = atom_count;
169  *in_pdb = new_pdb;
170  return;
171 }
PDB::y
float y
Definition: situs.h:47
PDB::z
float z
Definition: situs.h:48
fld2s
void fld2s(char *field, char *str)
Definition: lib_pio.cpp:377
PDB::weight
float weight
Definition: situs.h:52
error_fgets
void error_fgets(const char *program)
Definition: lib_err.cpp:42
PDB
Definition: situs.h:43
get_fld
void get_fld(char *line, unsigned i1, unsigned i2, char *field)
Definition: lib_pio.cpp:367
i
#define i
Definition: numerical_recipes.cpp:2493
k
ql0001_ & k(htemp+1),(cvec+1),(atemp+1),(bj+1),(bl+1),(bu+1),(x+1),(clamda+1), &iout, infoqp, &zero,(w+1), &lenw,(iw+1), &leniw, &glob_grd.epsmac
fld2i
void fld2i(char *field, unsigned n, int *num)
Definition: lib_pio.cpp:385
error_open_filename
void error_open_filename(int error_number, const char *program, char *argv)
Definition: lib_err.cpp:67
type
viol type
Definition: numerical_recipes.cpp:5198
error_atom_count
void error_atom_count(int error_number, const char *program, int i, int atom_count)
Definition: lib_err.cpp:253
PDB::occupancy
float occupancy
Definition: situs.h:49
PDB::x
float x
Definition: situs.h:46
j
#define j
Definition: numerical_recipes.cpp:2493
alloc_vect
void * alloc_vect(unsigned int n, size_t elem_size)
Definition: lib_vec.cpp:71
PDB::beta
float beta
Definition: situs.h:50

◆ write_pdb()

void write_pdb ( char *  ,
unsigned  ,
PDB *   
)

Definition at line 197 of file lib_pio.cpp.

198 {
199  unsigned i, j, k, space_count;
200  FILE *fout;
201  const char *program = "lib_pio";
202 
203  fout = fopen(filename, "w");
204  if (fout == NULL) {
205  error_open_filename(12320, program, filename);
206  }
207 
208  for (i = 0; i < num_atoms; i++) {
209  space_count = 6 - strlen(out_pdb[i].recd);
210  fprintf(fout, "%s", out_pdb[i].recd);
211  print_space(fout, space_count);
212 
213  /* renumber atoms using 5 digits, ignore out_pdb[i].serial */
214  if ((i + 1) / 100000 == 0) {
215  k = i + 1;
216  fprintf(fout, "%5d", k);
217  } else {
218  k = i + 1 - ((i + 1) / 100000) * 100000;
219  fprintf(fout, "%05d", k);
220  }
221  print_space(fout, 1);
222 
223  space_count = 2 - strlen(out_pdb[i].type);
224  print_space(fout, space_count);
225  fprintf(fout, "%s", out_pdb[i].type);
226 
227  space_count = 2 - strlen(out_pdb[i].loc);
228  fprintf(fout, "%s", out_pdb[i].loc);
229  print_space(fout, space_count);
230 
231  print_space(fout, 1);
232 
233  j = strlen(out_pdb[i].res);
234  space_count = 3 - j;
235  if (j < 4) {
236  print_space(fout, space_count);
237  fprintf(fout, "%s", out_pdb[i].res);
238  print_space(fout, 1);
239  } else fprintf(fout, "%s", out_pdb[i].res);
240 
241  space_count = 1 - strlen(out_pdb[i].chain);
242  print_space(fout, space_count);
243  fprintf(fout, "%s", out_pdb[i].chain);
244 
245  fprintf(fout, "%4d", out_pdb[i].seq);
246 
247  space_count = 1 - strlen(out_pdb[i].icode);
248  print_space(fout, space_count);
249  fprintf(fout, "%s", out_pdb[i].icode);
250 
251  print_space(fout, 3);
252 
253  fprintf(fout, "%8.*f", coord_precision(out_pdb[i].x), out_pdb[i].x);
254  fprintf(fout, "%8.*f", coord_precision(out_pdb[i].y), out_pdb[i].y);
255  fprintf(fout, "%8.*f", coord_precision(out_pdb[i].z), out_pdb[i].z);
256  fprintf(fout, "%6.2f", out_pdb[i].occupancy);
257  fprintf(fout, "%6.2f", out_pdb[i].beta);
258 
259  print_space(fout, 1);
260 
261  fprintf(fout, "%3d", out_pdb[i].footnote);
262 
263  print_space(fout, 2);
264 
265  space_count = 4 - strlen(out_pdb[i].segid);
266  fprintf(fout, "%s", out_pdb[i].segid);
267  print_space(fout, space_count);
268 
269  space_count = 2 - strlen(out_pdb[i].element);
270  print_space(fout, space_count);
271  fprintf(fout, "%s", out_pdb[i].element);
272 
273  space_count = 2 - strlen(out_pdb[i].charge);
274  fprintf(fout, "%s", out_pdb[i].charge);
275  print_space(fout, space_count);
276 
277  fprintf(fout, "\n");
278  }
279  fclose(fout);
280  return;
281 }
print_space
void print_space(FILE *fout, unsigned space_count)
Definition: lib_pio.cpp:401
alglib::beta
double beta(const double a, const double b)
Definition: specialfunctions.cpp:962
y
static double * y
Definition: numerical_recipes.cpp:8487
x
doublereal * x
Definition: numerical_recipes.cpp:2230
i
#define i
Definition: numerical_recipes.cpp:2493
k
ql0001_ & k(htemp+1),(cvec+1),(atemp+1),(bj+1),(bl+1),(bu+1),(x+1),(clamda+1), &iout, infoqp, &zero,(w+1), &lenw,(iw+1), &leniw, &glob_grd.epsmac
error_open_filename
void error_open_filename(int error_number, const char *program, char *argv)
Definition: lib_err.cpp:67
type
viol type
Definition: numerical_recipes.cpp:5198
z
double z
Definition: numerical_recipes.cpp:8490
j
#define j
Definition: numerical_recipes.cpp:2493
fprintf
fprintf(glob_prnt.io, "\)
coord_precision
int coord_precision(double fcoord)
Definition: lib_pio.cpp:184
Generated by   doxygen 1.8.13