mol.c

来自「最经典的分子对结软件」· C语言 代码 · 共 2,539 行 · 第 1/5 页

/*                                                                    */
/*                        Copyright UCSF, 1997                        */
/*                                                                    */

/*
Written by Todd Ewing
10/95
*/
#include <stdio.h>
#include "define.h"
#include "utility.h"
#include "global.h"
#include "search.h"
#include "mol.h"
#include "vector.h"

/* ///////////////////////////////////////////////////////////// */

void allocate_molecule (MOLECULE *molecule)
{
  allocate_info		(molecule);
  allocate_transform	(molecule);
  allocate_score	(&molecule->score);
  allocate_atoms	(molecule);
  allocate_bonds	(molecule);
  allocate_torsions	(molecule);
  allocate_substs	(molecule);
  allocate_segments	(molecule);
  allocate_layers	(molecule);
  allocate_sets		(molecule);
  allocate_keys		(molecule);
}

/* //////////////////////////////////////////////////////////// */

void reset_molecule (MOLECULE *molecule)
{
  reset_info		(molecule);
  reset_transform 	(molecule);
  reset_score		(&molecule->score);
  reset_atoms		(molecule);
  reset_bonds		(molecule);
  reset_torsions	(molecule);
  reset_substs		(molecule);
  reset_segments	(molecule);
  reset_layers		(molecule);
  reset_sets		(molecule);
  reset_keys		(molecule);
}

/* //////////////////////////////////////////////////////////// */

void free_molecule (MOLECULE *molecule)
{
  free_info		(molecule);
  free_atoms		(molecule);
  free_bonds		(molecule);
  free_torsions		(molecule);
  free_substs		(molecule);
  free_segments		(molecule);
  free_layers		(molecule);
  free_sets		(molecule);
  free_keys		(molecule);
}

/* ///////////////////////////////////////////////////////////// */

void reallocate_molecule (MOLECULE *molecule)
{
  reallocate_atoms	(molecule);
  reallocate_bonds	(molecule);
  reallocate_torsions	(molecule);
  reallocate_substs	(molecule);
  reallocate_segments	(molecule);
  reallocate_layers	(molecule);
  reallocate_sets	(molecule);
  reallocate_keys	(molecule);
}

/* ///////////////////////////////////////////////////////////// */

void copy_molecule (MOLECULE *copy, MOLECULE *original)
{
  copy_info		(copy, original);
  copy_transform	(copy, original);
  copy_score		(&copy->score, &original->score);
  copy_atoms		(copy, original);
  copy_bonds		(copy, original);
  copy_torsions		(copy, original);
  copy_substs		(copy, original);
  copy_segments		(copy, original);
  copy_layers		(copy, original);
  copy_sets		(copy, original);
  copy_keys		(copy, original);
}

/* ///////////////////////////////////////////////////////////// */

void save_molecule (MOLECULE *molecule, FILE *file)
{
  efwrite (&molecule->max, sizeof (ARRAYSIZE), 1, file);
  efwrite (&molecule->total, sizeof (ARRAYSIZE), 1, file);

  save_info		(molecule, file);
  save_transform	(molecule, file);
  save_score		(&molecule->score, file);
  save_atoms		(molecule, file);
  save_bonds		(molecule, file);
  save_torsions		(molecule, file);
  save_substs		(molecule, file);
  save_segments		(molecule, file);
  save_layers		(molecule, file);
  save_sets		(molecule, file);
  save_keys		(molecule, file);
}

/* ///////////////////////////////////////////////////////////// */

void load_molecule (MOLECULE *molecule, FILE *file)
{
  free_molecule (molecule);

  efread (&molecule->max, sizeof (ARRAYSIZE), 1, file);
  efread (&molecule->total, sizeof (ARRAYSIZE), 1, file);

  allocate_molecule	(molecule);

  load_info		(molecule, file);
  load_transform	(molecule, file);
  load_score		(&molecule->score, file);
  load_atoms		(molecule, file);
  load_bonds		(molecule, file);
  load_torsions		(molecule, file);
  load_substs		(molecule, file);
  load_segments		(molecule, file);
  load_layers		(molecule, file);
  load_sets		(molecule, file);
  load_keys		(molecule, file);
}

