| Bsoft 2.0.5 Bernard's software package

rwmol_star.cpp
Go to the documentation of this file.
1
9 #include "rwstar.h"
10 #include "rwmolecule.h"
11 #include "rwmol_star.h"
12 #include "mol_tags.h"
13 #include "linked_list.h"
14 #include "utilities.h"
15
16 // Declaration of global variables
17 extern int verbose; // Level of output to the screen
18
25 long read_mol_star(Bstring& filename, Bmolgroup *molgroup)
26 {
27 if ( verbose & VERB_DEBUG )
28 cout << "DEBUG read_mol_star: filename=" << filename << endl;
29
30 long i, n, nmol(0), natom(0), resnum;
31 Bstring molname("A");
32
33 Bstar* star = init_star();
34 Bstar_block* block;
35 Bstar_item* item;
36 Bstring** data = new Bstring*[100];
37
38 read_star(&filename, star);
39
40 // Find the number of molecules
41 nmol = item_get_number(star, MOLECULE_NAME);
42 if ( nmol < 1 && item_get_number(star, ATOM_NUMBER) > 0 ) nmol = 1;
43
44 if ( verbose & VERB_DEBUG )
45 cout << "DEBUG read_mol_star: Number of molecules: " << nmol << endl;
46
47 if ( nmol < 1 ) {
48 kill_star(star);
49 cerr << "Error: Star to molecule conversion unsuccessful!" << endl;
50 return -1;
51 }
52
53 // Allocate memory for the atomic data and convert data
54 Bmolecule* mol = NULL;
55 Bresidue* res = NULL;
56 Batom* atom = NULL;
57
58 Bstring resname;
59
60 // Find the molecules in every block
61 nmol = 0;
62 for ( block = star->block; block; block = block->next ) {
63 if ( ( item = item_find(block, MOLECULE_NAME) ) )
64 molname = *(item->data);
65 else if ( block->tag.length() )
66 molname = block->tag;
67 mol = molecule_add(&molgroup->mol, molname);
68 if ( verbose & VERB_DEBUG )
69 cout << "DEBUG read_mol_star: Molecule " << mol->id << endl;
70 mol->seq = item_get_string(block, MOLECULE_SEQUENCE);
71 if ( verbose & VERB_DEBUG )
72 cout << "DEBUG read_mol_star: sequence " << mol->seq << endl;
73 mol->nres = item_get_integer(block, MOLECULE_LENGTH);
74 if ( mol->seq.length() > 0 )
75 if ( mol->nres < 1 ) mol->nres = mol->seq.length();
76 // natom = item_get_number_for_block(block, ATOM_NUMBER);
77 natom = item_get_number_for_block(block, ATOM_PDB);
78 if ( verbose & VERB_DEBUG )
79 cout << "DEBUG read_mol_star: natom=" << natom << endl;
80 if ( natom > 0 ) {
81 res = NULL;
82 atom = NULL;
83 item = item_find(block, ATOM_PDB);
84 if ( item ) data[0] = item->data;
85 item = item_find(block, ATOM_RESNUMBER);
86 if ( item ) data[1] = item->data;
87 item = item_find(block, ATOM_RESINSERT);
88 if ( item ) data[2] = item->data;
89 item = item_find(block, ATOM_RESIDUE);
90 if ( item ) data[3] = item->data;
91 item = item_find(block, ATOM_NUMBER);
92 if ( item ) data[4] = item->data;
93 item = item_find(block, ATOM_SYMBOL);
94 if ( item ) data[5] = item->data;
95 item = item_find(block, ATOM_TOPTYPE);
96 if ( item ) data[6] = item->data;
97 item = item_find(block, ATOM_X);
98 if ( item ) data[7] = item->data;
99 item = item_find(block, ATOM_Y);
100 if ( item ) data[8] = item->data;
101 item = item_find(block, ATOM_Z);
102 if ( item ) data[9] = item->data;
103 item = item_find(block, ATOM_OCCUPANCY);
104 if ( item ) data[10] = item->data;
105 item = item_find(block, ATOM_BFACTOR);
106 if ( item ) data[11] = item->data;
107 item = item_find(block, ATOM_CHARGE);
108 if ( item ) data[12] = item->data;
109 n = 13;
110 while ( data[0] ) {
111 resnum = data[1]->integer();
112 if ( !res || res->num != resnum || resname != *data[3] ) {
113 res = (Bresidue *) add_item((char **) &res, sizeof(Bresidue));
114 if ( !mol->res ) mol->res = res;
115 res->num = resnum;
116 atom = NULL;
117 if ( data[2] ) {
118 res->insert[0] = data[2][0][0];
119 if ( !res->insert[0] || res->insert[0] == '?' ) res->insert[0] = ' ';
120 }
121 if ( data[3] ) {
122 strncpy(res->type, data[3]->c_str(), 6);
123 resname = *data[3];
124 }
125 }
126 atom = (Batom *) add_item((char **) &atom, sizeof(Batom));
127 if ( !res->atom ) res->atom = atom;
128 if ( data[4] ) atom->num = data[4]->integer();
129 if ( data[5] ) strncpy(atom->el, data[5]->c_str(), 2);
130 if ( data[6] ) atom_clean_type(atom, data[6]->c_str());
131 if ( data[7] ) atom->coord[0] = data[7]->real();
132 if ( data[8] ) atom->coord[1] = data[8]->real();
133 if ( data[9] ) atom->coord[2] = data[9]->real();
134 atom->q = 1;
135 if ( data[10] ) atom->q = data[10]->real();
136 if ( data[11] ) atom->b = data[11]->real();
137 if ( data[12] ) atom->chrg = data[12]->real();
138 atom->mass = 1;
139 atom->sel = 1;
140 for ( i=0; i<n; ++i ) if ( data[i] ) data[i] = data[i]->next;
141 }
142 /* if ( item )
143 for ( data=item->data; data; data=data->next ) {
144 resnum = data->integer();
145 cout << resnum << endl;
146 if ( !res || res->num != resnum ) {
147 res = (Bresidue *) add_item((char **) &res, sizeof(Bresidue));
148 if ( !mol->res ) mol->res = res;
149 res->num = resnum;
150 atom = NULL;
151 }
152 atom = (Batom *) add_item((char **) &atom, sizeof(Batom));
153 if ( !res->atom ) res->atom = atom;
154 atom->q = 1;
155 atom->mass = 1;
156 atom->sel = 1;
157 }
158 item = item_find(block, ATOM_RESINSERT);
159 if ( item )
160 for ( data=item->data, res=mol->res; data && res; res=res->next )
161 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next ) {
162 res->insert[0] = data[0][0];
163 if ( !res->insert[0] || res->insert[0] == '?' ) res->insert[0] = ' ';
164 }
165 item = item_find(block, ATOM_RESIDUE);
166 if ( item )
167 for ( data=item->data, res=mol->res; data && res; res=res->next )
168 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
169 strncpy(res->type, data->c_str(), 6);
170 item = item_find(block, ATOM_NUMBER);
171 if ( item )
172 for ( data=item->data, res=mol->res; data && res; res=res->next )
173 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
174 atom->num = data->integer();
175 item = item_find(block, ATOM_SYMBOL);
176 if ( item )
177 for ( data=item->data, res=mol->res; data && res; res=res->next )
178 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
179 strncpy(atom->el, data->c_str(), 2);
180 item = item_find(block, ATOM_TOPTYPE);
181 if ( item )
182 for ( data=item->data, res=mol->res; data && res; res=res->next )
183 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
184 atom_clean_type(atom, data->c_str());
185 item = item_find(block, ATOM_X);
186 if ( item )
187 for ( data=item->data, res=mol->res; data && res; res=res->next )
188 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
189 atom->coord[0] = data->real();
190 item = item_find(block, ATOM_Y);
191 if ( item )
192 for ( data=item->data, res=mol->res; data && res; res=res->next )
193 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
194 atom->coord[1] = data->real();
195 item = item_find(block, ATOM_Z);
196 if ( item )
197 for ( data=item->data, res=mol->res; data && res; res=res->next )
198 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
199 atom->coord[2] = data->real();
200 item = item_find(block, ATOM_OCCUPANCY);
201 if ( item )
202 for ( data=item->data, res=mol->res; data && res; res=res->next )
203 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
204 atom->q = data->real();
205 item = item_find(block, ATOM_BFACTOR);
206 if ( item )
207 for ( data=item->data, res=mol->res; data && res; res=res->next )
208 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
209 atom->b = data->real();
210 item = item_find(block, ATOM_CHARGE);
211 if ( item )
212 for ( data=item->data, res=mol->res; data && res; res=res->next )
213 for ( atom=res->atom; data && atom; data=data->next, atom=atom->next )
214 atom->chrg = data->real();*/
215 }
216 nmol++;
217 molname[0]++;
218 if ( molname[0] > 'Z' ) molname[0] = 'A';
219 }
220
221 delete[] data;
222
223 if ( nmol < 1 ) nmol--;
224
225 if ( verbose & VERB_DEBUG )
226 cout << "DEBUG read_mol_star: Conversion done for " << nmol << " molecules" << endl;
227
228 kill_star(star);
229
230 return nmol;
231 }
232
233 int item_put_atom_list(Bstar_block* block, const char* tag, Bresidue* res, const char* format)
234 {
235 if ( !block ) return -1;
236
237 char string[32] = "", c;
238
239 Bstar_item* item = item_find_or_make(block, tag);
240 Bstring* data = NULL;
241
242 item->type = NumberItem;
243 item->loop = -1;
244
245 if ( strcmp(tag, ATOM_TOPTYPE) == 0 || strcmp(tag, ATOM_RESIDUE) == 0 ||
246 strcmp(tag, ATOM_RESINSERT) == 0 )
247 item->type = StringItem;
248
249 Batom* atom = NULL;
250
251 for ( ; res; res=res->next )
252 for ( atom=res->atom; atom; atom=atom->next ) {
253 if ( strcmp(tag, ATOM_NUMBER) == 0 )
254 snprintf(string, 32, format, atom->num);
255 else if ( strcmp(tag, ATOM_SYMBOL) == 0 )
256 snprintf(string, 32, format, atom->el);
257 else if ( strcmp(tag, ATOM_TOPTYPE) == 0 )
258 snprintf(string, 32, format, atom->type);
259 else if ( strcmp(tag, ATOM_RESIDUE) == 0 )
260 snprintf(string, 32, format, res->type);
261 else if ( strcmp(tag, ATOM_RESNUMBER) == 0 )
262 snprintf(string, 32, format, res->num);
263 else if ( strcmp(tag, ATOM_RESINSERT) == 0 ) {
264 c = res->insert[0];
265 if ( !c || c==' ' ) c = '?';
266 snprintf(string, 32, format, c);
267 } else if ( strcmp(tag, ATOM_X) == 0 )
268 snprintf(string, 32, format, atom->coord[0]);
269 else if ( strcmp(tag, ATOM_Y) == 0 )
270 snprintf(string, 32, format, atom->coord[1]);
271 else if ( strcmp(tag, ATOM_Z) == 0 )
272 snprintf(string, 32, format, atom->coord[2]);
273 else if ( strcmp(tag, ATOM_OCCUPANCY) == 0 )
274 snprintf(string, 32, format, atom->q);
275 else if ( strcmp(tag, ATOM_BFACTOR) == 0 )
276 snprintf(string, 32, format, atom->b);
277 else if ( strcmp(tag, ATOM_CHARGE) == 0 )
278 snprintf(string, 32, format, atom->chrg);
279 data = string_add(&data, string);
280 if ( !item->data ) item->data = data;
281 if ( item->maxlen < strlen(string) ) item->maxlen = strlen(string);
282 }
283
284 if ( verbose & VERB_DEBUG_STAR )
285 cout << "DEBUG item_put_atom_list: " << tag << "=" << *(item->data) << endl;
286
287 return 0;
288 }
289
290 int item_put_chain(Bstar_block* block, const char* tag, Bresidue* res, char chain)
291 {
292 if ( !block ) return -1;
293
294 char string[32] = "";
295 string[0] = chain;
296
297 Bstar_item* item = item_find_or_make(block, tag);
298 Bstring* data = NULL;
299
300 item->type = StringItem;
301 item->loop = -1;
302
303 Batom* atom = NULL;
304
305 for ( ; res; res=res->next )
306 for ( atom=res->atom; atom; atom=atom->next ) {
307 data = string_add(&data, string);
308 if ( !item->data ) item->data = data;
309 if ( item->maxlen < strlen(string) ) item->maxlen = strlen(string);
310 }
311
312 if ( verbose & VERB_DEBUG_STAR )
313 cout << "DEBUG item_put_chain: " << tag << "=" << *(item->data) << endl;
314
315 return 0;
316 }
317
324 long write_mol_star(Bstring& filename, Bmolgroup *molgroup)
325 {
326 if ( verbose & VERB_DEBUG )
327 cout << "DEBUG write_mol_star: filename=" << filename << endl;
328
329 Bstar* star = init_star();
330 Bstar_block* block = NULL;
331 star->comment = molgroup->comment;
332 star->line_length = 120;
333
334 long natom(0), nmol(0), loop;
335
336 // Convert the atomic data
337 Bmolecule* mol;
338 Bresidue* res;
339 Batom* atom;
340
341 for ( mol = molgroup->mol; mol; mol = mol->next ) {
342 block = (Bstar_block *) add_item((char **)&block, sizeof(Bstar_block));
343 if ( !star->block ) star->block = block;
344 block->tag = mol->id;
345 item_put_string(block, MOLECULE_NAME, mol->id);
346 if ( verbose & VERB_DEBUG )
347 cout << "DEBUG write_mol_star: sequence " << mol->seq << endl;
348 if ( ( mol->nbase > 0 ) && mol->naseq.length() ) {
349 item_put_integer(block, MOLECULE_LENGTH, mol->nbase, "%8d");
350 item_put_string(block, MOLECULE_SEQUENCE, mol->naseq);
351 }
352 if ( ( mol->nres > 0 ) && mol->seq.length() ) {
353 item_put_integer(block, MOLECULE_LENGTH, mol->nres, "%8d");
354 item_put_string(block, MOLECULE_SEQUENCE, mol->seq);
355 }
356 natom = 0;
357 for ( res = mol->res; res; res = res->next )
358 for ( atom = res->atom; atom; atom = atom->next ) natom++;
359 if ( natom ) {
360 item_put_atom_list(block, ATOM_NUMBER, mol->res, "%6d");
361 item_put_atom_list(block, ATOM_SYMBOL, mol->res, "%s");
362 item_put_atom_list(block, ATOM_TOPTYPE, mol->res, "%s");
363 item_put_atom_list(block, ATOM_RESIDUE, mol->res, "%s");
364 item_put_atom_list(block, ATOM_RESNUMBER, mol->res, "%6d");
365 item_put_atom_list(block, ATOM_RESINSERT, mol->res, "%c");
366 item_put_chain(block, ATOM_CHAIN, mol->res, mol->id[0]);
367 item_put_atom_list(block, ATOM_X, mol->res, "%7.3f");
368 item_put_atom_list(block, ATOM_Y, mol->res, "%7.3f");
369 item_put_atom_list(block, ATOM_Z, mol->res, "%7.3f");
370 item_put_atom_list(block, ATOM_OCCUPANCY, mol->res, "%7.3f");
371 item_put_atom_list(block, ATOM_BFACTOR, mol->res, "%7.2f");
372 item_put_atom_list(block, ATOM_CHARGE, mol->res, "%7.3f");
373 loop = item_index(block, ATOM_NUMBER);
374 loop_set_identifier(block, loop, 1, "atom_site");
375 }
376 nmol++;
377 }
378
379 write_star(filename, star);
380
381 kill_star(star);
382
383 return nmol;
384 }
ATOM_X
#define ATOM_X
Definition: mol_tags.h:68
atom_clean_type
int atom_clean_type(Batom *atom, const char *type)
Cleans up the type string and assigns an element code to an atom.
Definition: rwmolecule.cpp:229
Bstar_item::data
Bstring * data
Definition: rwstar.h:43
read_star
int read_star(const char *filename, Bstar *star)
Reads paramaters and data into a STAR data base from a list of files.
Definition: rwstar.cpp:224
Bmolecule::id
Bstring id
Definition: rwmolecule.h:110
Bmolgroup::mol
Bmolecule * mol
Definition: rwmolecule.h:189
Bstring::real
double real()
Definition: Bstring.cpp:545
string_add
Bstring * string_add(Bstring **list, const char *string)
Adds a string to a linked list.
Definition: Bstring.cpp:705
Bstar_block::next
Bstar_block * next
Definition: rwstar.h:56
StringItem
Definition: rwstar.h:25
Bstar_item::loop
int loop
Definition: rwstar.h:40
Bmolecule::nres
long nres
Definition: rwmolecule.h:111
ATOM_SYMBOL
#define ATOM_SYMBOL
Definition: mol_tags.h:63
utilities.h
Header file for general utilities.
VERB_DEBUG
#define VERB_DEBUG
Definition: utilities.h:112
Bmolecule::res
Bresidue * res
Definition: rwmolecule.h:122
item_get_string
char * item_get_string(Bstar_block *block, const char *tag)
Gets a string value associated with a tag in a STAR data block.
Definition: rwstar.cpp:1189
ATOM_RESNUMBER
#define ATOM_RESNUMBER
Definition: mol_tags.h:58
rwmol_star.h
Read and write molecules in STAR format.
write_star
int write_star(const char *filename, Bstar *star)
Writes a STAR data base to one or more STAR format files.
Definition: rwstar.cpp:666
init_star
Bstar * init_star()
Creates a STAR data base.
Definition: rwstar.cpp:111
Bresidue::insert
char insert[2]
Definition: rwmolecule.h:52
item_put_chain
int item_put_chain(Bstar_block *block, const char *tag, Bresidue *res, char chain)
Definition: rwmol_star.cpp:290
Bstar_item::type
StarType type
Definition: rwstar.h:39
add_item
char * add_item(char **list, unsigned long size)
Adds an item to a linked list.
Definition: linked_list.cpp:26
Bstring::length
long length() const
Definition: Bstring.cpp:263
Bstar
Definition: rwstar.h:78
MOLECULE_SEQUENCE
#define MOLECULE_SEQUENCE
Definition: mol_tags.h:109
kill_star
int kill_star(Bstar *star)
Destroys a STAR data base.
Definition: rwstar.cpp:132
Bresidue::type
char type[6]
Definition: rwmolecule.h:53
ATOM_RESINSERT
#define ATOM_RESINSERT
Definition: mol_tags.h:59
item_put_atom_list
int item_put_atom_list(Bstar_block *block, const char *tag, Bresidue *res, const char *format)
Definition: rwmol_star.cpp:233
ATOM_CHARGE
#define ATOM_CHARGE
Definition: mol_tags.h:76
Batom::q
double q
Definition: rwmolecule.h:31
Batom::sel
int sel
Definition: rwmolecule.h:34
read_mol_star
long read_mol_star(Bstring &filename, Bmolgroup *molgroup)
Reads a molecule group from a STAR format file.
Definition: rwmol_star.cpp:25
Batom::type
char type[8]
Definition: rwmolecule.h:28
NumberItem
Definition: rwstar.h:26
Batom::num
int num
Definition: rwmolecule.h:26
Bstar_item::maxlen
int maxlen
Definition: rwstar.h:41
write_mol_star
long write_mol_star(Bstring &filename, Bmolgroup *molgroup)
Writes a molecule group to a STAR format file.
Definition: rwmol_star.cpp:324
mol_tags.h
All STAR file format tags for molecules and molecular parameters.
Bmolecule::seq
Bstring seq
Definition: rwmolecule.h:114
linked_list.h
Header file for generalized linked list functions.
rwmolecule.h
Header file for reading reflection files.
MOLECULE_NAME
#define MOLECULE_NAME
Definition: mol_tags.h:107
Bstar::line_length
int line_length
Definition: rwstar.h:80
Bmolgroup
Definition: rwmolecule.h:170
Bmolecule::nbase
long nbase
Definition: rwmolecule.h:112
ATOM_CHAIN
#define ATOM_CHAIN
Definition: mol_tags.h:66
Bstring::next
Bstring * next
Definition: Bstring.h:31
item_put_string
int item_put_string(Bstar_block *block, const char *tag, char *string)
Writes a string into a data item associated with a specific data block and tag in a STAR data base.
Definition: rwstar.cpp:1300
Bstar_block
Definition: rwstar.h:55
Bmolgroup::comment
Bstring comment
Definition: rwmolecule.h:175
Bmolecule::next
Bmolecule * next
Definition: rwmolecule.h:108
molecule_add
Bmolecule * molecule_add(Bmolecule **mol, char *name)
Adds a molecule to a linked list.
Definition: rwmolecule.cpp:76
item_get_number
long item_get_number(Bstar *star, const char *tag)
Gets the number of values associated with a tag in a STAR data base.
Definition: rwstar.cpp:1134
item_find_or_make
Bstar_item * item_find_or_make(Bstar_block *block, const char *tag)
Gets the STAR item associated with a tag in a STAR data block.
Definition: rwstar.cpp:1105
Bmolecule::naseq
Bstring naseq
Definition: rwmolecule.h:115
ATOM_NUMBER
#define ATOM_NUMBER
Definition: mol_tags.h:60
Batom::b
double b
Definition: rwmolecule.h:31
verbose
int verbose
item_put_integer
int item_put_integer(Bstar_block *block, const char *tag, int value, const char *format)
Writes a integer into a data item associated with a specific data block and tag in a STAR data base.
Definition: rwstar.cpp:1368
MOLECULE_LENGTH
#define MOLECULE_LENGTH
Definition: mol_tags.h:108
Bresidue::atom
Batom * atom
Definition: rwmolecule.h:54
Bstring::c_str
const char * c_str()
Definition: Bstring.h:70
Bmolecule
Definition: rwmolecule.h:107
ATOM_Y
#define ATOM_Y
Definition: mol_tags.h:69
Bresidue::next
Bresidue * next
Definition: rwmolecule.h:50
Bresidue
Definition: rwmolecule.h:49
Bstar_block::tag
Bstring tag
Definition: rwstar.h:58
Bstring
Definition: Bstring.h:29
ATOM_TOPTYPE
#define ATOM_TOPTYPE
Definition: mol_tags.h:64
ATOM_PDB
#define ATOM_PDB
Definition: mol_tags.h:57
Bstar::comment
Bstring comment
Definition: rwstar.h:81
Batom
Definition: rwmolecule.h:24
rwstar.h
A header file for STAR format files.
loop_set_identifier
int loop_set_identifier(Bstar_block *block, int loop, int n,...)
Assigns a loop identification number to items.
Definition: rwstar.cpp:1803
item_index
int item_index(Bstar_block *block, const char *tag)
Gets the STAR item associated with a tag in a STAR data block.
Definition: rwstar.cpp:1029
Bresidue::num
int num
Definition: rwmolecule.h:51
ATOM_Z
#define ATOM_Z
Definition: mol_tags.h:70
Bstar::block
Bstar_block * block
Definition: rwstar.h:82
Batom::coord
Vector3< double > coord
Definition: rwmolecule.h:30
Bstring::integer
long integer()
Definition: Bstring.cpp:539
Batom::el
char el[4]
Definition: rwmolecule.h:27
VERB_DEBUG_STAR
#define VERB_DEBUG_STAR
Definition: utilities.h:113
ATOM_RESIDUE
#define ATOM_RESIDUE
Definition: mol_tags.h:65
item_get_integer
int item_get_integer(Bstar_block *block, const char *tag)
Gets an integer value associated with a tag in a STAR data block.
Definition: rwstar.cpp:1245
Batom::chrg
double chrg
Definition: rwmolecule.h:33
ATOM_BFACTOR
#define ATOM_BFACTOR
Definition: mol_tags.h:75
Batom::next
Batom * next
Definition: rwmolecule.h:25
Batom::mass
double mass
Definition: rwmolecule.h:32
item_get_number_for_block
long item_get_number_for_block(Bstar_block *block, const char *tag)
Gets the number of values associated with a tag in a STAR data block.
Definition: rwstar.cpp:1163
item_find
Bstar_item * item_find(Bstar_block *block, const char *tag)
Gets the STAR item associated with a tag in a STAR data block.
Definition: rwstar.cpp:1083
Bstar_item
Definition: rwstar.h:36
ATOM_OCCUPANCY
#define ATOM_OCCUPANCY
Definition: mol_tags.h:74