struct atomgrp *copy_atomgrp(const struct atomgrp *srcag)
{
int atomn;
struct atomgrp *destag =
(struct atomgrp *)_mol_calloc(1, sizeof(struct atomgrp));
destag->natoms = srcag->natoms;
destag->atoms =
(struct atom *)_mol_calloc(destag->natoms, sizeof(struct atom));
for (atomn = 0; atomn < destag->natoms; atomn++) {
copy_atom(&(srcag->atoms[atomn]), &(destag->atoms[atomn]));
}
return destag;
}
struct atomgrp* join_atomgrps (struct atomgrp** ags)
{
struct atomgrp* ag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
ag->natoms = 100; // just a guess, realloc as necessary
ag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * ag->natoms);
int agai = 0; // ag atom index
int agi = 0; // index into ags
while (ags[agi] != NULL)
{
int agsai; // ags atom index
for (agsai = 0; agsai < ags[agi]->natoms; agsai++, agai++)
{
if (agai+1 > ag->natoms)
{
ag->natoms *= 2;
ag->atoms = (struct atom*) _mol_realloc (ag->atoms, sizeof (struct atom) * ag->natoms);
}
copy_atom (&ags[agi]->atoms[agsai], &ag->atoms[agai]);
}
agi++;
}
// final realloc of the arrays to make them tight
ag->natoms = agai;
ag->atoms = (struct atom*) _mol_realloc (ag->atoms, sizeof (struct atom) * ag->natoms);
return ag;
}
struct atomgrp* copy_atomgrp (struct atomgrp* srcag)
{
struct atomgrp* destag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
destag->natoms = srcag->natoms;
destag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * destag->natoms);
int atomn;
for (atomn = 0; atomn < destag->natoms; atomn++)
{
copy_atom (&srcag->atoms[atomn], &destag->atoms[atomn]);
}
return destag;
}
struct atomgrp *around(int nlist, int *list, struct atomgrp* ag, double distup)
{
int i, j;
int natoms=ag->natoms;
double x1,y1,z1,x2,y2,z2,d2;
double du2=distup*distup;
int *tmplist;
int nout;
struct atomgrp *destag;
if(natoms==0)
{
fprintf (stderr,
"around> ERROR: no atoms initially");
exit (EXIT_FAILURE);
}
tmplist=_mol_malloc(natoms*sizeof(int));
for(i=0; i<natoms; i++)tmplist[i]=1;
for(i=0; i<nlist; i++)tmplist[list[i]]=0;
nout=0;
for(i=0; i<nlist; i++)
{
x1=ag->atoms[list[i]].X;
y1=ag->atoms[list[i]].Y;
z1=ag->atoms[list[i]].Z;
for(j=0; j<natoms; j++)
{
if(tmplist[j]!=1)continue;
x2=ag->atoms[j].X-x1;
y2=ag->atoms[j].Y-y1;
z2=ag->atoms[j].Z-z1;
d2=x2*x2+y2*y2+z2*z2;
if(d2<=du2)
{
tmplist[j]=2;
nout++;
}
}
}
destag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
destag->natoms = nout;
destag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * destag->natoms);
j=0;
for (i = 0; i < natoms; i++)
{
if(tmplist[i]==2)copy_atom (&ag->atoms[i], &destag->atoms[j++]);
}
free(tmplist);
return destag;
}
struct atomgrp* exrm_type (struct atomgrp* ag, const char* type, struct prm* prm, int direction)
{
int atomn; // loop var
int natoms; // type atom number
struct atomgrp* exag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp)); // resultant extracted atomgrp
exag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * ag->natoms); // allocate memory for the array of atoms, realloc later to make it tight
natoms = 0;
for (atomn = 0; atomn < ag->natoms; atomn++)
{
if (
(direction == 0 && strcmp (type, prm->atoms[ag->atoms[atomn].atom_typen].typemin) == 0) // extract type
||
(direction == 1 && ! (strcmp (type, prm->atoms[ag->atoms[atomn].atom_typen].typemin) == 0)) // rm type
)
{
exag->atoms[natoms].atom_typen = ag->atoms[atomn].atom_typen;
exag->atoms[natoms].sa = ag->atoms[atomn].sa;
exag->atoms[natoms].X = ag->atoms[atomn].X;
exag->atoms[natoms].Y = ag->atoms[atomn].Y;
exag->atoms[natoms].Z = ag->atoms[atomn].Z;
/*
exag->atoms[natoms].bonds[0] = ag->atoms[atomn].bonds[0];
exag->atoms[natoms].bonds[1] = ag->atoms[atomn].bonds[1];
exag->atoms[natoms].bonds[2] = ag->atoms[atomn].bonds[2];
exag->atoms[natoms].bonds[3] = ag->atoms[atomn].bonds[3];
*/
natoms++;
}
}
if (natoms == 0)
{
if (direction == 0)
{
fprintf (stderr, "there are no atoms of type %s to extract\n", type);
}
if (direction == 1)
{
fprintf (stderr, "removing atoms of type %s leaves no remaining atoms\n", type);
}
exit (EXIT_FAILURE);
}
exag->atoms = (struct atom*) _mol_realloc (exag->atoms, sizeof (struct atom) * natoms); // realloc exag->atoms to make it tight
exag->natoms = natoms; // attach number of atoms
return exag;
}
void read_ff_json(const char *json_file, struct atomgrp *ag)
{
json_error_t json_file_error;
json_t *base = json_load_file(json_file, 0, &json_file_error);
if (!base) {
fprintf(stderr,
"error reading json file %s on line %d column %d: %s\n",
json_file, json_file_error.line, json_file_error.column,
json_file_error.text);
}
if (!json_is_object(base)) {
fprintf(stderr, "json file not an object %s\n", json_file);
}
json_t *atoms, *bonds, *angles, *torsions, *impropers;
atoms = json_object_get(base, "atoms");
if (!json_is_array(atoms)) {
fprintf(stderr, "json atoms are not an array %s\n", json_file);
}
size_t natoms = json_array_size(atoms);
if (natoms != (size_t) ag->natoms) {
fprintf(stderr,
"json file has a different number of atoms %zd vs. %d : %s\n",
natoms, ag->natoms, json_file);
}
ag->num_atom_types = 0;
for (size_t i = 0; i < natoms; i++) {
json_t *atom = json_array_get(atoms, i);
if (!json_is_object(atom)) {
fprintf(stderr,
"Atom %zd not an object in json file %s\n", i,
json_file);
}
json_t *ace_volume, *ftype_index, *ftype_name, *eps03;
json_t *name, *radius03, *eps;
json_t *charge, *radius, *element;
ace_volume = json_object_get(atom, "ace_volume");
if (!json_is_real(ace_volume)) {
fprintf(stderr,
"json ace volume is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].acevolume = json_real_value(ace_volume);
ftype_index = json_object_get(atom, "ftype_index");
if (!json_is_integer(ftype_index)) {
fprintf(stderr,
"json ftype index is not integer for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].atom_ftypen = json_integer_value(ftype_index);
if (ag->atoms[i].atom_ftypen > ag->num_atom_types) {
ag->num_atom_types = ag->atoms[i].atom_ftypen;
}
ftype_name = json_object_get(atom, "ftype_name");
if (!json_is_string(ftype_name)) {
fprintf(stderr,
"json ftype name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].ftype_name = strdup(json_string_value(ftype_name));
element = json_object_get(atom, "element");
if (!json_is_string(element)) {
fprintf(stderr,
"json element name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].element = strdup(json_string_value(element));
eps = json_object_get(atom, "eps");
if (!json_is_real(eps)) {
fprintf(stderr,
"json eps is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps = sqrt(-json_real_value(eps));
eps03 = json_object_get(atom, "eps03");
if (!json_is_real(eps03)) {
fprintf(stderr,
"json eps03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps03 = sqrt(-json_real_value(eps03));
radius = json_object_get(atom, "radius");
if (!json_is_real(radius)) {
fprintf(stderr,
"json radius is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh = json_real_value(radius);
radius03 = json_object_get(atom, "radius03");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json radius03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh03 = json_real_value(radius03);
charge = json_object_get(atom, "charge");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json charge is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].chrg = json_real_value(charge);
name = json_object_get(atom, "name");
if (!json_is_string(name)) {
fprintf(stderr,
"json name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].name = strdup(json_string_value(name));
ag->atoms[i].nbonds = 0;
ag->atoms[i].nangs = 0;
ag->atoms[i].ntors = 0;
ag->atoms[i].nimps = 0;
ag->atoms[i].fixed = 0;
}
bonds = json_object_get(base, "bonds");
if (!json_is_array(bonds)) {
fprintf(stderr, "json bonds are not an array %s\n", json_file);
}
size_t nbonds = json_array_size(bonds);
ag->nbonds = nbonds;
ag->bonds = _mol_calloc(nbonds, sizeof(struct atombond));
for (size_t i = 0; i < nbonds; i++) {
json_t *bond = json_array_get(bonds, i);
if (!json_is_object(bond)) {
fprintf(stderr,
"Bond %zd not an object in json file %s\n", i,
json_file);
}
json_t *length, *atom1, *atom2, *spring_constant, *sdf_type;
atom1 = json_object_get(bond, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->bonds[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nbonds)++;
atom2 = json_object_get(bond, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->bonds[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nbonds)++;
length = json_object_get(bond, "length");
if (!json_is_real(length)) {
fprintf(stderr,
"json length is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].l0 = json_real_value(length);
spring_constant = json_object_get(bond, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].k = json_real_value(spring_constant);
sdf_type = json_object_get(bond, "sdf_type");
if (!json_is_integer(sdf_type)) {
fprintf(stderr,
"json sdf_type is not integer for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].sdf_type = json_integer_value(sdf_type);
}
angles = json_object_get(base, "angles");
if (!json_is_array(angles)) {
fprintf(stderr, "json angles are not an array %s\n", json_file);
}
size_t nangles = json_array_size(angles);
ag->nangs = nangles;
ag->angs = _mol_calloc(nangles, sizeof(struct atomangle));
for (size_t i = 0; i < nangles; i++) {
json_t *angle = json_array_get(angles, i);
if (!json_is_object(angle)) {
fprintf(stderr,
"Angle %zd not an object in json file %s\n", i,
json_file);
}
json_t *theta, *atom1, *atom2, *atom3, *spring_constant;
atom1 = json_object_get(angle, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->angs[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nangs)++;
atom2 = json_object_get(angle, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->angs[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nangs)++;
atom3 = json_object_get(angle, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->angs[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nangs)++;
theta = json_object_get(angle, "theta");
if (!json_is_real(theta)) {
fprintf(stderr,
"json theta is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].th0 = json_real_value(theta);
spring_constant = json_object_get(angle, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].k = json_real_value(spring_constant);
}
torsions = json_object_get(base, "torsions");
if (!json_is_array(torsions)) {
fprintf(stderr, "json torsions are not an array %s\n",
json_file);
}
size_t ntorsions = json_array_size(torsions);
ag->ntors = ntorsions;
ag->tors = _mol_calloc(ntorsions, sizeof(struct atomtorsion));
for (size_t i = 0; i < ntorsions; i++) {
json_t *torsion = json_array_get(torsions, i);
if (!json_is_object(torsion)) {
fprintf(stderr,
"Torsion %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *minima, *delta_constant,
*spring_constant;
atom1 = json_object_get(torsion, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->tors[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].ntors)++;
atom2 = json_object_get(torsion, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->tors[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].ntors)++;
atom3 = json_object_get(torsion, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->tors[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].ntors)++;
atom4 = json_object_get(torsion, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->tors[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].ntors)++;
minima = json_object_get(torsion, "minima");
if (!json_is_integer(minima)) {
fprintf(stderr,
"json minima is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].n = json_integer_value(minima);
delta_constant = json_object_get(torsion, "delta_constant");
if (!json_is_real(delta_constant)) {
fprintf(stderr,
"json delta_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].d = json_real_value(delta_constant);
spring_constant = json_object_get(torsion, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].k = json_real_value(spring_constant);
}
impropers = json_object_get(base, "impropers");
if (!json_is_array(impropers)) {
fprintf(stderr, "json impropers are not an array %s\n",
json_file);
}
size_t nimpropers = json_array_size(impropers);
ag->nimps = nimpropers;
ag->imps = _mol_calloc(nimpropers, sizeof(struct atomimproper));
for (size_t i = 0; i < nimpropers; i++) {
json_t *improper = json_array_get(impropers, i);
if (!json_is_object(improper)) {
fprintf(stderr,
"Improper %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *phi, *spring_constant;
atom1 = json_object_get(improper, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->imps[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nimps)++;
atom2 = json_object_get(improper, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->imps[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nimps)++;
atom3 = json_object_get(improper, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->imps[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nimps)++;
atom4 = json_object_get(improper, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->imps[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].nimps)++;
phi = json_object_get(improper, "phi");
if (!json_is_real(phi)) {
fprintf(stderr,
"json phi is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].psi0 = json_real_value(phi);
spring_constant = json_object_get(improper, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].k = json_real_value(spring_constant);
}
json_decref(base);
//allocate atom arrays of pointers to parameters
for (size_t i = 0; i < natoms; i++) {
int i1 = ag->atoms[i].nbonds;
ag->atoms[i].bonds = _mol_calloc(i1, sizeof(struct atombond *));
ag->atoms[i].nbonds = 0;
i1 = ag->atoms[i].nangs;
ag->atoms[i].angs = _mol_calloc(i1, sizeof(struct atomangle *));
ag->atoms[i].nangs = 0;
i1 = ag->atoms[i].ntors;
ag->atoms[i].tors =
_mol_calloc(i1, sizeof(struct atomtorsion *));
ag->atoms[i].ntors = 0;
i1 = ag->atoms[i].nimps;
ag->atoms[i].imps =
_mol_calloc(i1, sizeof(struct atomimproper *));
ag->atoms[i].nimps = 0;
}
struct atom *atm;
//fill bonds
for (int i = 0; i < ag->nbonds; i++) {
atm = ag->bonds[i].a0;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
atm = ag->bonds[i].a1;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
}
//fill angles
for (int i = 0; i < ag->nangs; i++) {
atm = ag->angs[i].a0;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a1;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a2;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
}
//fill torsions
for (int i = 0; i < ag->ntors; i++) {
atm = ag->tors[i].a0;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a1;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a2;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a3;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
}
//fill impropers
for (int i = 0; i < ag->nimps; i++) {
atm = ag->imps[i].a0;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a1;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a2;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a3;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
}
//atom indices in the group
fill_ingrp(ag);
ag->is_psf_read = true;
// copy vals from deprecated to new data structures
int atomsi;
for (atomsi = 0; atomsi < ag->natoms; atomsi++) {
_mol_atom_create_bond_indices(&ag->atoms[atomsi],
ag->atoms[atomsi].nbonds);
}
_mol_atom_group_copy_from_deprecated(ag);
}
struct atomgrp *read_json_ag(const char *json_file)
{
struct atomgrp *ag =
(struct atomgrp *)_mol_calloc(1, sizeof(struct atomgrp));
json_error_t json_file_error;
json_t *base = json_load_file(json_file, 0, &json_file_error);
if (!base) {
fprintf(stderr,
"error reading json file %s on line %d column %d: %s\n",
json_file, json_file_error.line, json_file_error.column,
json_file_error.text);
}
if (!json_is_object(base)) {
fprintf(stderr, "json file not an object %s\n", json_file);
}
json_t *atoms, *bonds, *angles, *torsions, *impropers;
atoms = json_object_get(base, "atoms");
if (!json_is_array(atoms)) {
fprintf(stderr, "json atoms are not an array %s\n", json_file);
}
size_t natoms = json_array_size(atoms);
ag->natoms = natoms;
ag->atoms = (struct atom *)_mol_calloc(ag->natoms, sizeof(struct atom));
ag->num_atom_types = 0;
char *prev_segment = _mol_calloc(1, sizeof(char));
char *prev_residue = _mol_calloc(1, sizeof(char));
int prev_residue_seq = -107;
ag->nres = 0;
int alloc_res = 250;
ag->iares = _mol_malloc(alloc_res*sizeof(int));
for (size_t i = 0; i < natoms; i++) {
json_t *atom = json_array_get(atoms, i);
if (!json_is_object(atom)) {
fprintf(stderr,
"Atom %zd not an object in json file %s\n", i,
json_file);
}
json_t *ace_volume, *ftype_index, *ftype_name, *eps03;
json_t *name, *radius03, *eps, *acp_type, *residue_name;
json_t *charge, *radius, *element;
json_t *x, *y, *z;
json_t *yeti_type, *sybyl_type;
json_t *backbone, *hb_acceptor, *hb_donor, *hb_weight;
json_t *segment, *residue;
segment = json_object_get(atom, "segment");
residue = json_object_get(atom, "residue");
if ((segment != NULL) && (residue != NULL)) {
if (!json_is_string(segment)) {
fprintf(stderr,
"json segment is not string for atom %zd in json_file %s\n",
i, json_file);
}
if (!json_is_string(residue)) {
fprintf(stderr,
"json residue is not string for atom %zd in json_file %s\n",
i, json_file);
}
const char *cur_segment = json_string_value(segment);
const char *cur_residue = json_string_value(residue);
if (strcmp(cur_segment, prev_segment) != 0) {
prev_residue_seq += 100;
free(prev_segment);
prev_segment = strdup(cur_segment);
}
if (strcmp(cur_residue, prev_residue) != 0) {
int cur_residue_int = atoi(cur_residue);
int prev_residue_int = atoi(prev_residue);
if ((cur_residue_int - prev_residue_int) > 1) {
prev_residue_seq +=
(cur_residue_int -
prev_residue_int);
} else {
prev_residue_seq += 1;
}
free(prev_residue);
prev_residue = strdup(cur_residue);
if (ag->nres +1 == alloc_res) {
alloc_res *= 2;
ag->iares = _mol_realloc(ag->iares, alloc_res * i);
}
ag->iares[ag->nres] = i;
ag->nres++;
}
ag->atoms[i].comb_res_seq = prev_residue_seq;
} else {
ag->atoms[i].comb_res_seq = prev_residue_seq;
}
ace_volume = json_object_get(atom, "ace_volume");
if (!json_is_real(ace_volume)) {
fprintf(stderr,
"json ace volume is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].acevolume = json_real_value(ace_volume);
ftype_index = json_object_get(atom, "ftype_index");
if (!json_is_integer(ftype_index)) {
fprintf(stderr,
"json ftype index is not integer for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].atom_ftypen = json_integer_value(ftype_index);
if (ag->atoms[i].atom_ftypen > ag->num_atom_types) {
ag->num_atom_types = ag->atoms[i].atom_ftypen;
}
ftype_name = json_object_get(atom, "ftype_name");
if (!json_is_string(ftype_name)) {
fprintf(stderr,
"json ftype name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].ftype_name = strdup(json_string_value(ftype_name));
element = json_object_get(atom, "element");
if (!json_is_string(element)) {
fprintf(stderr,
"json element name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].element = strdup(json_string_value(element));
eps = json_object_get(atom, "eps");
if (!json_is_real(eps)) {
fprintf(stderr,
"json eps is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps = sqrt(-json_real_value(eps));
eps03 = json_object_get(atom, "eps03");
if (!json_is_real(eps03)) {
fprintf(stderr,
"json eps03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].eps03 = sqrt(-json_real_value(eps03));
radius = json_object_get(atom, "radius");
if (!json_is_real(radius)) {
fprintf(stderr,
"json radius is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh = json_real_value(radius);
radius03 = json_object_get(atom, "radius03");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json radius03 is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].rminh03 = json_real_value(radius03);
charge = json_object_get(atom, "charge");
if (!json_is_real(radius03)) {
fprintf(stderr,
"json charge is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].chrg = json_real_value(charge);
name = json_object_get(atom, "name");
if (!json_is_string(name)) {
fprintf(stderr,
"json name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].name = strdup(json_string_value(name));
residue_name = json_object_get(atom, "residue_name");
if (residue_name != NULL) {
if (!json_is_string(residue_name)) {
fprintf(stderr,
"json residue_name is not string for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].residue_name =
strdup(json_string_value(residue_name));
} else {
ag->atoms[i].residue_name = NULL;
}
x = json_object_get(atom, "x");
if (!json_is_real(x)) {
fprintf(stderr,
"json coordinate x is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].X = json_real_value(x);
y = json_object_get(atom, "y");
if (!json_is_real(y)) {
fprintf(stderr,
"json coordinate y is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].Y = json_real_value(y);
z = json_object_get(atom, "z");
if (!json_is_real(z)) {
fprintf(stderr,
"json coordinate z is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].Z = json_real_value(z);
acp_type = json_object_get(atom, "acp_type");
if (acp_type != NULL) {
if (!json_is_integer(acp_type)) {
fprintf(stderr,
"json acp_type index is not integer for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].acp_type = json_integer_value(acp_type);
} else {
ag->atoms[i].acp_type = -1;
}
yeti_type = json_object_get(atom, "yeti_type");
if (yeti_type != NULL) {
const char *yeti_type_string;
if (!json_is_string(yeti_type)) {
fprintf(stderr,
"json yeti_type is not string for atom %zd in json_file %s\n",
i, json_file);
}
yeti_type_string = json_string_value(yeti_type);
if (strcmp("carbonyl", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_CARBONYL;
} else if (strcmp("hydroxyl", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_HYDROXYL;
} else if (strcmp("sulfonamide", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_SULFONAMIDE;
} else if (strcmp("N5_aromatic", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_N5_AROMATIC;
} else if (strcmp("N6_aromatic", yeti_type_string) == 0) {
ag->atoms[i].yeti_type = MOL_YETI_N6_AROMATIC;
} else {
fprintf(stderr,
"unknown json yeti_type %s for atom %zd in json_file %s\n",
yeti_type_string, i, json_file);
ag->atoms[i].yeti_type = MOL_YETI_NONE;
}
} else {
ag->atoms[i].yeti_type = MOL_YETI_NONE;
}
sybyl_type = json_object_get(atom, "sybyl_type");
if (sybyl_type != NULL) {
const char *sybyl_type_string;
if (!json_is_string(sybyl_type)) {
fprintf(stderr,
"json sybyl_type is not string for atom %zd in json_file %s\n",
i, json_file);
}
sybyl_type_string = json_string_value(sybyl_type);
ag->atoms[i].hybridization =
mol_hydridization_from_sybyl(sybyl_type_string);
} else {
ag->atoms[i].hybridization = UNKNOWN_HYBRID;
}
backbone = json_object_get(atom, "backbone");
if (backbone != NULL) {
if (!json_is_boolean(backbone)) {
fprintf(stderr,
"json backbone is not boolean for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].backbone = json_is_true(backbone);
} else {
ag->atoms[i].backbone = false;
}
ag->atoms[i].hprop = 0;
hb_acceptor = json_object_get(atom, "hb_acceptor");
if (hb_acceptor != NULL) {
if (!json_is_boolean(hb_acceptor)) {
fprintf(stderr,
"json hb_acceptor is not boolean for atom %zd in json_file %s\n",
i, json_file);
}
if (json_is_true(hb_acceptor)) {
ag->atoms[i].hprop |= HBOND_ACCEPTOR;
}
}
hb_donor = json_object_get(atom, "hb_donor");
if (hb_donor != NULL) {
if (!json_is_boolean(hb_donor)) {
fprintf(stderr,
"json hb_donor is not boolean for atom %zd in json_file %s\n",
i, json_file);
}
if (json_is_true(hb_donor)) {
ag->atoms[i].hprop |= DONATABLE_HYDROGEN;
}
}
ag->atoms[i].hbond_weight = 1.0;
hb_weight = json_object_get(atom, "hb_weight");
if (hb_weight != NULL) {
if (!json_is_real(hb_weight)) {
fprintf(stderr,
"json hb_weight is not floating point for atom %zd in json_file %s\n",
i, json_file);
}
ag->atoms[i].hbond_weight = json_real_value(hb_weight);
}
ag->atoms[i].nbonds = 0;
ag->atoms[i].nangs = 0;
ag->atoms[i].ntors = 0;
ag->atoms[i].nimps = 0;
ag->atoms[i].fixed = 0;
ag->atoms[i].sa = -1;
ag->atoms[i].base = -1;
ag->atoms[i].base2 = -1;
}
ag->iares[ag->nres] = ag->natoms;
ag->iares = _mol_realloc(ag->iares, (ag->nres+1) * sizeof(int));
free(prev_segment);
free(prev_residue);
bonds = json_object_get(base, "bonds");
if (!json_is_array(bonds)) {
fprintf(stderr, "json bonds are not an array %s\n", json_file);
}
size_t nbonds = json_array_size(bonds);
ag->nbonds = nbonds;
ag->bonds = _mol_calloc(nbonds, sizeof(struct atombond));
for (size_t i = 0; i < nbonds; i++) {
json_t *bond = json_array_get(bonds, i);
if (!json_is_object(bond)) {
fprintf(stderr,
"Bond %zd not an object in json file %s\n", i,
json_file);
}
json_t *length, *atom1, *atom2, *spring_constant, *sdf_type;
atom1 = json_object_get(bond, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->bonds[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nbonds)++;
atom2 = json_object_get(bond, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for bond %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->bonds[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nbonds)++;
length = json_object_get(bond, "length");
if (!json_is_real(length)) {
fprintf(stderr,
"json length is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].l0 = json_real_value(length);
spring_constant = json_object_get(bond, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].k = json_real_value(spring_constant);
sdf_type = json_object_get(bond, "sdf_type");
if (sdf_type != NULL) {
if (!json_is_integer(sdf_type)) {
fprintf(stderr,
"json sdf_type is not integer for bond %zd in json_file %s\n",
i, json_file);
}
ag->bonds[i].sdf_type = json_integer_value(sdf_type);
} else {
ag->bonds[i].sdf_type = 0;
}
}
angles = json_object_get(base, "angles");
if (!json_is_array(angles)) {
fprintf(stderr, "json angles are not an array %s\n", json_file);
}
size_t nangles = json_array_size(angles);
ag->nangs = nangles;
ag->angs = _mol_calloc(nangles, sizeof(struct atomangle));
for (size_t i = 0; i < nangles; i++) {
json_t *angle = json_array_get(angles, i);
if (!json_is_object(angle)) {
fprintf(stderr,
"Angle %zd not an object in json file %s\n", i,
json_file);
}
json_t *theta, *atom1, *atom2, *atom3, *spring_constant;
atom1 = json_object_get(angle, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->angs[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nangs)++;
atom2 = json_object_get(angle, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->angs[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nangs)++;
atom3 = json_object_get(angle, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for angle %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->angs[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nangs)++;
theta = json_object_get(angle, "theta");
if (!json_is_real(theta)) {
fprintf(stderr,
"json theta is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].th0 = json_real_value(theta);
spring_constant = json_object_get(angle, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for angle %zd in json_file %s\n",
i, json_file);
}
ag->angs[i].k = json_real_value(spring_constant);
}
torsions = json_object_get(base, "torsions");
if (!json_is_array(torsions)) {
fprintf(stderr, "json torsions are not an array %s\n",
json_file);
}
size_t ntorsions = json_array_size(torsions);
ag->ntors = ntorsions;
ag->tors = _mol_calloc(ntorsions, sizeof(struct atomtorsion));
for (size_t i = 0; i < ntorsions; i++) {
json_t *torsion = json_array_get(torsions, i);
if (!json_is_object(torsion)) {
fprintf(stderr,
"Torsion %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *minima, *delta_constant,
*spring_constant;
atom1 = json_object_get(torsion, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->tors[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].ntors)++;
atom2 = json_object_get(torsion, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->tors[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].ntors)++;
atom3 = json_object_get(torsion, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->tors[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].ntors)++;
atom4 = json_object_get(torsion, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->tors[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].ntors)++;
minima = json_object_get(torsion, "minima");
if (!json_is_integer(minima)) {
fprintf(stderr,
"json minima is not integer for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].n = json_integer_value(minima);
delta_constant = json_object_get(torsion, "delta_constant");
if (!json_is_real(delta_constant)) {
fprintf(stderr,
"json delta_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].d = json_real_value(delta_constant);
spring_constant = json_object_get(torsion, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for torsion %zd in json_file %s\n",
i, json_file);
}
ag->tors[i].k = json_real_value(spring_constant);
}
impropers = json_object_get(base, "impropers");
if (!json_is_array(impropers)) {
fprintf(stderr, "json impropers are not an array %s\n",
json_file);
}
size_t nimpropers = json_array_size(impropers);
ag->nimps = nimpropers;
ag->imps = _mol_calloc(nimpropers, sizeof(struct atomimproper));
for (size_t i = 0; i < nimpropers; i++) {
json_t *improper = json_array_get(impropers, i);
if (!json_is_object(improper)) {
fprintf(stderr,
"Improper %zd not an object in json file %s\n",
i, json_file);
}
json_t *atom1, *atom2, *atom3, *atom4, *phi, *spring_constant;
atom1 = json_object_get(improper, "atom1");
if (!json_is_integer(atom1)) {
fprintf(stderr,
"json atom1 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i1 = json_integer_value(atom1) - 1;
ag->imps[i].a0 = &(ag->atoms[i1]);
(ag->atoms[i1].nimps)++;
atom2 = json_object_get(improper, "atom2");
if (!json_is_integer(atom2)) {
fprintf(stderr,
"json atom2 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i2 = json_integer_value(atom2) - 1;
ag->imps[i].a1 = &(ag->atoms[i2]);
(ag->atoms[i2].nimps)++;
atom3 = json_object_get(improper, "atom3");
if (!json_is_integer(atom3)) {
fprintf(stderr,
"json atom3 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i3 = json_integer_value(atom3) - 1;
ag->imps[i].a2 = &(ag->atoms[i3]);
(ag->atoms[i3].nimps)++;
atom4 = json_object_get(improper, "atom4");
if (!json_is_integer(atom4)) {
fprintf(stderr,
"json atom4 is not integer for improper %zd in json_file %s\n",
i, json_file);
}
int i4 = json_integer_value(atom4) - 1;
ag->imps[i].a3 = &(ag->atoms[i4]);
(ag->atoms[i4].nimps)++;
phi = json_object_get(improper, "phi");
if (!json_is_real(phi)) {
fprintf(stderr,
"json phi is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].psi0 = json_real_value(phi);
spring_constant = json_object_get(improper, "spring_constant");
if (!json_is_real(spring_constant)) {
fprintf(stderr,
"json spring_constant is not floating point for improper %zd in json_file %s\n",
i, json_file);
}
ag->imps[i].k = json_real_value(spring_constant);
}
json_decref(base);
//allocate atom arrays of pointers to parameters
for (size_t i = 0; i < natoms; i++) {
int i1 = ag->atoms[i].nbonds;
ag->atoms[i].bonds = _mol_calloc(i1, sizeof(struct atombond *));
ag->atoms[i].nbonds = 0;
i1 = ag->atoms[i].nangs;
ag->atoms[i].angs = _mol_calloc(i1, sizeof(struct atomangle *));
ag->atoms[i].nangs = 0;
i1 = ag->atoms[i].ntors;
ag->atoms[i].tors =
_mol_calloc(i1, sizeof(struct atomtorsion *));
ag->atoms[i].ntors = 0;
i1 = ag->atoms[i].nimps;
ag->atoms[i].imps =
_mol_calloc(i1, sizeof(struct atomimproper *));
ag->atoms[i].nimps = 0;
}
struct atom *atm;
//fill bonds
for (int i = 0; i < ag->nbonds; i++) {
atm = ag->bonds[i].a0;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
atm = ag->bonds[i].a1;
atm->bonds[(atm->nbonds)++] = &(ag->bonds[i]);
}
//fill angles
for (int i = 0; i < ag->nangs; i++) {
atm = ag->angs[i].a0;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a1;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
atm = ag->angs[i].a2;
atm->angs[(atm->nangs)++] = &(ag->angs[i]);
}
//fill torsions
for (int i = 0; i < ag->ntors; i++) {
atm = ag->tors[i].a0;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a1;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a2;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
atm = ag->tors[i].a3;
atm->tors[(atm->ntors)++] = &(ag->tors[i]);
}
//fill impropers
for (int i = 0; i < ag->nimps; i++) {
atm = ag->imps[i].a0;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a1;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a2;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
atm = ag->imps[i].a3;
atm->imps[(atm->nimps)++] = &(ag->imps[i]);
}
//atom indices in the group
fill_ingrp(ag);
ag->is_psf_read = true;
// copy vals from deprecated to new data structures
int atomsi;
for (atomsi = 0; atomsi < ag->natoms; atomsi++) {
_mol_atom_create_bond_indices(&ag->atoms[atomsi],
ag->atoms[atomsi].nbonds);
}
_mol_atom_group_copy_from_deprecated(ag);
return ag;
}
struct atomgrp *read_pdb(const char *path, struct prm *prm)
{
FILE *fp = myfopen(path, "r");
struct atomgrp *ag =
(struct atomgrp *)_mol_calloc(1, sizeof(struct atomgrp));
char *line = NULL;
size_t len = 0;
char atypemaj[5];
char atypemin[5];
// read every line of the pdb file
int atomi = 0;
ag->natoms = 100; // just a guess, realloc as necessary
ag->atoms =
(struct atom *)_mol_malloc(sizeof(struct atom) * ag->natoms);
while (getline(&line, &len, fp) != -1) {
if (strncmp(line, "ATOM ", 6) != 0) // check for ATOM line
continue;
if (atomi + 1 > ag->natoms) {
ag->natoms *= 2;
ag->atoms =
(struct atom *)_mol_realloc(ag->atoms,
sizeof(struct atom) *
ag->natoms);
}
/*
// init bonds
ag->atoms[atomi].bonds[0] = -1;
ag->atoms[atomi].bonds[1] = -1;
ag->atoms[atomi].bonds[2] = -1;
ag->atoms[atomi].bonds[3] = -1;
*/
// init sa
ag->atoms[atomi].sa = -1;
// init mask
ag->atoms[atomi].mask = 0;
// init attl
ag->atoms[atomi].attl = 0.0;
ag->atoms[atomi].nbondis = 0;
ag->atoms[atomi].nbonds = 0;
ag->atoms[atomi].nangs = 0;
ag->atoms[atomi].ntors = 0;
ag->atoms[atomi].nimps = 0;
if (sscanf(line, "%*s %*d %4s %4s", atypemin, atypemaj) < 2) {
fprintf(stderr,
"error: in file %s line %s: incorrect atom line\n",
path, line);
exit(EXIT_FAILURE);
}
ag->atoms[atomi].atom_typen = atomid(prm, atypemaj, atypemin);
if (ag->atoms[atomi].atom_typen == -1) // val not found
{
if (atypemin[0] == 'H') // try one more time for hydrogen
{
atypemin[1] = '\0';
ag->atoms[atomi].atom_typen =
atomid(prm, atypemaj, atypemin);
}
if (ag->atoms[atomi].atom_typen == -1) // val still not found
{
fprintf(stderr,
"error: in file %s line %s: atom type number of %s %s not defined in prm\n",
path, line, atypemaj, atypemin);
exit(EXIT_FAILURE);
}
}
if (!strcmp(atypemin, "C") || !strcmp(atypemin, "CA")
|| !strcmp(atypemin, "N") || !strcmp(atypemin, "O")
|| !strcmp(atypemin, "H"))
ag->atoms[atomi].backbone = true;
else
ag->atoms[atomi].backbone = false;
sscanf(&line[30], "%8lf%8lf%8lf",
&ag->atoms[atomi].X, &ag->atoms[atomi].Y,
&ag->atoms[atomi].Z);
sscanf(&line[60], "%6lf", &ag->atoms[atomi].B);
ag->atoms[atomi].icode = line[26];
line[26] = 0;
errno = 0;
ag->atoms[atomi].res_seq = atoi(&line[22]);
if (errno) {
perror("atoi");
exit(EXIT_FAILURE);
}
ag->atoms[atomi].base = ag->atoms[atomi].base2 = -1;
atomi++;
}
if (line)
free(line);
myfclose(fp);
// final realloc of the arrays to make them tight
ag->natoms = atomi;
ag->atoms =
(struct atom *)_mol_realloc(ag->atoms,
sizeof(struct atom) * ag->natoms);
ag->is_psf_read = false;
ag->prm = prm;
// check_atomgrp (ag, prm);
return ag;
}
struct atomgrp *read_pdb_nopar(const char *path)
{
FILE *fp = myfopen(path, "r");
struct atomgrp *ag =
(struct atomgrp *)_mol_calloc(1, sizeof(struct atomgrp));
char *line = NULL;
size_t len = 0;
// read every line of the pdb file
int atomi = 0;
ag->natoms = 100; // just a guess, realloc as necessary
ag->atoms =
(struct atom *)_mol_malloc(sizeof(struct atom) * ag->natoms);
while (getline(&line, &len, fp) != -1) {
char *atom_name;
if (strncmp(line, "ATOM ", 6) != 0
&& strncmp(line, "HETATM", 6) != 0)
continue;
if (atomi + 1 > ag->natoms) {
ag->natoms *= 2;
ag->atoms =
(struct atom *)_mol_realloc(ag->atoms,
sizeof(struct atom) *
ag->natoms);
}
// init bonds
/*
ag->atoms[atomi].bonds[0] = -1;
ag->atoms[atomi].bonds[1] = -1;
ag->atoms[atomi].bonds[2] = -1;
ag->atoms[atomi].bonds[3] = -1;
*/
// init sa
ag->atoms[atomi].sa = -1;
// init mask
// ag->atoms[atomi].mask = 0;
// init attl
// ag->atoms[atomi].attl = 0.0;
ag->atoms[atomi].atom_typen = 1;
if (!strncmp(line + 13, "C ", 2)
|| !strncmp(line + 13, "CA ", 3)
|| !strncmp(line + 13, "N ", 2)
|| !strncmp(line + 13, "O ", 2)
|| !strncmp(line + 13, "H ", 2))
ag->atoms[atomi].backbone = true;
else
ag->atoms[atomi].backbone = false;
atom_name = _mol_calloc(5, sizeof(char));
strncpy(atom_name, line + 12, 4);
rstrip(atom_name);
while (isspace(*atom_name)) {
memmove(atom_name, atom_name + 1, 4);
}
ag->atoms[atomi].name = atom_name;
sscanf(&line[30], "%8lf%8lf%8lf",
&ag->atoms[atomi].X, &ag->atoms[atomi].Y,
&ag->atoms[atomi].Z);
sscanf(&line[60], "%6lf", &ag->atoms[atomi].B);
ag->atoms[atomi].icode = line[26];
line[26] = 0;
errno = 0;
ag->atoms[atomi].res_seq = atoi(&line[22]);
if (errno) {
perror("atoi");
exit(EXIT_FAILURE);
}
ag->atoms[atomi].base = ag->atoms[atomi].base2 = -1;
ag->atoms[atomi].element = NULL;
atomi++;
}
if (line)
free(line);
myfclose(fp);
// final realloc of the arrays to make them tight
ag->natoms = atomi;
ag->atoms =
(struct atom *)_mol_realloc(ag->atoms,
sizeof(struct atom) * ag->natoms);
ag->is_psf_read = false;
ag->prm = NULL;
return ag;
}
struct atomgrp* read_ms (const char* path, struct prm* prm)
{
FILE* fp = myfopen (path, "r");
struct atomgrp* ag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
char* line = NULL;
size_t len = 0;
// tmp scanf vals
char atypemaj[5];
char atypemin[5];
// read every line of the pdb file
int atomi = 0;
ag->natoms = 100; // just a guess, realloc as necessary
ag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * ag->natoms);
while (getline (&line, &len, fp) != -1)
{
if (strncmp (line, "ATOM ", 6) != 0) // check for ATOM line
continue;
if (atomi+1 > ag->natoms)
{
ag->natoms *= 2;
ag->atoms = (struct atom*) _mol_realloc (ag->atoms, sizeof (struct atom) * ag->natoms);
}
/*
// init bonds
ag->atoms[atomi].bonds[0] = -1;
ag->atoms[atomi].bonds[1] = -1;
ag->atoms[atomi].bonds[2] = -1;
ag->atoms[atomi].bonds[3] = -1;
*/
// init sa
ag->atoms[atomi].sa = -1;
// init mask
ag->atoms[atomi].mask = 0;
ag->atoms[atomi].nbondis = 0;
ag->atoms[atomi].nbonds = 0;
ag->atoms[atomi].nangs = 0;
ag->atoms[atomi].ntors = 0;
ag->atoms[atomi].nimps = 0;
if (sscanf (line, "%*s %*d %4s %4s", atypemin, atypemaj) < 2)
{
fprintf (stderr, "begin error\n");
fprintf (stderr, "in function read_ms\n");
fprintf (stderr, "incorrect format for ATOM line\n");
fprintf (stderr, "at file:\n");
fprintf (stderr, "%s\n", path);
fprintf (stderr, "at line:\n");
fprintf (stderr, "%s\n", line);
fprintf (stderr, "end error\n");
exit (EXIT_FAILURE);
}
if (strncmp (atypemin, "HT", 2) == 0)
continue; // ignore terminal hydrogens
if (strncmp (atypemin, "OCT1", 4) == 0)
{
atypemin[1] = '\0';
}
if (strncmp (atypemin, "OCT2", 4) == 0)
continue;
ag->atoms[atomi].atom_typen = atomid (prm, atypemaj, atypemin);
if (ag->atoms[atomi].atom_typen == -1) // val not found
{
if (atypemin[0] == 'H') // try one more time for hydrogen
{
atypemin[1] = '\0';
ag->atoms[atomi].atom_typen = atomid (prm, atypemaj, atypemin);
}
if (ag->atoms[atomi].atom_typen == -1) // val still not found
{
fprintf (stderr, "error: in file %s line %s: atom type number of %s %s not defined in prm\n", path, line, atypemaj, atypemin);
exit (EXIT_FAILURE);
}
}
ag->atoms[atomi].X = atof (&line[30]);
ag->atoms[atomi].Y = atof (&line[38]);
ag->atoms[atomi].Z = atof (&line[46]);
//if (line[57] != '0' && line[57] != '1') // verify that sa is 1 or 0
if (! (line[57] >= '0' && line[57] <= '9')) // verify that sa is 1 or 0
{
fprintf (stderr, "error: file %s does not appear to be an ms file\n", path);
exit (EXIT_FAILURE);
}
//ag->atoms[atomi].sa = atoi (&line[57]);
ag->atoms[atomi].attl = atof (&line[57]);
if (ag->atoms[atomi].attl > 0.0)
{
ag->atoms[atomi].sa = 1;
}
else
{
ag->atoms[atomi].sa = 0;
}
atomi++;
}
if (line)
free (line);
myfclose (fp);
// final realloc of the arrays to make them tight
ag->natoms = atomi;
assert (ag->natoms > 0);
ag->atoms = (struct atom*) _mol_realloc (ag->atoms, sizeof (struct atom) * ag->natoms);
check_atomgrp (ag, prm);
return ag;
}
struct atomgrp* read_ms_nopar (const char* path)
{
FILE* fp = myfopen (path, "r");
struct atomgrp* ag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
char* line = NULL;
size_t len = 0;
// read every line of the pdb file
int atomi = 0;
ag->natoms = 100; // just a guess, realloc as necessary
ag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * ag->natoms);
while (getline (&line, &len, fp) != -1)
{
if (strncmp (line, "ATOM ", 6) != 0) // check for ATOM line
continue;
if (atomi+1 > ag->natoms)
{
ag->natoms *= 2;
ag->atoms = (struct atom*) _mol_realloc (ag->atoms, sizeof (struct atom) * ag->natoms);
}
/*
// init bonds
ag->atoms[atomi].bonds[0] = -1;
ag->atoms[atomi].bonds[1] = -1;
ag->atoms[atomi].bonds[2] = -1;
ag->atoms[atomi].bonds[3] = -1;
*/
// init sa
ag->atoms[atomi].sa = -1;
// init mask
ag->atoms[atomi].mask = 0;
ag->atoms[atomi].atom_typen = 1;
ag->atoms[atomi].X = atof (&line[30]);
ag->atoms[atomi].Y = atof (&line[38]);
ag->atoms[atomi].Z = atof (&line[46]);
//if (line[57] != '0' && line[57] != '1') // verify that sa is 1 or 0
if (! (line[57] >= '0' && line[57] <= '9')) // verify that sa is 1 or 0
{
fprintf (stderr, "error: file %s does not appear to be an ms file\n", path);
exit (EXIT_FAILURE);
}
//ag->atoms[atomi].sa = atoi (&line[57]);
ag->atoms[atomi].attl = atof (&line[57]);
if (ag->atoms[atomi].attl > 0.0)
{
ag->atoms[atomi].sa = 1;
}
else
{
ag->atoms[atomi].sa = 0;
}
atomi++;
}
if (line)
free (line);
myfclose (fp);
// final realloc of the arrays to make them tight
ag->natoms = atomi;
ag->atoms = (struct atom*) _mol_realloc (ag->atoms, sizeof (struct atom) * ag->natoms);
return ag;
}
struct atomgrp* fullcopy_atomgrp (struct atomgrp* srcag)
{
struct atomgrp* destag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
destag->natoms = srcag->natoms;
destag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * destag->natoms);
memcpy(destag->atoms, srcag->atoms, sizeof(struct atom) * destag->natoms);
//destag->nactives = srcag->nactives ;
//destag->activelist = _mol_malloc(destag->nactives*sizeof(int));
//for (i = 0; i < destag->nactives; i++)
//{
// destag->activelist[i]=srcag->activelist[i];
//}
destag->nbonds=srcag->nbonds;
destag->bonds= _mol_malloc (destag->nbonds*sizeof(struct atombond));
memcpy(destag->bonds, srcag->bonds, sizeof(struct atombond) * destag->nbonds);
//destag->nbact=srcag->nbact;
//destag->bact= _mol_malloc (destag->nbact*sizeof(struct atombond*));
//for (i = 0; i < destag->nbact; i++)
//{
// destag->bact[i]=srcag->bact[i];
//}
destag->nangs=srcag->nangs;
destag->angs= _mol_malloc (destag->nangs*sizeof(struct atomangle));
memcpy(destag->angs, srcag->angs, sizeof(struct atomangle) * destag->nangs);
//destag->nangact=srcag->nangact;
//destag->angact= _mol_malloc (destag->nangact*sizeof(struct atomangle*));
//for (i = 0; i < destag->nangact; i++)
//{
// destag->angact[i]=srcag->angact[i];
//}
destag->ntors=srcag->ntors;
destag->tors= _mol_malloc (destag->ntors*sizeof(struct atomtorsion));
memcpy(destag->tors, srcag->tors, sizeof(struct atomtorsion) * destag->ntors);
//destag->ntoract=srcag->ntoract;
//destag->toract= _mol_malloc (destag->ntoract*sizeof(struct atomtorsion*));
//for (i = 0; i < destag->ntoract; i++)
//{
// destag->toract[i]=srcag->toract[i];
//}
destag->nimps=srcag->nimps;
destag->imps= _mol_malloc (destag->nimps*sizeof(struct atomimproper));
memcpy(destag->imps, srcag->imps, sizeof(struct atomimproper) * destag->nimps);
//destag->nimpact=srcag->nimpact;
//destag->impact= _mol_malloc (destag->nimpact*sizeof(struct atomimproper*));
//for (i = 0; i < destag->nimpact; i++)
//{
// destag->impact[i]=srcag->impact[i];
//}
//point to correct atoms
size_t atom_offset = destag->atoms - srcag->atoms;
for (int i = 0; i < destag->nbonds; i++) {
destag->bonds[i].a0 += atom_offset;
destag->bonds[i].a1 += atom_offset;
}
for (int i = 0; i < destag->nangs; i++) {
destag->angs[i].a0 += atom_offset;
destag->angs[i].a1 += atom_offset;
destag->angs[i].a2 += atom_offset;
}
for (int i = 0; i < destag->ntors; i++) {
destag->tors[i].a0 += atom_offset;
destag->tors[i].a1 += atom_offset;
destag->tors[i].a2 += atom_offset;
destag->tors[i].a3 += atom_offset;
}
for (int i = 0; i < destag->nimps; i++) {
destag->imps[i].a0 += atom_offset;
destag->imps[i].a1 += atom_offset;
destag->imps[i].a2 += atom_offset;
destag->imps[i].a3 += atom_offset;
}
//point to atoms to correct bonds, angs, tors, imps
size_t bond_offset = destag->bonds - srcag->bonds;
size_t ang_offset = destag->angs - srcag->angs;
size_t imp_offset = destag->imps - srcag->imps;
size_t tor_offset = destag->tors - srcag->tors;
for (int i = 0; i < destag->natoms; i++) {
// struct atom local_atom = destag->atoms[i];
destag->atoms[i].name = strdup(srcag->atoms[i].name);
destag->atoms[i].bonds = _mol_malloc( destag->atoms[i].nbonds*sizeof(struct atombond*));
memcpy(destag->atoms[i].bonds, srcag->atoms[i].bonds, sizeof(struct atombond*) * destag->atoms[i].nbonds);
for (int j = 0; j < destag->atoms[i].nbonds; j++) {
destag->atoms[i].bonds[j] += bond_offset;
}
destag->atoms[i].angs = _mol_malloc( destag->atoms[i].nangs*sizeof(struct atomangle*));
memcpy(destag->atoms[i].angs, srcag->atoms[i].angs, sizeof(struct atomangle*) * destag->atoms[i].nangs);
for (int j = 0; j < destag->atoms[i].nangs; j++) {
destag->atoms[i].angs[j] += ang_offset;
}
destag->atoms[i].tors = _mol_malloc( destag->atoms[i].ntors*sizeof(struct atomtorsion*));
memcpy(destag->atoms[i].tors, srcag->atoms[i].tors, sizeof(struct atomtorsion*) * destag->atoms[i].ntors);
for (int j = 0; j < destag->atoms[i].ntors; j++) {
destag->atoms[i].tors[j] += tor_offset;
}
destag->atoms[i].imps = _mol_malloc( destag->atoms[i].nimps*sizeof(struct atomimproper*));
memcpy(destag->atoms[i].imps, srcag->atoms[i].imps, sizeof(struct atomimproper*) * destag->atoms[i].nimps);
for (int j = 0; j < destag->atoms[i].nimps; j++) {
destag->atoms[i].imps[j] += imp_offset;
}
}
//destag->nres=srcag->nres;
//destag->iares=srcag->iares;
//destag->idres=srcag->idres;
//destag->is_psf_read=srcag->is_psf_read;
return destag;
}
//Init ACE
void ace_ini(struct atomgrp *ag, struct acesetup *ac_s)
{
const double minr = 0.6;
int i, j, k;
const double sqrtpi = sqrt(M_PI);
const double c1 = 4.0 / (3.0 * M_PI);
const double c2 = 77.0 * M_PI * M_SQRT2 / 512.0;
const double c3 = 2.0 * M_PI * sqrtpi;
const double pi2 = M_1_PI * M_1_PI;
const double width = 1.2;
double ri, ri2, rk, vk, rk2, alpha, alpha2, alpha4, prod2, prod4, ratio,
tik2, qik, qterm, temp, fik, omik, s2ik, s3ik, uik, omgik;
int nbsize;
ac_s->ntypes = ag->num_atom_types + 1;
ac_s->rsolv = (double *)_mol_malloc(sizeof(double) * ac_s->ntypes);
ac_s->vsolv = (double *)_mol_malloc(sizeof(double) * ac_s->ntypes);
ac_s->lwace = (double *)_mol_malloc(sizeof(double) * ac_s->ntypes);
ac_s->s2ace =
(double *)_mol_malloc(sizeof(double) * ac_s->ntypes * ac_s->ntypes);
ac_s->uace =
(double *)_mol_malloc(sizeof(double) * ac_s->ntypes * ac_s->ntypes);
ac_s->wace =
(double *)_mol_malloc(sizeof(double) * ac_s->ntypes * ac_s->ntypes);
ac_s->hydr = (double *)_mol_malloc(sizeof(double) * ac_s->ntypes);
for (i = 0; i < ac_s->ntypes; i++) {
ac_s->vsolv[i] = -1.0;
ac_s->rsolv[i] = 0.0;
}
for (i = 0; i < ag->natoms; i++) {
if (ac_s->vsolv[ag->atoms[i].atom_ftypen] <= 0.0) {
struct atombond bp;
ac_s->vsolv[ag->atoms[i].atom_ftypen] =
ag->atoms[i].acevolume;
ac_s->rsolv[ag->atoms[i].atom_ftypen] =
_mol_max(ag->atoms[i].rminh, minr);
//Hydrogen correction
if (strcmp("H", ag->atoms[i].ftype_name) == 0) {
ac_s->rsolv[ag->atoms[i].atom_ftypen] =
_mol_max(0.85,
ac_s->rsolv[ag->atoms[i].
atom_ftypen]);
} else if (strcmp("HC", ag->atoms[i].ftype_name) == 0) {
ac_s->rsolv[ag->atoms[i].atom_ftypen] =
_mol_max(0.83,
ac_s->rsolv[ag->atoms[i].
atom_ftypen]);
}
// printf(" %d %.3f \n",ag->atoms[i].atom_ftypen,ag->atoms[i].rminh);
for (j = 0; j < ag->nbonds; j++) {
bp = ag->bonds[j];
if (bp.a0->atom_ftypen ==
ag->atoms[i].atom_ftypen) {
ac_s->rsolv[ag->atoms[i].atom_ftypen] =
_mol_max(ac_s->
rsolv[ag->atoms[i].
atom_ftypen],
bp.a1->rminh - bp.l0);
}
if (ag->bonds[j].a1->atom_ftypen ==
ag->atoms[i].atom_ftypen) {
ac_s->rsolv[ag->atoms[i].atom_ftypen] =
_mol_max(ac_s->
rsolv[ag->atoms[i].
atom_ftypen],
bp.a0->rminh - bp.l0);
}
}
}
}
//Hydrogen correction
// if (ac_s->rsolv[1]<0.85) ac_s->rsolv[1]=0.85; //H ?
// if (ac_s->rsolv[2]<0.83) ac_s->rsolv[2]=0.83; //HC ?
for (i = 0; i < ac_s->ntypes; i++) {
if (ac_s->vsolv[i] >= 0.0) {
// printf ("%d %.3f %.3f\n",i,ac_s->vsolv[i],ac_s->rsolv[i]);
}
}
for (i = 0; i < ac_s->ntypes; i++) {
ac_s->hydr[i] =
-4 * M_PI * 0.003 * ac_s->rsolv[i] * (ac_s->rsolv[i] +
1.4) *
(ac_s->rsolv[i] + 1.4);
ri = ac_s->rsolv[i];
ri2 = ri * ri;
if (ri > 0) {
for (k = 0; k < ac_s->ntypes; k++) {
rk = ac_s->rsolv[k];
vk = ac_s->vsolv[k];
if (rk > 0) {
rk2 = rk * rk;
alpha = _mol_max(width, ri / rk);
alpha2 = alpha * alpha;
alpha4 = alpha2 * alpha2;
prod2 = alpha2 * rk2;
prod4 = prod2 * prod2;
ratio = alpha2 * rk2 / ri2;
tik2 = 0.5 * M_PI * ratio;
temp = 1.0 / (1.0 + 2.0 * tik2);
fik = 2.0 / (1.0 + tik2) - temp;
qik = tik2 * sqrt(temp);
qterm = qik - atan(qik);
if (k == i) {
omik =
-((vk * pi2) -
c1 * (ri2 * ri)) * qterm /
(alpha4 * ri2 * ri2);
ac_s->lwace[i] = omik;
}
if (vk > 1.0e-8) {
omgik =
vk * qterm * pi2 / prod4;
s2ik =
3.0 * qterm * prod2 /
((3.0 + fik) * qik -
4.0 * atan(qik));
s3ik = s2ik * sqrt(s2ik);
uik =
c2 * ri / (1.0 -
(c3 * s3ik * ri *
omgik / vk));
ac_s->wace[i * ac_s->ntypes +
k] = omgik;
ac_s->s2ace[i * ac_s->ntypes +
k] = s2ik;
ac_s->uace[i * ac_s->ntypes +
k] = uik;
} else {
ac_s->wace[i * ac_s->ntypes +
k] = 0.0;
ac_s->s2ace[i * ac_s->ntypes +
k] = 1.0e-6;
ac_s->uace[i * ac_s->ntypes +
k] = 1.0e+6;
}
}
}
}
}
for (i = 0; i < ac_s->ntypes; i++) {
if (ac_s->vsolv[i] >= 0.0) {
for (k = 0; k < ac_s->ntypes; k++) {
if (ac_s->vsolv[k] >= 0.0) {
// printf ("%d %d %.3f %.3f\n",i,k,ac_s->wace[i*ac_s->ntypes+k],ac_s->lwace[i]);
}
}
}
}
ac_s->nbsize = 1;
nbsize = 1;
ac_s->eself = _mol_calloc(sizeof(double), ag->natoms);
ac_s->rborn = _mol_calloc(sizeof(double), ag->natoms);
ac_s->swarr = _mol_calloc(sizeof(double), nbsize);
ac_s->dswarr = _mol_calloc(sizeof(double), nbsize);
ac_s->darr = _mol_calloc(sizeof(double), nbsize);
//d(rb)/d(eself)
ac_s->dbrdes = _mol_calloc(sizeof(double), ag->natoms);
ac_s->xsf = _mol_calloc(sizeof(double), 2 * nbsize);
ac_s->ysf = _mol_calloc(sizeof(double), 2 * nbsize);
ac_s->zsf = _mol_calloc(sizeof(double), 2 * nbsize);
ac_s->xf = _mol_calloc(sizeof(double), ag->natoms);
ac_s->yf = _mol_calloc(sizeof(double), ag->natoms);
ac_s->zf = _mol_calloc(sizeof(double), ag->natoms);
ac_s->diarr = _mol_calloc(sizeof(double), ag->natoms);
ac_s->list0123 = _mol_calloc(sizeof(int), 1);
}
struct atomgrp* fullcopy_atomgrp (struct atomgrp* srcag)
{
struct atomgrp* destag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
destag->natoms = srcag->natoms;
destag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * destag->natoms);
int i;
for (i = 0; i < destag->natoms; i++)
{
fullcopy_atom (&srcag->atoms[i], &destag->atoms[i]);
}
destag->nactives = srcag->nactives ;
destag->activelist = _mol_malloc(destag->nactives*sizeof(int));
for (i = 0; i < destag->nactives; i++)
{
destag->activelist[i]=srcag->activelist[i];
}
destag->nbonds=srcag->nbonds;
destag->bonds= _mol_malloc (destag->nbonds*sizeof(struct atombond));
for (i = 0; i < destag->nbonds; i++)
{
destag->bonds[i]=srcag->bonds[i];
}
destag->nbact=srcag->nbact;
destag->bact= _mol_malloc (destag->nbact*sizeof(struct atombond*));
for (i = 0; i < destag->nbact; i++)
{
destag->bact[i]=srcag->bact[i];
}
destag->nangs=srcag->nangs;
destag->angs= _mol_malloc (destag->nangs*sizeof(struct atomangle));
for (i = 0; i < destag->nangs; i++)
{
destag->angs[i]=srcag->angs[i];
}
destag->nangact=srcag->nangact;
destag->angact= _mol_malloc (destag->nangact*sizeof(struct atomangle*));
for (i = 0; i < destag->nangact; i++)
{
destag->angact[i]=srcag->angact[i];
}
destag->ntors=srcag->ntors;
destag->tors= _mol_malloc (destag->ntors*sizeof(struct atomtorsion));
for (i = 0; i < destag->ntors; i++)
{
destag->tors[i]=srcag->tors[i];
}
destag->ntoract=srcag->ntoract;
destag->toract= _mol_malloc (destag->ntoract*sizeof(struct atomtorsion*));
for (i = 0; i < destag->ntoract; i++)
{
destag->toract[i]=srcag->toract[i];
}
destag->nimps=srcag->nimps;
destag->imps= _mol_malloc (destag->nimps*sizeof(struct atomimproper));
for (i = 0; i < destag->nimps; i++)
{
destag->imps[i]=srcag->imps[i];
}
destag->nimpact=srcag->nimpact;
destag->impact= _mol_malloc (destag->nimpact*sizeof(struct atomimproper*));
for (i = 0; i < destag->nimpact; i++)
{
destag->impact[i]=srcag->impact[i];
}
destag->nres=srcag->nres;
destag->iares=srcag->iares;
destag->idres=srcag->idres;
destag->is_psf_read=srcag->is_psf_read;
return destag;
}
struct atomgrp *join_rec_lig_ff(struct atomgrp *rec, struct atomgrp *lig)
{
int i;
int j;
struct atomgrp *ag =
(struct atomgrp *)_mol_calloc(1, sizeof(struct atomgrp));
//sum counts
ag->natoms = rec->natoms + lig->natoms;
ag->nbonds = rec->nbonds + lig->nbonds;
ag->nangs = rec->nangs + lig->nangs;
ag->ntors = rec->ntors + lig->ntors;
ag->nimps = rec->nimps + lig->nimps;
ag->num_atom_types = rec->num_atom_types + lig->num_atom_types;
//don't think we need actives yet
//ag->nactives = rec->nactives + lig->nactives;
//ag->nbact = rec->nbact + lig->nbact;
//ag->nangact = rec->nangact + lig->nangact;
//ag->ntoract = rec->ntoract + lig->ntoract;
//ag->nimpact = rec->nimpact + lig->nimpact;
//allocate first level
ag->atoms =
(struct atom *)_mol_malloc(sizeof(struct atom) * ag->natoms);
ag->bonds =
(struct atombond *)_mol_malloc(sizeof(struct atombond) *
ag->nbonds);
ag->angs =
(struct atomangle *)_mol_malloc(sizeof(struct atomangle) *
ag->nangs);
ag->tors =
(struct atomtorsion *)_mol_malloc(sizeof(struct atomtorsion) *
ag->ntors);
ag->imps =
(struct atomimproper *)_mol_malloc(sizeof(struct atomimproper) *
ag->nimps);
//copy rec items
memcpy(ag->atoms, rec->atoms, sizeof(struct atom) * rec->natoms);
memcpy(ag->bonds, rec->bonds, sizeof(struct atombond) * rec->nbonds);
memcpy(ag->angs, rec->angs, sizeof(struct atomangle) * rec->nangs);
memcpy(ag->tors, rec->tors, sizeof(struct atomtorsion) * rec->ntors);
memcpy(ag->imps, rec->imps, sizeof(struct atomimproper) * rec->nimps);
//point to correct atoms
for (i = 0; i < rec->nbonds; i++) {
ptrdiff_t a0_offset = ag->bonds[i].a0 - rec->atoms;
ptrdiff_t a1_offset = ag->bonds[i].a1 - rec->atoms;
ag->bonds[i].a0 = ag->atoms + a0_offset;
ag->bonds[i].a1 = ag->atoms + a1_offset;
}
for (i = 0; i < rec->nangs; i++) {
ptrdiff_t a0_offset = ag->angs[i].a0 - rec->atoms;
ptrdiff_t a1_offset = ag->angs[i].a1 - rec->atoms;
ptrdiff_t a2_offset = ag->angs[i].a2 - rec->atoms;
ag->angs[i].a0 = ag->atoms + a0_offset;
ag->angs[i].a1 = ag->atoms + a1_offset;
ag->angs[i].a2 = ag->atoms + a2_offset;
}
for (i = 0; i < rec->ntors; i++) {
ptrdiff_t a0_offset = ag->tors[i].a0 - rec->atoms;
ptrdiff_t a1_offset = ag->tors[i].a1 - rec->atoms;
ptrdiff_t a2_offset = ag->tors[i].a2 - rec->atoms;
ptrdiff_t a3_offset = ag->tors[i].a3 - rec->atoms;
ag->tors[i].a0 = ag->atoms + a0_offset;
ag->tors[i].a1 = ag->atoms + a1_offset;
ag->tors[i].a2 = ag->atoms + a2_offset;
ag->tors[i].a3 = ag->atoms + a3_offset;
}
for (i = 0; i < rec->nimps; i++) {
ptrdiff_t a0_offset = ag->imps[i].a0 - rec->atoms;
ptrdiff_t a1_offset = ag->imps[i].a1 - rec->atoms;
ptrdiff_t a2_offset = ag->imps[i].a2 - rec->atoms;
ptrdiff_t a3_offset = ag->imps[i].a3 - rec->atoms;
ag->imps[i].a0 = ag->atoms + a0_offset;
ag->imps[i].a1 = ag->atoms + a1_offset;
ag->imps[i].a2 = ag->atoms + a2_offset;
ag->imps[i].a3 = ag->atoms + a3_offset;
}
//point to atoms to correct bonds, angs, tors, imps
for (i = 0; i < rec->natoms; i++) {
ag->atoms[i].name = strdup(rec->atoms[i].name);
if (rec->atoms[i].residue_name != NULL) {
ag->atoms[i].residue_name = strdup(rec->atoms[i].residue_name);
}
ag->atoms[i].ftype_name = strdup(rec->atoms[i].ftype_name);
ag->atoms[i].bonds =
_mol_malloc(rec->atoms[i].nbonds *
sizeof(struct atombond *));
memcpy(ag->atoms[i].bonds, rec->atoms[i].bonds,
sizeof(struct atombond *) * rec->atoms[i].nbonds);
for (j = 0; j < ag->atoms[i].nbonds; j++) {
ptrdiff_t bond_offset =
ag->atoms[i].bonds[j] - rec->bonds;
ag->atoms[i].bonds[j] = ag->bonds + bond_offset;
}
ag->atoms[i].angs =
_mol_malloc(rec->atoms[i].nangs *
sizeof(struct atomangle *));
memcpy(ag->atoms[i].angs, rec->atoms[i].angs,
sizeof(struct atomangle *) * rec->atoms[i].nangs);
for (j = 0; j < ag->atoms[i].nangs; j++) {
ptrdiff_t ang_offset = ag->atoms[i].angs[j] - rec->angs;
ag->atoms[i].angs[j] = ag->angs + ang_offset;
}
ag->atoms[i].tors =
_mol_malloc(rec->atoms[i].ntors *
sizeof(struct atomtorsion *));
memcpy(ag->atoms[i].tors, rec->atoms[i].tors,
sizeof(struct atomtorsion *) * rec->atoms[i].ntors);
for (j = 0; j < ag->atoms[i].ntors; j++) {
ptrdiff_t tor_offset = ag->atoms[i].tors[j] - rec->tors;
ag->atoms[i].tors[j] = ag->tors + tor_offset;
}
ag->atoms[i].imps =
_mol_malloc(rec->atoms[i].nimps *
sizeof(struct atomimproper *));
memcpy(ag->atoms[i].imps, rec->atoms[i].imps,
sizeof(struct atomimproper *) * rec->atoms[i].nimps);
for (j = 0; j < ag->atoms[i].nimps; j++) {
ptrdiff_t imp_offset = ag->atoms[i].imps[j] - rec->imps;
ag->atoms[i].imps[j] = ag->imps + imp_offset;
}
}
//copy lig items
memcpy(ag->atoms + rec->natoms, lig->atoms,
sizeof(struct atom) * lig->natoms);
memcpy(ag->bonds + rec->nbonds, lig->bonds,
sizeof(struct atombond) * lig->nbonds);
memcpy(ag->angs + rec->nangs, lig->angs,
sizeof(struct atomangle) * lig->nangs);
memcpy(ag->tors + rec->ntors, lig->tors,
sizeof(struct atomtorsion) * lig->ntors);
memcpy(ag->imps + rec->nimps, lig->imps,
sizeof(struct atomimproper) * lig->nimps);
//point to correct atoms
struct atom *newlig_atoms = ag->atoms + rec->natoms;
for (i = rec->nbonds; i < ag->nbonds; i++) {
ptrdiff_t a0_offset = ag->bonds[i].a0 - lig->atoms;
ptrdiff_t a1_offset = ag->bonds[i].a1 - lig->atoms;
ag->bonds[i].a0 = newlig_atoms + a0_offset;
ag->bonds[i].a1 = newlig_atoms + a1_offset;
ag->bonds[i].ai += rec->natoms;
ag->bonds[i].aj += rec->natoms;
}
for (i = rec->nangs; i < ag->nangs; i++) {
ptrdiff_t a0_offset = ag->angs[i].a0 - lig->atoms;
ptrdiff_t a1_offset = ag->angs[i].a1 - lig->atoms;
ptrdiff_t a2_offset = ag->angs[i].a2 - lig->atoms;
ag->angs[i].a0 = newlig_atoms + a0_offset;
ag->angs[i].a1 = newlig_atoms + a1_offset;
ag->angs[i].a2 = newlig_atoms + a2_offset;
}
for (i = rec->ntors; i < ag->ntors; i++) {
ptrdiff_t a0_offset = ag->tors[i].a0 - lig->atoms;
ptrdiff_t a1_offset = ag->tors[i].a1 - lig->atoms;
ptrdiff_t a2_offset = ag->tors[i].a2 - lig->atoms;
ptrdiff_t a3_offset = ag->tors[i].a3 - lig->atoms;
ag->tors[i].a0 = newlig_atoms + a0_offset;
ag->tors[i].a1 = newlig_atoms + a1_offset;
ag->tors[i].a2 = newlig_atoms + a2_offset;
ag->tors[i].a3 = newlig_atoms + a3_offset;
}
for (i = rec->nimps; i < ag->nimps; i++) {
ptrdiff_t a0_offset = ag->imps[i].a0 - lig->atoms;
ptrdiff_t a1_offset = ag->imps[i].a1 - lig->atoms;
ptrdiff_t a2_offset = ag->imps[i].a2 - lig->atoms;
ptrdiff_t a3_offset = ag->imps[i].a3 - lig->atoms;
ag->imps[i].a0 = newlig_atoms + a0_offset;
ag->imps[i].a1 = newlig_atoms + a1_offset;
ag->imps[i].a2 = newlig_atoms + a2_offset;
ag->imps[i].a3 = newlig_atoms + a3_offset;
}
int max_rec_res_seq = rec->atoms[rec->natoms-1].comb_res_seq;
//point to atoms to correct bonds, angs, tors, imps
struct atombond *newlig_bonds = ag->bonds + rec->nbonds;
struct atomangle *newlig_angs = ag->angs + rec->nangs;
struct atomtorsion *newlig_tors = ag->tors + rec->ntors;
struct atomimproper *newlig_imps = ag->imps + rec->nimps;
for (i = rec->natoms; i < ag->natoms; i++) {
// struct atom local_atom = ag->atoms[i];
ag->atoms[i].comb_res_seq += 100 + max_rec_res_seq;
ag->atoms[i].atom_ftypen += rec->num_atom_types;
ag->atoms[i].name = strdup(lig->atoms[i - (rec->natoms)].name);
if (lig->atoms[i - (rec->natoms)].residue_name != NULL) {
ag->atoms[i].residue_name =
strdup(lig->atoms[i - (rec->natoms)].residue_name);
}
ag->atoms[i].ftype_name =
strdup(lig->atoms[i - (rec->natoms)].ftype_name);
ag->atoms[i].bonds =
_mol_malloc(lig->atoms[i - (rec->natoms)].nbonds *
sizeof(struct atombond *));
memcpy(ag->atoms[i].bonds, lig->atoms[i - (rec->natoms)].bonds,
sizeof(struct atombond *) * lig->atoms[i -
(rec->natoms)].
nbonds);
for (j = 0; j < ag->atoms[i].nbonds; j++) {
ptrdiff_t bond_offset =
ag->atoms[i].bonds[j] - lig->bonds;
ag->atoms[i].bonds[j] = newlig_bonds + bond_offset;
}
ag->atoms[i].angs =
_mol_malloc(lig->atoms[i - (rec->natoms)].nangs *
sizeof(struct atomangle *));
memcpy(ag->atoms[i].angs, lig->atoms[i - (rec->natoms)].angs,
sizeof(struct atomangle *) * lig->atoms[i -
(rec->natoms)].
nangs);
for (j = 0; j < ag->atoms[i].nangs; j++) {
ptrdiff_t ang_offset = ag->atoms[i].angs[j] - lig->angs;
ag->atoms[i].angs[j] = newlig_angs + ang_offset;
}
ag->atoms[i].tors =
_mol_malloc(lig->atoms[i - (rec->natoms)].ntors *
sizeof(struct atomtorsion *));
memcpy(ag->atoms[i].tors, lig->atoms[i - (rec->natoms)].tors,
sizeof(struct atomtorsion *) * lig->atoms[i -
(rec->natoms)].
ntors);
for (j = 0; j < ag->atoms[i].ntors; j++) {
ptrdiff_t tor_offset = ag->atoms[i].tors[j] - lig->tors;
ag->atoms[i].tors[j] = newlig_tors + tor_offset;
}
ag->atoms[i].imps =
_mol_malloc(lig->atoms[i - (rec->natoms)].nimps *
sizeof(struct atomimproper *));
memcpy(ag->atoms[i].imps, lig->atoms[i - (rec->natoms)].imps,
sizeof(struct atomimproper *) * lig->atoms[i -
(rec->
natoms)].
nimps);
for (j = 0; j < ag->atoms[i].nimps; j++) {
ptrdiff_t imp_offset = ag->atoms[i].imps[j] - lig->imps;
ag->atoms[i].imps[j] = newlig_imps + imp_offset;
}
}
//copy into ryan's structure
// _mol_atom_group_copy_from_deprecated(ag);
fill_ingrp(ag);
return ag;
}
struct atomgrp* join_rec_lig_ff(struct atomgrp* rec, struct atomgrp* lig)
{
struct atomgrp* ag = (struct atomgrp*) _mol_calloc (1, sizeof (struct atomgrp));
//sum counts
ag->natoms = rec->natoms + lig->natoms;
ag->nbonds = rec->nbonds + lig->nbonds;
ag->nangs = rec->nangs + lig->nangs;
ag->ntors = rec->ntors + lig->ntors;
ag->nimps = rec->nimps + lig->nimps;
//don't think we need actives yet
//ag->nactives = rec->nactives + lig->nactives;
//ag->nbact = rec->nbact + lig->nbact;
//ag->nangact = rec->nangact + lig->nangact;
//ag->ntoract = rec->ntoract + lig->ntoract;
//ag->nimpact = rec->nimpact + lig->nimpact;
//allocate first level
ag->atoms = (struct atom*) _mol_malloc (sizeof (struct atom) * ag->natoms);
ag->bonds = (struct atombond*) _mol_malloc (sizeof (struct atombond) * ag->nbonds);
ag->angs = (struct atomangle*) _mol_malloc (sizeof (struct atomangle) * ag->nangs);
ag->tors = (struct atomtorsion*) _mol_malloc (sizeof (struct atomtorsion) * ag->ntors);
ag->imps = (struct atomimproper*) _mol_malloc (sizeof (struct atomimproper) * ag->nimps);
//copy rec items
memcpy(ag->atoms, rec->atoms, sizeof(struct atom) * rec->natoms);
memcpy(ag->bonds, rec->bonds, sizeof(struct atombond) * rec->nbonds);
memcpy(ag->angs, rec->angs, sizeof(struct atomangle) * rec->nangs);
memcpy(ag->tors, rec->tors, sizeof(struct atomtorsion) * rec->ntors);
memcpy(ag->imps, rec->imps, sizeof(struct atomimproper) * rec->nimps);
//point to correct atoms
size_t atom_offset = ag->atoms - rec->atoms;
for (int i = 0; i < rec->nbonds; i++) {
ag->bonds[i].a0 += atom_offset;
ag->bonds[i].a1 += atom_offset;
}
for (int i = 0; i < rec->nangs; i++) {
ag->angs[i].a0 += atom_offset;
ag->angs[i].a1 += atom_offset;
ag->angs[i].a2 += atom_offset;
}
for (int i = 0; i < rec->ntors; i++) {
ag->tors[i].a0 += atom_offset;
ag->tors[i].a1 += atom_offset;
ag->tors[i].a2 += atom_offset;
ag->tors[i].a3 += atom_offset;
}
for (int i = 0; i < rec->nimps; i++) {
ag->imps[i].a0 += atom_offset;
ag->imps[i].a1 += atom_offset;
ag->imps[i].a2 += atom_offset;
ag->imps[i].a3 += atom_offset;
}
//point to atoms to correct bonds, angs, tors, imps
size_t bond_offset = ag->bonds - rec->bonds;
size_t ang_offset = ag->angs - rec->angs;
size_t imp_offset = ag->imps - rec->imps;
size_t tor_offset = ag->tors - rec->tors;
for (int i = 0; i < rec->natoms; i++) {
// struct atom local_atom = ag->atoms[i];
ag->atoms[i].name = strdup(rec->atoms[i].name);
ag->atoms[i].bonds = _mol_malloc( rec->atoms[i].nbonds*sizeof(struct atombond*));
memcpy(ag->atoms[i].bonds, rec->atoms[i].bonds, sizeof(struct atombond*) * rec->atoms[i].nbonds);
for (int j = 0; j < ag->atoms[i].nbonds; j++) {
ag->atoms[i].bonds[j] += bond_offset;
}
ag->atoms[i].angs = _mol_malloc( rec->atoms[i].nangs*sizeof(struct atomangle*));
memcpy(ag->atoms[i].angs, rec->atoms[i].angs, sizeof(struct atomangle*) * rec->atoms[i].nangs);
for (int j = 0; j < ag->atoms[i].nangs; j++) {
ag->atoms[i].angs[j] += ang_offset;
}
ag->atoms[i].tors = _mol_malloc( rec->atoms[i].ntors*sizeof(struct atomtorsion*));
memcpy(ag->atoms[i].tors, rec->atoms[i].tors, sizeof(struct atomtorsion*) * rec->atoms[i].ntors);
for (int j = 0; j < ag->atoms[i].ntors; j++) {
ag->atoms[i].tors[j] += tor_offset;
}
ag->atoms[i].imps = _mol_malloc( rec->atoms[i].nimps*sizeof(struct atomimproper*));
memcpy(ag->atoms[i].imps, rec->atoms[i].imps, sizeof(struct atomimproper*) * rec->atoms[i].nimps);
for (int j = 0; j < ag->atoms[i].nimps; j++) {
ag->atoms[i].imps[j] += imp_offset;
}
}
//copy lig items
memcpy(ag->atoms + rec->natoms, lig->atoms, sizeof(struct atom) * lig->natoms);
memcpy(ag->bonds + rec->nbonds, lig->bonds, sizeof(struct atombond) * lig->nbonds);
memcpy(ag->angs + rec->nangs, lig->angs, sizeof(struct atomangle) * lig->nangs);
memcpy(ag->tors + rec->ntors, lig->tors, sizeof(struct atomtorsion) * lig->ntors);
memcpy(ag->imps + rec->nimps, lig->imps, sizeof(struct atomimproper) * lig->nimps);
//point to correct atoms
atom_offset = ag->atoms - lig->atoms + rec->natoms;
for (int i = rec->nbonds; i < ag->nbonds; i++) {
ag->bonds[i].a0 += atom_offset;
ag->bonds[i].a1 += atom_offset;
}
for (int i = rec->nangs; i < ag->nangs; i++) {
ag->angs[i].a0 += atom_offset;
ag->angs[i].a1 += atom_offset;
ag->angs[i].a2 += atom_offset;
}
for (int i = rec->ntors; i < ag->ntors; i++) {
ag->tors[i].a0 += atom_offset;
ag->tors[i].a1 += atom_offset;
ag->tors[i].a2 += atom_offset;
ag->tors[i].a3 += atom_offset;
}
for (int i = rec->nimps; i < ag->nimps; i++) {
ag->imps[i].a0 += atom_offset;
ag->imps[i].a1 += atom_offset;
ag->imps[i].a2 += atom_offset;
ag->imps[i].a3 += atom_offset;
}
//point to atoms to correct bonds, angs, tors, imps
bond_offset = ag->bonds - lig->bonds + rec->nbonds;
ang_offset = ag->angs - lig->angs + rec->nangs;
imp_offset = ag->imps - lig->imps + rec->nimps;
tor_offset = ag->tors - lig->tors + rec->ntors;
for (int i = rec->natoms; i < ag->natoms; i++) {
// struct atom local_atom = ag->atoms[i];
ag->atoms[i].name = strdup(lig->atoms[i-(rec->natoms)].name);
ag->atoms[i].bonds = _mol_malloc( lig->atoms[i-(rec->natoms)].nbonds*sizeof(struct atombond*));
memcpy(ag->atoms[i].bonds, lig->atoms[i-(rec->natoms)].bonds, sizeof(struct atombond*) * lig->atoms[i-(rec->natoms)].nbonds);
for (int j = 0; j < ag->atoms[i].nbonds; j++) {
ag->atoms[i].bonds[j] += bond_offset;
}
ag->atoms[i].angs = _mol_malloc( lig->atoms[i-(rec->natoms)].nangs*sizeof(struct atomangle*));
memcpy(ag->atoms[i].angs, lig->atoms[i-(rec->natoms)].angs, sizeof(struct atomangle*) * lig->atoms[i-(rec->natoms)].nangs);
for (int j = 0; j < ag->atoms[i].nangs; j++) {
ag->atoms[i].angs[j] += ang_offset;
}
ag->atoms[i].tors = _mol_malloc( lig->atoms[i-(rec->natoms)].ntors*sizeof(struct atomtorsion*));
memcpy(ag->atoms[i].tors, lig->atoms[i-(rec->natoms)].tors, sizeof(struct atomtorsion*) * lig->atoms[i-(rec->natoms)].ntors);
for (int j = 0; j < ag->atoms[i].ntors; j++) {
ag->atoms[i].tors[j] += tor_offset;
}
ag->atoms[i].imps = _mol_malloc( lig->atoms[i-(rec->natoms)].nimps*sizeof(struct atomimproper*));
memcpy(ag->atoms[i].imps, lig->atoms[i-(rec->natoms)].imps, sizeof(struct atomimproper*) * lig->atoms[i-(rec->natoms)].nimps);
for (int j = 0; j < ag->atoms[i].nimps; j++) {
ag->atoms[i].imps[j] += imp_offset;
}
}
//copy into ryan's structure
// _mol_atom_group_copy_from_deprecated(ag);
return ag;
}
struct atomgrp *fullcopy_atomgrp(struct atomgrp *srcag)
{
int i;
int j;
struct atomgrp *destag =
(struct atomgrp *)_mol_calloc(1, sizeof(struct atomgrp));
destag->natoms = srcag->natoms;
destag->num_atom_types = srcag->num_atom_types;
destag->atoms =
(struct atom *)_mol_malloc(sizeof(struct atom) * destag->natoms);
memcpy(destag->atoms, srcag->atoms,
sizeof(struct atom) * destag->natoms);
//destag->nactives = srcag->nactives ;
//destag->activelist = _mol_malloc(destag->nactives*sizeof(int));
//for (i = 0; i < destag->nactives; i++)
//{
// destag->activelist[i]=srcag->activelist[i];
//}
destag->nbonds = srcag->nbonds;
if (srcag->nbonds > 0) {
destag->bonds =
_mol_malloc(destag->nbonds * sizeof(struct atombond));
memcpy(destag->bonds, srcag->bonds,
sizeof(struct atombond) * destag->nbonds);
}
//destag->nbact=srcag->nbact;
//destag->bact= _mol_malloc (destag->nbact*sizeof(struct atombond*));
//for (i = 0; i < destag->nbact; i++)
//{
// destag->bact[i]=srcag->bact[i];
//}
destag->nangs = srcag->nangs;
if (srcag->nangs > 0) {
destag->angs =
_mol_malloc(destag->nangs * sizeof(struct atomangle));
memcpy(destag->angs, srcag->angs,
sizeof(struct atomangle) * destag->nangs);
}
//destag->nangact=srcag->nangact;
//destag->angact= _mol_malloc (destag->nangact*sizeof(struct atomangle*));
//for (i = 0; i < destag->nangact; i++)
//{
// destag->angact[i]=srcag->angact[i];
//}
destag->ntors = srcag->ntors;
if (srcag->ntors > 0) {
destag->tors =
_mol_malloc(destag->ntors * sizeof(struct atomtorsion));
memcpy(destag->tors, srcag->tors,
sizeof(struct atomtorsion) * destag->ntors);
}
//destag->ntoract=srcag->ntoract;
//destag->toract= _mol_malloc (destag->ntoract*sizeof(struct atomtorsion*));
//for (i = 0; i < destag->ntoract; i++)
//{
// destag->toract[i]=srcag->toract[i];
//}
destag->nimps = srcag->nimps;
if (srcag->nimps > 0) {
destag->imps =
_mol_malloc(destag->nimps * sizeof(struct atomimproper));
memcpy(destag->imps, srcag->imps,
sizeof(struct atomimproper) * destag->nimps);
}
//destag->nimpact=srcag->nimpact;
//destag->impact= _mol_malloc (destag->nimpact*sizeof(struct atomimproper*));
//for (i = 0; i < destag->nimpact; i++)
//{
// destag->impact[i]=srcag->impact[i];
//}
//point to correct atoms
for (i = 0; i < destag->nbonds; i++) {
ptrdiff_t a0_offset = destag->bonds[i].a0 - srcag->atoms;
ptrdiff_t a1_offset = destag->bonds[i].a1 - srcag->atoms;
destag->bonds[i].a0 = destag->atoms + a0_offset;
destag->bonds[i].a1 = destag->atoms + a1_offset;
}
for (i = 0; i < destag->nangs; i++) {
ptrdiff_t a0_offset = destag->angs[i].a0 - srcag->atoms;
ptrdiff_t a1_offset = destag->angs[i].a1 - srcag->atoms;
ptrdiff_t a2_offset = destag->angs[i].a2 - srcag->atoms;
destag->angs[i].a0 = destag->atoms + a0_offset;
destag->angs[i].a1 = destag->atoms + a1_offset;
destag->angs[i].a2 = destag->atoms + a2_offset;
}
for (i = 0; i < destag->ntors; i++) {
ptrdiff_t a0_offset = destag->tors[i].a0 - srcag->atoms;
ptrdiff_t a1_offset = destag->tors[i].a1 - srcag->atoms;
ptrdiff_t a2_offset = destag->tors[i].a2 - srcag->atoms;
ptrdiff_t a3_offset = destag->tors[i].a3 - srcag->atoms;
destag->tors[i].a0 = destag->atoms + a0_offset;
destag->tors[i].a1 = destag->atoms + a1_offset;
destag->tors[i].a2 = destag->atoms + a2_offset;
destag->tors[i].a3 = destag->atoms + a3_offset;
}
for (i = 0; i < destag->nimps; i++) {
ptrdiff_t a0_offset = destag->imps[i].a0 - srcag->atoms;
ptrdiff_t a1_offset = destag->imps[i].a1 - srcag->atoms;
ptrdiff_t a2_offset = destag->imps[i].a2 - srcag->atoms;
ptrdiff_t a3_offset = destag->imps[i].a3 - srcag->atoms;
destag->imps[i].a0 = destag->atoms + a0_offset;
destag->imps[i].a1 = destag->atoms + a1_offset;
destag->imps[i].a2 = destag->atoms + a2_offset;
destag->imps[i].a3 = destag->atoms + a3_offset;
}
//point to atoms to correct bonds, angs, tors, imps
for (i = 0; i < destag->natoms; i++) {
// struct atom local_atom = destag->atoms[i];
destag->atoms[i].name = strdup(srcag->atoms[i].name);
if (srcag->atoms[i].residue_name != NULL) {
destag->atoms[i].residue_name =
strdup(srcag->atoms[i].residue_name);
}
destag->atoms[i].ftype_name =
strdup(srcag->atoms[i].ftype_name);
if (srcag->nbonds > 0) {
destag->atoms[i].bonds =
_mol_malloc(destag->atoms[i].nbonds *
sizeof(struct atombond *));
memcpy(destag->atoms[i].bonds, srcag->atoms[i].bonds,
sizeof(struct atombond *) *
destag->atoms[i].nbonds);
for (j = 0; j < destag->atoms[i].nbonds; j++) {
ptrdiff_t bond_offset =
destag->atoms[i].bonds[j] - srcag->bonds;
destag->atoms[i].bonds[j] =
destag->bonds + bond_offset;
}
}
if (srcag->nangs > 0) {
destag->atoms[i].angs =
_mol_malloc(destag->atoms[i].nangs *
sizeof(struct atomangle *));
memcpy(destag->atoms[i].angs, srcag->atoms[i].angs,
sizeof(struct atomangle *) *
destag->atoms[i].nangs);
for (j = 0; j < destag->atoms[i].nangs; j++) {
ptrdiff_t ang_offset =
destag->atoms[i].angs[j] - srcag->angs;
destag->atoms[i].angs[j] =
destag->angs + ang_offset;
}
}
if (srcag->ntors > 0) {
destag->atoms[i].tors =
_mol_malloc(destag->atoms[i].ntors *
sizeof(struct atomtorsion *));
memcpy(destag->atoms[i].tors, srcag->atoms[i].tors,
sizeof(struct atomtorsion *) *
destag->atoms[i].ntors);
for (j = 0; j < destag->atoms[i].ntors; j++) {
ptrdiff_t tor_offset =
destag->atoms[i].tors[j] - srcag->tors;
destag->atoms[i].tors[j] =
destag->tors + tor_offset;
}
}
if (srcag->nimps > 0) {
destag->atoms[i].imps =
_mol_malloc(destag->atoms[i].nimps *
sizeof(struct atomimproper *));
memcpy(destag->atoms[i].imps, srcag->atoms[i].imps,
sizeof(struct atomimproper *) *
destag->atoms[i].nimps);
for (j = 0; j < destag->atoms[i].nimps; j++) {
ptrdiff_t imp_offset =
destag->atoms[i].imps[j] - srcag->imps;
destag->atoms[i].imps[j] =
destag->imps + imp_offset;
}
}
}
//destag->nres=srcag->nres;
//destag->iares=srcag->iares;
//destag->idres=srcag->idres;
//destag->is_psf_read=srcag->is_psf_read;
return destag;
}