/* ///////////////////////////////////////////////////////////// */

int get_identifier (void)
{
  static int identifier = 0;
  return ++identifier;
}

/* ///////////////////////////////////////////////////////////// */
/* ///////////////////////////////////////////////////////////// */

void allocate_info (MOLECULE *molecule)
{
  reset_info (molecule);
}

/* ///////////////////////////////////////////////////////////// */

void reset_info (MOLECULE *molecule)
{
  efree ((void **) &molecule->info.name);
  efree ((void **) &molecule->info.comment);
  efree ((void **) &molecule->info.molecule_type);
  efree ((void **) &molecule->info.charge_type);
  efree ((void **) &molecule->info.status_bits);
  efree ((void **) &molecule->info.source_file);

  memset (&molecule->info, 0, sizeof (INFO));
  molecule->info.input_id = NEITHER;
}

/* ///////////////////////////////////////////////////////////// */

void free_info (MOLECULE *molecule)
{
  efree ((void **) &molecule->info.name);
  efree ((void **) &molecule->info.comment);
  efree ((void **) &molecule->info.molecule_type);
  efree ((void **) &molecule->info.charge_type);
  efree ((void **) &molecule->info.status_bits);
  efree ((void **) &molecule->info.source_file);

  memset (&molecule->info, 0, sizeof (INFO));
  molecule->info.input_id = NEITHER;
}

/* ///////////////////////////////////////////////////////////// */

void copy_info (MOLECULE *copy, MOLECULE *original)
{
  copy->info.input_id = original->info.input_id;
  copy->info.output_id = original->info.output_id;

  vstrcpy (&copy->info.name, original->info.name);
  vstrcpy (&copy->info.comment, original->info.comment);
  vstrcpy (&copy->info.molecule_type, original->info.molecule_type);
  vstrcpy (&copy->info.charge_type, original->info.charge_type);
  vstrcpy (&copy->info.status_bits, original->info.status_bits);
  vstrcpy (&copy->info.source_file, original->info.source_file);

  copy->info.source_position = original->info.source_position;
  copy->info.file_position = original->info.file_position;

  copy->info.allocated = original->info.allocated;
  copy->info.assign_chem = original->info.assign_chem;
  copy->info.assign_flex = original->info.assign_flex;
  copy->info.assign_vdw = original->info.assign_vdw;
}

/* ///////////////////////////////////////////////////////////// */

void save_info (MOLECULE *molecule, FILE *file)
{
  efwrite (&molecule->info.input_id, sizeof (int), 1, file);
  efwrite (&molecule->info.output_id, sizeof (int), 1, file);

  save_string (&molecule->info.name, file);
  save_string (&molecule->info.comment, file);
  save_string (&molecule->info.molecule_type, file);
  save_string (&molecule->info.charge_type, file);
  save_string (&molecule->info.status_bits, file);
  save_string (&molecule->info.source_file, file);

  efwrite (&molecule->info.source_position, sizeof (long), 1, file);
  efwrite (&molecule->info.file_position, sizeof (long), 1, file);

  efwrite (&molecule->info.allocated, sizeof (int), 1, file);
  efwrite (&molecule->info.assign_chem, sizeof (int), 1, file);
  efwrite (&molecule->info.assign_vdw, sizeof (int), 1, file);
  efwrite (&molecule->info.assign_flex, sizeof (int), 1, file);
}

/* ///////////////////////////////////////////////////////////// */

