Exemplo n.º 1
0
coords_struct* alloc_coords(global_options_struct *global_options)
{ 
    coords_struct *coords_data = (struct _coords_struct*) malloc(global_options->NSTRUCTURES*sizeof(coords_struct));
    if (coords_data == NULL)
    {
      malloc_failure_char("alloc_coords", "coords_data", global_options->NSTRUCTURES*sizeof(coords_struct));
      return NULL;
    }
    int i,j;
    
    for (i=0; i<global_options->NSTRUCTURES; ++i)
    {
      coords_data[i].mem_allocated = 0;
      coords_data[i].x_coord = (double *) malloc(global_options->NATOMS*sizeof(double));
      if (coords_data[i].x_coord == NULL)
      {
        malloc_failure_char("alloc_coords", "coords_data->x_coord",(global_options->NATOMS*sizeof(double)));
        return NULL;
      }
      coords_data[i].mem_allocated+=(global_options->NATOMS*sizeof(double));
      coords_data[i].y_coord = (double *) malloc(global_options->NATOMS*sizeof(double));
      if (coords_data[i].y_coord == NULL)
      {
        malloc_failure_char("alloc_coords", "coords_data->y_coord",(global_options->NATOMS*sizeof(double)));
        return NULL;
      }
      coords_data[i].mem_allocated+=(global_options->NATOMS*sizeof(double));
      coords_data[i].z_coord = (double *) malloc(global_options->NATOMS*sizeof(double));
      if (coords_data[i].z_coord == NULL)
      {
	      malloc_failure_char("alloc_coords", "coords_data->z_coord",(global_options->NATOMS*sizeof(double)));
        return NULL;
      }
      coords_data[i].mem_allocated+=(global_options->NATOMS*sizeof(double));
      
      // If fitting forces, allocate space for the force on each atom
      if (global_options->FUNC_TO_FIT==AMBER_FORCES) {
        coords_data[i].force = (force_struct *) malloc(global_options->NATOMS*sizeof(force_struct));
        if (coords_data[i].force == NULL) {
          malloc_failure_char("alloc_coords", "coords_data->force", (global_options->NATOMS*sizeof(force_struct)));
          return NULL;
        }
      }
      else
        coords_data[i].force = NULL;
    }
    return coords_data;
}
Exemplo n.º 2
0
/**
 * Main input creating function for multiple prmtops
 * Creates input directories if non existent, creates the files to write in the
 * dircctory, and calls the appropriate function to write the correct format. If there
 * is only one molecule, falls through to old fashioned create_input for single prmtops.
 * 
 * @param[in] global_options The global options structure
 * @param[in] parm_datas Pointer to the array of parm structures
 * @param[in] coords_datas Pointer to array of coordinate structures
 * @return Integer indicating success or failure
 */
