parm_dock.c

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

  get_parameter
  (
    (void *) &score->contact.flag,
    &parm, Boolean, "contact_score",
    "no",
    score->flag &&
      (!score->grid.flag || (score->grid.version >= 4.0))
  );

  score->type[CONTACT].flag = score->contact.flag;
  strcpy (score->type[CONTACT].name, "contact");
  strcpy (score->type[CONTACT].abbrev, "cnt");

  get_parameter
  (
    (void *) &score->contact.distance,
    &parm, Real, "contact_cutoff_distance",
    score->contact.flag && (!score->grid.flag || score->intra_flag) ?
      "4.5" : "0.0",
    score->contact.flag && (!score->grid.flag || score->intra_flag)
  );

  get_parameter
  (
    (void *) &score->contact.clash_overlap,
    &parm, Real, "contact_clash_overlap",
    score->contact.flag && (score->intra_flag || !score->grid.flag)
      ? "0.75" : "0.0",
    score->contact.flag && (score->intra_flag || !score->grid.flag)
  );

  get_parameter
  (
    (void *) &score->contact.clash_penalty,
    &parm, Real, "contact_clash_penalty",
    score->contact.flag ? "50" : "0",
    score->contact.flag
  );

  get_parameter
  (
    (void *) &score->chemical.flag,
    &parm, Boolean, "chemical_score",
    "no",
    score->flag &&
      (!score->grid.flag || (score->grid.version >= 4.0))
  );

  label->chemical.flag =
    label->chemical.flag || score->chemical.flag;

  score->type[CHEMICAL].flag = score->chemical.flag;
  strcpy (score->type[CHEMICAL].name, "chemical");
  strcpy (score->type[CHEMICAL].abbrev, "chm");

  get_parameter
  (
    (void *) &score->energy.flag,
    &parm, Boolean, "energy_score",
    "no",
    score->flag
  );

  score->type[ENERGY].flag = score->energy.flag;
  strcpy (score->type[ENERGY].name, "energy");
  strcpy (score->type[ENERGY].abbrev, "nrg");

  get_parameter
  (
    (void *) &score->energy.distance,
    &parm, Real, "energy_cutoff_distance",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag) ? "10.0" : "0.0",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag)
  );

  get_parameter
  (
    (void *) &score->energy.distance_dielectric,
    &parm, Boolean, "distance_dielectric",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag) ? "yes" : "no",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag)
  );

  get_parameter
  (
    (void *) &score->energy.dielectric_factor,
    &parm, Real, "dielectric_factor",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag) ? "4.0" : "0.0",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag)
  );

  get_parameter
  (
    (void *) &score->energy.attractive_exponent,
    &parm, Integer, "attractive_exponent",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag) ? "6" : "0",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag)
  );

  get_parameter
  (
    (void *) &score->energy.repulsive_exponent,
    &parm, Integer, "repulsive_exponent",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag) ? "12" : "0",
    (!score->grid.flag || score->intra_flag) &&
      (score->energy.flag || score->chemical.flag)
  );

  get_parameter
  (
    (void *) &score->energy.atom_model,
    &parm, Character, "atom_model",
    score->energy.flag || score->chemical.flag ? "UNITED all" : "0",
    score->energy.flag || score->chemical.flag
  );

  get_parameter
  (
    (void *) &score->energy.scale_vdw,
    &parm, Real, "vdw_scale",
    score->energy.flag || score->chemical.flag ? "1" : "0",
    score->energy.flag || score->chemical.flag
  );

  get_parameter
  (
    (void *) &score->energy.scale_electro,
    &parm, Real, "electrostatic_scale",
    score->energy.flag || score->chemical.flag ? "1" : "0",
    score->energy.flag || score->chemical.flag
  );

  get_parameter
  (
    (void *) &score->energy.decomp_flag,
    &parm, Boolean, "output_atom_scores",
    "no",
    FALSE
  );

  get_parameter
  (
    (void *) &score->rmsd.flag,
    &parm, Boolean, "rmsd_score",
    "no",
    score->inter_flag && !score->intra_flag &&
      !score->grid.flag && !orient->flag
  );

  score->type[RMSD].flag = score->rmsd.flag;
  strcpy (score->type[RMSD].name, "rmsd");
  strcpy (score->type[RMSD].abbrev, "rmsd");

  if
  (
    score->inter_flag &&
    !score->contact.flag &&
    !score->chemical.flag &&
    !score->energy.flag &&
    !score->rmsd.flag
  )
    exit (fprintf (global.outfile,
      "ERROR get_parameters: no intermolecular scoring options selected.\n"));

  for (i = 1; i < SCORE_TOTAL; i++)
  {
    sprintf (parameter_name, "%s_maximum", score->type[i].name);

    get_parameter
    (
      (void *) &score->type[i].maximum,
      &parm, Real, parameter_name,
      "0",
      score->type[i].flag &&
        ((dock->write_orients && !dock->rank_orients) ||
        (!dock->multiple_orients &&
          dock->multiple_ligands && !dock->rank_ligands))
    );

    sprintf (parameter_name, "%s_size_penalty", score->type[i].name);

    get_parameter
    (
      (void *) &score->type[i].size_penalty,
      &parm, Real, parameter_name,
      "0",
      score->type[i].flag && dock->rank_ligands && (i != RMSD)
    );
  }

  get_parameter
  (
    (void *) &score->rmsd_override,
    &parm, Real, "rmsd_override",
    "0.0",
    score->flag && !dock->rank_ligands &&
      dock->write_orients && !dock->rank_orients
  );


  if (score->minimize.flag || (global.output_volume == 'v'))
    fprintf (global.outfile, 
      "\n______________Minimization_Parameters_____________\n");

  for (i = 1, j = 0; i < SCORE_TOTAL; i++)
  {
    sprintf (parameter_name, "%s_minimize", score->type[i].name);

    get_parameter
    (
      (void *) &score->type[i].minimize,
      &parm, Boolean, parameter_name,
      "no",
      score->type[i].flag && score->minimize.flag
    );

    if (score->type[i].minimize == TRUE) j++;
  }

  if
  (
    (score->minimize.flag == TRUE) &&
    ((j == 0) ||
    ((score->inter_flag == FALSE) &&
      (label->flex.minimize_flag == FALSE)))
  )
    exit (fprintf (global.outfile,
      "ERROR get_parameters: no minimization selected\n"));

  get_parameter
  (
    (void *) &score->minimize.translation,
    &parm, Real, "initial_translation",
    score->inter_flag && score->minimize.flag ? "1.0" : "0.0",
    score->inter_flag && score->minimize.flag
  );

  get_parameter
  (
    (void *) &score->minimize.rotation,
    &parm, Real, "initial_rotation",
    score->inter_flag && score->minimize.flag ? "0.1" : "0.0",
    score->inter_flag && score->minimize.flag
  );

  get_parameter
  (
    (void *) &score->minimize.torsion,
    &parm, Real, "initial_torsion",
    label->flex.minimize_flag ? "10.0" : "0.0",
    label->flex.minimize_flag
  );

  get_parameter
  (
    (void *) &score->minimize.iteration,
    &parm, Integer, "maximum_iterations",
    score->minimize.flag ? "100" : "0",
    score->minimize.flag
  );

  if ((score->minimize.flag == TRUE) && (score->minimize.iteration < 1))
    exit (fprintf (global.outfile,
      "ERROR get_parameters: maximum_iterations < 1\n"));

  for (i = 1; i < SCORE_TOTAL; i++)
  {
    sprintf (parameter_name, "%s_convergence", score->type[i].name);

    get_parameter
    (
      (void *) &score->type[i].convergence,
      &parm, Real, parameter_name,
      score->type[i].minimize && (score->minimize.iteration > 1) ? "0.1" : "0",
      score->type[i].minimize && (score->minimize.iteration > 1)
    );
  }

  get_parameter
  (
    (void *) &score->minimize.cycle,
    &parm, Integer, "maximum_cycles",
    score->minimize.flag ? "1" : "0",
    score->minimize.flag
  );

  if ((score->minimize.flag == TRUE) && (score->minimize.cycle < 1))
    exit (fprintf (global.outfile,
      "ERROR get_parameters: maximum_cycles < 1\n"));

  get_parameter
  (
    (void *) &score->minimize.cycle_converge,
    &parm, Real, "cycle_convergence",
    (score->minimize.cycle > 1) ? "1.0" : "0",
    score->minimize.cycle > 1
  );

  if ((score->minimize.cycle > 1) && (score->minimize.cycle_converge <= 0))
    exit (fprintf (global.outfile,
      "ERROR get_parameters: cycle_convergence <= 0\n"));

  for (i = 1; i < SCORE_TOTAL; i++)
  {
    sprintf (parameter_name, "%s_termination", score->type[i].name);

    get_parameter
    (
      (void *) &score->type[i].termination,
      &parm, Real, parameter_name,
      score->type[i].minimize && (score->minimize.cycle > 1) ? "1.0" : "0",
      score->type[i].minimize && (score->minimize.cycle > 1)
    );
  }


  if (label->chemical.screen.flag || (global.output_volume == 'v'))
    fprintf (global.outfile,
      "\n____________Chemical_Screen_Parameters____________\n");

  get_parameter
  (
    (void *) &label->chemical.screen.construct_flag,
    &parm, Boolean, "construct_screen",
    "no",
    label->chemical.screen.flag
  );

  get_parameter
  (
    (void *) &label->chemical.screen.process_flag,
    &parm, Boolean, "screen_ligands",
    label->chemical.screen.flag ?
      (label->chemical.screen.construct_flag ? "no" : "yes") : "no",
    label->chemical.screen.flag && !label->chemical.screen.construct_flag
  );

  if (label->chemical.screen.flag &&
    !label->chemical.screen.process_flag &&
    !label->chemical.screen.construct_flag)
    exit (fprintf (global.outfile,
      "ERROR get_parameters: No chemical screen options selected!\n"));

  get_parameter
  (
    (void *) &label->chemical.screen.pharmaco_flag,
    &parm, Boolean, "pharmacophore_screen",
    "no",
    label->chemical.screen.process_flag
  );

  if (label->chemical.screen.pharmaco_flag)
    orient->match.chemical_flag = TRUE;

  get_parameter
  (
    (void *) &label->chemical.screen.similar_flag,
    &parm, Boolean, "similarity_screen",
    label->chemical.screen.process_flag ?
      (label->chemical.screen.pharmaco_flag ? "no" : "yes") : "no",
    label->chemical.screen.process_flag &&
      !label->chemical.screen.pharmaco_flag
  );

  get_parameter
  (
    (void *) &label->chemical.screen.fold_flag,
    &parm, Boolean, "fold_keys",
    "yes",
    FALSE
  );

  if (label->chemical.screen.process_flag &&
    !label->chemical.screen.pharmaco_flag &&
    !label->chemical.screen.similar_flag)
    exit (fprintf (global.outfile,
      "ERROR get_parameters: If screen_ligands selected, then either\n"
      "  pharmacophore_screen or similarity_screen must also be selected!\n"));

  get_parameter
  (
    (void *) &label->chemical.screen.dissimilar_maximum,
    &parm, Real, "dissimilarity_maximum",
    "0.25",
    label->chemical.screen.similar_flag
  );

  get_parameter
  (
    (void *) &label->chemical.screen.distance_minimum,
    &parm, Real, "distance_begin",
    label->chemical.screen.flag ? "2" : "0",
    label->chemical.screen.flag
  );

  get_parameter
  (
    (void *) &label->chemical.screen.distance_maximum,
    &parm, Real, "distance_end",
    label->chemical.screen.flag ? "17" : "0",
    label->chemical.screen.flag
  );

  get_parameter
  (
    (void *) &label->chemical.screen.distance_interval,
    &parm, Real, "distance_interval",
    label->chemical.screen.flag ? "0.5" : "0",
    label->chemical.screen.flag
  );

  label->chemical.screen.interval_total = (int)
    ((label->chemical.screen.distance_maximum -
    label->chemical.screen.distance_minimum) /
    label->chemical.screen.distance_interval) + 2;

  if (label->chemical.screen.interval_total > MASK_LENGTH)
    exit (fprintf (global.outfile,
      "ERROR get_parameters: Chemical screen intervals > %d!\n",
      MASK_LENGTH - 2));


  if (dock->parallel.flag || (global.output_volume == 'v'))
    fprintf (global.outfile,
      "\n______________Parallel_Job_Parameters_____________\n");

  get_parameter
  (
    (void *) &dock->parallel.server,
    &parm, Boolean, "parallel_server",
    "no",
    dock->parallel.flag
  );