void load_info (MOLECULE *molecule, FILE *file)
{
  efread (&molecule->info.input_id, sizeof (int), 1, file);
  efread (&molecule->info.output_id, sizeof (int), 1, file);

  load_string (&molecule->info.name, file);
  load_string (&molecule->info.comment, file);
  load_string (&molecule->info.molecule_type, file);
  load_string (&molecule->info.charge_type, file);
  load_string (&molecule->info.status_bits, file);
  load_string (&molecule->info.source_file, file);

  efread (&molecule->info.source_position, sizeof (long), 1, file);
  efread (&molecule->info.file_position, sizeof (long), 1, file);

  efread (&molecule->info.allocated, sizeof (int), 1, file);
  efread (&molecule->info.assign_chem, sizeof (int), 1, file);
  efread (&molecule->info.assign_vdw, sizeof (int), 1, file);
  efread (&molecule->info.assign_flex, sizeof (int), 1, file);
}

/* ///////////////////////////////////////////////////////////// */
/* ///////////////////////////////////////////////////////////// */

void allocate_transform (MOLECULE *molecule)
{
  reset_transform (molecule);
}

/* ///////////////////////////////////////////////////////////// */

void reset_transform (MOLECULE *molecule)
{
  memset (&molecule->transform, 0, sizeof (TRANSFORM));
  molecule->transform.refl_flag = NEITHER;
  molecule->transform.tors_flag = NEITHER;
  molecule->transform.anchor_segment = NEITHER;
  molecule->transform.anchor_atom = NEITHER;
}

/* ///////////////////////////////////////////////////////////// */

void copy_transform (MOLECULE *copy, MOLECULE *original)
{
  copy->transform.flag = original->transform.flag;
  copy->transform.trans_flag = original->transform.trans_flag;
  copy->transform.rot_flag = original->transform.rot_flag;
  copy->transform.refl_flag = original->transform.refl_flag;
  copy->transform.tors_flag = original->transform.tors_flag;

  copy->transform.translate[0] = original->transform.translate[0];
  copy->transform.translate[1] = original->transform.translate[1];
  copy->transform.translate[2] = original->transform.translate[2];

  copy->transform.rotate[0] = original->transform.rotate[0];
  copy->transform.rotate[1] = original->transform.rotate[1];
  copy->transform.rotate[2] = original->transform.rotate[2];

  copy->transform.conf_total = original->transform.conf_total;
  copy->transform.anchor_segment = original->transform.anchor_segment;
  copy->transform.anchor_atom = original->transform.anchor_atom;
  copy->transform.active_layer = original->transform.active_layer;
  copy->transform.fold_flag = original->transform.fold_flag;

  copy->transform.com[0] = original->transform.com[0];
  copy->transform.com[1] = original->transform.com[1];
  copy->transform.com[2] = original->transform.com[2];

  copy->transform.rmsd = original->transform.rmsd;
  copy->transform.heavy_total = original->transform.heavy_total;
}

/* ///////////////////////////////////////////////////////////// */

void save_transform (MOLECULE *molecule, FILE *file)
{
  efwrite (&molecule->transform, sizeof (TRANSFORM), 1, file);
}

/* ///////////////////////////////////////////////////////////// */

void load_transform (MOLECULE *molecule, FILE *file)
{
  efread (&molecule->transform, sizeof (TRANSFORM), 1, file);
}

/* ///////////////////////////////////////////////////////////// */
/* ///////////////////////////////////////////////////////////// */

void allocate_score (MOL_SCORE *score)
{
  reset_score (score);
}

/* ///////////////////////////////////////////////////////////// */

void reset_score (MOL_SCORE *score)
{
  score->type = 0;
  score->bumpcount = 0;

  reset_score_parts (&score->intra);
  reset_score_parts (&score->inter);

  score->inter.total = INITIAL_SCORE;
  score->total = INITIAL_SCORE;
}

/* ///////////////////////////////////////////////////////////// */

void reset_score_parts (SCORE_PART *part)
{
  part->current_flag = FALSE;
  part->total = 0;
  part->electro = 0;
  part->vdw = 0;
}