int create_qm_input(global_options_struct *global_options, parm_struct *parm_datas, coord_set *coords_datas)
{
  int retval;
  char *filename;
  FILE *fptr;
  int i,j;
  
  // Sanity check that relevant job control variables are defined
  if (!global_options->QMFILEOUTSTART) {
    printf("ERROR: QMFILEOUTSTART not defined in job control file.\n");
    return INVALID_DATA;
  } else if (!global_options->QMFILEOUTEND) {
    printf("ERROR: QMFILEOUTEND not defined in job control file.\n");
    return INVALID_DATA;
  } else if (!global_options->QMHEADER) {
    printf("ERROR: QM_HEADER not defined in job control file.\n");
    return INVALID_DATA;
  }
  
  // Print out a message if fitting forces
  if (global_options->FUNC_TO_FIT==AMBER_FORCES) {
    if (global_options->QMFILEFORMAT==GAUSSIAN)
      printf("!  Will fit forces- ensure the route line in your header has the force keyword!\n");
    else {
      printf("*** ERROR: Force calculation input file creation is currently only supported for Gaussian.\n");
      return INVALID_DATA;
  } }
  
  // If single prmtop, just do old fashioned create input
  if (global_options->num_prmtops==1)
    return create_input_single_prmtop(global_options, parm_datas, coords_datas);
   
  // Loop through each prmtop
  for (i=0; i<global_options->num_prmtops; ++i) {
    // Check if directory already exists for these files. If not, create it
    struct stat s;
    if (!stat(coords_datas[i].energy_filename, &s)) { // returns 0 on success
#if WIN32
      if (!S_ISDIR(s.st_mode)) {
#else
      if (!S_ISDIR(s.st_mode) && !S_ISLNK(s.st_mode)) {
#endif
        printf("ERROR! Energy directory for coordinate set '%s' is '%s'\n", coords_datas[i].filename, coords_datas[i].energy_filename);
        printf("       Not a directory or symlink\n");
        return INVALID_DATA;
    } }
    else { // create the directory
      printf("   Creating directory %s\n", coords_datas[i].energy_filename);
#if WIN32
      if (mkdir(coords_datas[i].energy_filename)) { // returns 0 on success
#else
      if (mkdir(coords_datas[i].energy_filename, 0700)) { // returns 0 on success
#endif
        printf("ERROR! Could not create directory '%s' for coordinate set '%s'\n", coords_datas[i].energy_filename, coords_datas[i].filename);
        return FAILURE;
    } }
    
    // Loop over each structure for this prmtop
    for (j=0; j<coords_datas[i].num_coords; ++j) {
      // Create the filename and open the file
      filename = (char*)malloc(strlen(coords_datas[i].energy_filename)+strlen(global_options->QMFILEOUTEND)+strlen(global_options->QMFILEOUTSTART)+10);
      if (!filename) {
        malloc_failure_char("create_qm_input","filename", strlen(coords_datas[i].energy_filename)+strlen(global_options->QMFILEOUTEND)+strlen(global_options->QMFILEOUTSTART)+10);
        return ALLOC_FAIL;
      }
      sprintf(filename,"%s/%s%d%s",coords_datas[i].energy_filename,global_options->QMFILEOUTSTART,j,global_options->QMFILEOUTEND);
      if((fptr=fopen(filename,"w"))==NULL) {
        file_open_failure("create_input", filename);
        return FILE_OPEN_FAIL;
      }
      
    // Write the file with the correct format
     if (global_options->QMFILEFORMAT==GAUSSIAN)
        retval=write_input_gaussian(global_options, &parm_datas[i], &coords_datas[i], j, fptr);
     else if (global_options->QMFILEFORMAT==ADF)
       retval = write_input_adf(global_options, &parm_datas[i], &coords_datas[i], j, fptr);
     else if (global_options->QMFILEFORMAT==GAMESS)
       retval = write_input_gamess(global_options, &parm_datas[i], &coords_datas[i], j, fptr);
     else {
       printf("   ERROR IN create_input SUBROUTINE\n");
       printf("   UNKNOWN FILE FORMAT TO WRITE: %d.\n",global_options->QMFILEFORMAT);
      return UNKNOWN_OPT;
     }
     if (retval!=SUCCESS) return retval;
     fclose(fptr);
     free(filename);
     
    }
    printf("    Successfully wrote %i input files for coordinate set '%s' in directory '%s'\n", coords_datas[i].num_coords, coords_datas[i].filename,
           coords_datas[i].energy_filename);
  }
  return SUCCESS;
}

/**
 * Main input creating function for a single prmtop
 * Sets up input files to write and calls the appropriate function to write it in the
 * correct format.
 * @param[in] global_options The global options structure
 * @param[in] parm_data Pointer to a single set of parameters for this molecule
 * @param[in] coords_data Pointer to a single coordinate set for this molecule
 * @return Integer indicating success or failure
 */
int create_input_single_prmtop(global_options_struct *global_options, parm_struct *parm_data, coord_set *coords_data)
{
  FILE *fptr;
  int current_struct=0;
  int retval;
  char filename_to_write[1024];

  if (global_options->VERBOSITY>=HIGH) {
     printf(" Creating input files. Will write a total of %d sequentially numbered files.\n",coords_data->num_coords);
     printf("           %6d > .",0);
  }

  /* Read the mdcrd if necessary */
  if (coords_data == NULL) {
    retval=read_single_mdcrd(global_options,coords_data);
    if (retval!=SUCCESS) {
      printf("*** ERROR IN create_input SUBROUTINE\n");
      printf("*** FAILED TO READ STRUCTURE %d FROM MDCRD FILE.\n",current_struct);
      return FILE_READ_FAIL;
    }
  }
  
  /* Print out a warning if fitting forces */
  if (global_options->FUNC_TO_FIT==AMBER_FORCES) {
    if (global_options->QMFILEFORMAT==GAUSSIAN)
    printf("!  Will fit forces- ensure the route line in your header has the force keyword!\n");
    else {
      printf("*** ERROR: Force calculation input file creation is currently only supported for Gaussian.\n");
      return INVALID_DATA;
    }
  }
  
  /*loop over all the structures*/
  for (current_struct=0; current_struct<coords_data->num_coords;++current_struct)
  {
     /*Open the output file with the relevant name*/
     /*filename to write is made up of QMFILEOUTSTART, current_struct and QMFILEOUTEND
     the char variable filename_to_write has been allocated as 1024 bytes long but we should
     still really have a sanity check here to ensure we don't exceed it - not that many people
     would ever want a filename over 1023 characters long*/
     if (strlen(global_options->QMFILEOUTSTART)+strlen(global_options->QMFILEOUTEND)+5 >= 1024) {
       printf("ERROR! Probable overflow in quantum input filenames.\n");
       printf("       Reduce the number of characters in QMFILEOUTSTART and QMFILEOUTEND\n");
       return INVALID_DATA;
     }

     /*Note, a potential overflow could occur here - currently NOT checked for*/
     
     /*Now fill the filename_to_write array*/
     sprintf(filename_to_write,"%s%d%s",global_options->QMFILEOUTSTART,current_struct,global_options->QMFILEOUTEND);
     if (global_options->VERBOSITY>=HIGH)
           printf("   Filename to be written is: %s\n",filename_to_write);
     
     if((fptr=fopen(filename_to_write,"w"))==NULL) {
        file_open_failure("create_input", filename_to_write);
        return FILE_OPEN_FAIL;
     }

     /*print info for each file we write*/
     if (global_options->VERBOSITY>=HIGH) {
       /*check if current_struct is divisible by 50, if it is print a new line*/
       if(current_struct%50==0)
         printf("\n           %6d > .",current_struct);
       else
         printf(".");
       fflush(stdout); /*Flush the printf buffer*/
     }

     /*Now we have the file open call the relevant routines for writing the data*/
     if (global_options->QMFILEFORMAT==GAUSSIAN)
        retval=write_input_gaussian(global_options, parm_data, coords_data, current_struct, fptr);
     else if (global_options->QMFILEFORMAT==ADF)
       retval = write_input_adf(global_options, parm_data, coords_data, current_struct, fptr);
     else if (global_options->QMFILEFORMAT==GAMESS)
       retval = write_input_gamess(global_options, parm_data, coords_data, current_struct, fptr);
     else {
       /*Unknown option*/
       printf("   ERROR IN create_input SUBROUTINE\n");
       printf("   UNKNOWN FILE FORMAT TO WRITE: %d.\n",global_options->QMFILEFORMAT);
      return UNKNOWN_OPT;
     }
     if (retval!=SUCCESS)
       return retval;
     fclose(fptr);
  }

  printf("*   Successfully wrote %i files\n",coords_data->num_coords); 
  return SUCCESS;
}