/*
* Make sure only a single type of scoring has been requested
* 10/96 te
*/
  if (dock->parallel.server)
  {
    for (i = j = 0; i < SCORE_TOTAL; i++)
      if (score->type[i].flag) j++;

    if (j != 1)
      exit (fprintf (global.outfile,
        "ERROR get_parameters: "
        "Parallel job server must perform single type of scoring.\n"));
  }

  get_parameter
  (
    (void *) &dock->parallel.server_name,
    &parm, String, "server_name",
    dock->parallel.server ? global.job_name : "server",
    dock->parallel.flag
  );

  get_parameter
  (
    (void *) &dock->parallel.client_total,
    &parm, Integer, "client_total",
    dock->parallel.server ? "5" : (dock->parallel.flag ? "1" : "0"),
    dock->parallel.server
  );

  if (dock->parallel.flag)
  {
    if (dock->parallel.client_total < 1)
      exit (fprintf (global.outfile,
        "ERROR get_parameters: Inappropriate value for client_total.\n"));

    ecalloc
    (
      (void **) &dock->parallel.client_name,
      dock->parallel.client_total,
      sizeof (STRING20),
      "parallel client names",
      global.outfile
    );

    for (i = 0; i < dock->parallel.client_total; i++)                 
    {
      if (dock->parallel.server)
      {
        sprintf (parameter_name, "client_name_%d", i + 1);
        sprintf (parameter_value, "client%d", i + 1);
      }

      else
      {
        strcpy (parameter_name, "client_name");
        strcpy (parameter_value, global.job_name);
      }

      get_parameter
      (
        (void *) &dock->parallel.client_name[i],
        &parm, String, parameter_name,
        parameter_value,
        TRUE
      );
    }
  }


  if (dock->multiple_ligands || (global.output_volume == 'v'))
    fprintf (global.outfile,
      "\n____________Multiple_Ligand_Parameters____________\n");
                                                                      
  get_parameter
  (
    (void *) &dock->max_ligands,
    &parm, Integer, "ligands_maximum",
    dock->multiple_ligands ? "1000" : "1",
    dock->multiple_ligands
  );

  get_parameter
  (
    (void *) &dock->initial_skip,
    &parm, Integer, "initial_skip",
    "0",
    dock->multiple_ligands
  );

  get_parameter
  (
    (void *) &dock->interval_skip,
    &parm, Integer, "interval_skip",
    "0",
    dock->multiple_ligands
  );

  get_parameter
  (
    (void *) &dock->min_heavies,
    &parm, Integer, "heavy_atoms_minimum",
    "0",
    dock->multiple_ligands
  );

  get_parameter
  (