/* ///////////////////////////////////////////////////////////// */

void copy_score (MOL_SCORE *copy, MOL_SCORE *original)
{
  copy->type = original->type;
  copy->bumpcount = original->bumpcount;
  copy->intra = original->intra;
  copy->inter = original->inter;
  copy->total = original->total;
}

/* ///////////////////////////////////////////////////////////// */

void add_score_parts (SCORE_PART *sum, SCORE_PART *increment)
{
  sum->vdw += increment->vdw;
  sum->electro += increment->electro;
  sum->total += increment->total;
}

/* ///////////////////////////////////////////////////////////// */

void save_score (MOL_SCORE *score, FILE *file)
{
  efwrite (score, sizeof (MOL_SCORE), 1, file);
}

/* ///////////////////////////////////////////////////////////// */

void load_score (MOL_SCORE *score, FILE *file)
{
  efread (score, sizeof (MOL_SCORE), 1, file);
}

/* ///////////////////////////////////////////////////////////// */
/* ///////////////////////////////////////////////////////////// */

void allocate_atoms (MOLECULE *molecule)
{
  int i;

  if (molecule->max.atoms > 0)
  {
    ecalloc
    (
      (void **) &molecule->atom,
      molecule->max.atoms,
      sizeof (ATOM),
      molecule->info.name,
      global.outfile
    );

    ecalloc
    (
      (void **) &molecule->coord,
      molecule->max.atoms,
      sizeof (XYZ),
      molecule->info.name,
      global.outfile
    );

    for (i = 0; i < molecule->total.atoms; i++)
      reset_atom (&molecule->atom[i]);
  }
}

/* ///////////////////////////////////////////////////////////// */

void allocate_atom_neighbors (ATOM *atom)
{
  if (atom->neighbor_max > 0)
  {
    ecalloc
    (
      (void **) &atom->neighbor,
      atom->neighbor_max,
      sizeof (LINK),
      "atom neighbors",
      global.outfile
    );

    reset_atom_neighbors (atom);
  }
}

/* ///////////////////////////////////////////////////////////// */

void reset_atoms (MOLECULE *molecule)
{
  int i;

  if (molecule->max.atoms > 0)
  {
    for (i = 0; i < molecule->max.atoms; i++)
      reset_atom (&molecule->atom[i]);

    memset (molecule->coord, 0, molecule->max.atoms * sizeof (XYZ));
  }

  molecule->total.atoms = 0;
}

/* ///////////////////////////////////////////////////////////// */

void reset_atom (ATOM *atom)
{
  efree ((void **) &atom->name);
  efree ((void **) &atom->type);

  atom->number = 0;
  atom->subst_id = 0;
  atom->chem_id = 0;
  atom->vdw_id = 0;
  atom->heavy_flag = FALSE;
  atom->centrality = NEITHER;
  atom->segment_id = NEITHER;
  atom->flag = 0;
  atom->charge = 0;

  reset_atom_neighbors (atom);
}

/* ///////////////////////////////////////////////////////////// */

void reset_atom_neighbors (ATOM *atom)
{
  int i;

  for (i = 0; i < atom->neighbor_max; i++)
  {
    atom->neighbor[i].id = NEITHER;
    atom->neighbor[i].bond_id = NEITHER;
    atom->neighbor[i].out_flag = FALSE;
  }

  atom->neighbor_total = 0;
}

/* ///////////////////////////////////////////////////////////// */

void free_atoms (MOLECULE *molecule)
{
  int i;

  for (i = 0; i < molecule->max.atoms; i++)
    free_atom (&molecule->atom[i]);

  efree ((void **) &molecule->atom);
  efree ((void **) &molecule->coord);
  molecule->max.atoms = 0;
}

/* ///////////////////////////////////////////////////////////// */

void free_atom (ATOM *atom)
{