int main( int argc , char *argv[] ) {
/* index counters */
int i ;
/* Command line options */
char input_file_name[1024] ;
char output_file_name[1024] ;
/* Angles stuff */
int z_twist , theta , phi ;
/* Structures */
struct Structure Input_Structure , Origin_Structure , Spun_Structure ;
/************/
/* Its nice to tell people what going on straight away */
setvbuf( stdout , (char *)NULL , _IONBF , 0 ) ;
printf( "\n 3D-Dock Suite (March 2001)\n" ) ;
printf( " Copyright (C) 1997-2000 Gidon Moont\n" ) ;
printf( " This program comes with ABSOLUTELY NO WARRANTY\n" ) ;
printf( " for details see license. This program is free software,\n");
printf( " and you may redistribute it under certain conditions.\n\n");
printf( " Biomolecular Modelling Laboratory\n" ) ;
printf( " Imperial Cancer Research Fund\n" ) ;
printf( " 44 Lincoln's Inn Fields\n" ) ;
printf( " London WC2A 3PX\n" ) ;
printf( " +44 (0)20 7269 3348\n" ) ;
printf( " http://www.bmm.icnet.uk/\n\n" ) ;
/************/
printf( "Starting FTDock random spin program (FTDock v2.0)\n" ) ;
/************/
/* Command Line defaults */
strcpy( input_file_name , "unspun.pdb" ) ;
strcpy( output_file_name , "spun.pdb" ) ;
/* Command Line parse */
for( i = 1 ; i < argc ; i ++ ) {
if( strcmp( argv[i] , "-in" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( input_file_name , argv[i] ) ;
} else {
if( strcmp( argv[i] , "-out" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( output_file_name , argv[i] ) ;
} else {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
}
}
/************/
/* Read in Structure from pdb file */
Input_Structure = read_pdb_to_structure( input_file_name ) ;
/* Store new structures centered on Origin */
Origin_Structure = translate_structure_onto_origin( Input_Structure ) ;
/* Free some memory */
for( i = 1 ; i <= Input_Structure.length ; i ++ ) {
free( Input_Structure.Residue[i].Atom ) ;
}
free( Input_Structure.Residue ) ;
/* Spin Structure */
for( i = 0 ; i < 10 ; i ++ ) {
/* Get angles */
srand( (unsigned int)time( NULL ) ) ;
z_twist = (int)( 359 * ( (float)rand() / (float)RAND_MAX ) ) ;
theta = (int)( 179 * ( (float)rand() / (float)RAND_MAX ) ) ;
phi = (int)( 359 * ( (float)rand() / (float)RAND_MAX ) ) ;
Spun_Structure = rotate_structure( Origin_Structure , (long int)z_twist , (long int)theta , (long int)phi ) ;
for( i = 1 ; i <= Origin_Structure.length ; i ++ ) {
free( Origin_Structure.Residue[i].Atom ) ;
}
free( Origin_Structure.Residue ) ;
if( i != 9 ) Origin_Structure = duplicate_structure( Spun_Structure ) ;
}
write_structure_to_pdb( Spun_Structure , output_file_name ) ;
for( i = 1 ; i <= Spun_Structure.length ; i ++ ) {
free( Spun_Structure.Residue[i].Atom ) ;
}
free( Spun_Structure.Residue ) ;
/************/
printf( "\n\nFinished\n\n" ) ;
return( 0 ) ;
} /* end main */
int main(int argc, char *argv[])
{
/* index counters */
int i, j;
int residue_s, atom_s;
/* Command line options */
char *input_file_name;
int b0, b1, b2;
char *gf_type;
char gf_one_letter_code;
int c_alpha;
/* File stuff */
FILE *ftdock_file;
char line_buffer[100];
char *static_file_name;
char *mobile_file_name;
char *complex_file_name;
/* Structures */
struct Structure Static_Structure, Mobile_Structure;
struct Structure Origin_Static_Structure, Origin_Mobile_Structure;
struct Structure Rotated_at_Origin_Mobile_Structure, Translated_and_Rotated_at_Origin_Mobile_Structure;
struct Structure Complex_Structure, C_Alpha_Complex_Structure;
/* Co-ordinates and Angles */
int x, y, z, z_twist, theta, phi;
/* Grid stuff */
int grid_size;
float grid_span, one_span;
/* ftdock.dat file values */
int complex_id, prev_complex_id, SCscore;
float RPscore;
/************/
/* Its nice to tell people what going on straight away */
setvbuf(stdout, (char *)NULL, _IONBF, 0);
printf("\n 3D-Dock Suite (March 2001)\n");
printf(" Copyright (C) 1997-2000 Gidon Moont\n");
printf(" This program comes with ABSOLUTELY NO WARRANTY\n");
printf(" for details see license. This program is free software,\n");
printf(" and you may redistribute it under certain conditions.\n\n");
printf(" Biomolecular Modelling Laboratory\n");
printf(" Imperial Cancer Research Fund\n");
printf(" 44 Lincoln's Inn Fields\n");
printf(" London WC2A 3PX\n");
printf(" +44 (0)20 7269 3348\n");
printf(" http://www.bmm.icnet.uk/\n\n");
printf("Starting Build program\n");
/************/
/* Memory allocation */
if (((input_file_name = (char *)malloc(500 * sizeof(char))) == NULL) ||
((gf_type = (char *)malloc(10 * sizeof(char))) == NULL) ||
((static_file_name = (char *)malloc(500 * sizeof(char))) == NULL) ||
((mobile_file_name = (char *)malloc(500 * sizeof(char))) == NULL) || ((complex_file_name = (char *)malloc(500 * sizeof(char))) == NULL)) {
GENERAL_MEMORY_PROBLEM}
/************/
/* Command Line defaults */
strcpy(input_file_name, "ftdock_rpscored.dat");
b0 = 0;
b1 = 1;
b2 = NUMBER_TO_KEEP;
strcpy(gf_type, "G_DATA");
gf_one_letter_code = 'g';
c_alpha = 0;
/* Command Line parse */
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-in") == 0) {
i++;
if ((i == argc) || (strncmp(argv[i], "-", 1) == 0)) {
printf("Bad command line\n");
exit(EXIT_FAILURE);
}
strcpy(input_file_name, argv[i]);
} else {
if (strcmp(argv[i], "-b0") == 0) {
i++;
if ((i == argc) || (strncmp(argv[i], "-", 1) == 0)) {
printf("Bad command line\n");
exit(EXIT_FAILURE);
}
sscanf(argv[i], "%d", &b0);
} else {
if (strcmp(argv[i], "-b1") == 0) {
i++;
if ((i == argc) || (strncmp(argv[i], "-", 1) == 0)) {
printf("Bad command line\n");
exit(EXIT_FAILURE);
}
sscanf(argv[i], "%d", &b1);
} else {
if (strcmp(argv[i], "-b2") == 0) {
i++;
if ((i == argc) || (strncmp(argv[i], "-", 1) == 0)) {
printf("Bad command line\n");
exit(EXIT_FAILURE);
}
sscanf(argv[i], "%d", &b2);
} else {
if (strcmp(argv[i], "-fine") == 0) {
strcpy(gf_type, "F_DATA");
gf_one_letter_code = 'f';
} else {
if (strcmp(argv[i], "-c_alpha") == 0) {
c_alpha = 1;
} else {
printf("Bad command line\n");
exit(EXIT_FAILURE);
}
}
}
}
}
}
}
/************/
/* Read neat data file - headers */
if ((ftdock_file = fopen(input_file_name, "r")) == NULL) {
printf("Could not open %s for reading.\nDying\n\n", input_file_name);
exit(EXIT_FAILURE);
}
while (fgets(line_buffer, 99, ftdock_file)) {
if (strncmp(line_buffer, "Static molecule", 15) == 0)
sscanf(line_buffer, "Static molecule :: %s", static_file_name);
if (strncmp(line_buffer, "Mobile molecule", 15) == 0)
sscanf(line_buffer, "Mobile molecule :: %s", mobile_file_name);
if (gf_one_letter_code == 'g') {
if (strncmp(line_buffer, "Global grid size", 16) == 0)
sscanf(line_buffer, "Global grid size :: %d", &grid_size);
} else {
if (strncmp(line_buffer, "Refinement grid size", 20) == 0)
sscanf(line_buffer, "Refinement grid size :: %d", &grid_size);
}
if (strncmp(line_buffer, gf_type, 6) == 0)
break;
}
fclose(ftdock_file);
/************/
/* Read in Structures from pdb files */
Static_Structure = read_pdb_to_structure(static_file_name);
Mobile_Structure = read_pdb_to_structure(mobile_file_name);
/************/
/* Store new structures centered on Origin */
Origin_Static_Structure = translate_structure_onto_origin(Static_Structure);
Origin_Mobile_Structure = translate_structure_onto_origin(Mobile_Structure);
/* Free some memory */
for (i = 1; i <= Static_Structure.length; i++) {
free(Static_Structure.Residue[i].Atom);
}
free(Static_Structure.Residue);
for (i = 1; i <= Mobile_Structure.length; i++) {
free(Mobile_Structure.Residue[i].Atom);
}
free(Mobile_Structure.Residue);
/************/
/* Calculate Grid stuff */
grid_span = total_span_of_structures(Origin_Static_Structure, Origin_Mobile_Structure);
one_span = grid_span / (float)grid_size;
/************/
/* Reopen ftdock.dat */
if ((ftdock_file = fopen(input_file_name, "r")) == NULL) {
printf("Could not open %s for reading.\nDying\n\n", input_file_name);
exit(EXIT_FAILURE);
}
/************/
/* Choose between range to build or specific individual */
if (b0 != 0) {
/* Build individual */
printf("Building complex %s %d only\n", gf_type, b0);
b1 = b0;
b2 = b0;
} else {
/* Build range */
printf("Building complexes %s %d -> %d\n", gf_type, b1, b2);
}
/* Build */
while (fgets(line_buffer, 99, ftdock_file)) {
for (i = b1; i <= b2; i++) {
if (strncmp(line_buffer, gf_type, 6) == 0) {
sscanf(line_buffer + 1, "_DATA %d %d %d %f %d %d %d %d %d %d", &complex_id, &prev_complex_id, &SCscore, &RPscore, &x, &y, &z, &z_twist, &theta,
&phi);
if (complex_id == i) {
/* Rotate Mobile Structure */
Rotated_at_Origin_Mobile_Structure = rotate_structure(Origin_Mobile_Structure, z_twist, theta, phi);
/* Translate Mobile Structure */
Translated_and_Rotated_at_Origin_Mobile_Structure =
translate_structure(Rotated_at_Origin_Mobile_Structure, (float)x * one_span, (float)y * one_span, (float)z * one_span);
/************/
/* Write Complex */
Complex_Structure = merge_structures(Origin_Static_Structure, Translated_and_Rotated_at_Origin_Mobile_Structure);
sprintf(complex_file_name, "Complex_%d%c.pdb", complex_id, gf_one_letter_code);
/************/
if (c_alpha == 1) {
if ((C_Alpha_Complex_Structure.Residue = (struct Amino_Acid *)malloc((Complex_Structure.length + 1) * sizeof_Amino_Acid)) == NULL) {
GENERAL_MEMORY_PROBLEM}
strcpy(C_Alpha_Complex_Structure.ident, Complex_Structure.ident);
C_Alpha_Complex_Structure.length = Complex_Structure.length;
for (residue_s = 1; residue_s <= Complex_Structure.length; residue_s++) {
C_Alpha_Complex_Structure.Residue[residue_s] = Complex_Structure.Residue[residue_s];
C_Alpha_Complex_Structure.Residue[residue_s].size = 1;
if ((C_Alpha_Complex_Structure.Residue[residue_s].Atom = (struct Atom *)malloc(2 * sizeof_Atom)) == NULL) {
GENERAL_MEMORY_PROBLEM}
for (atom_s = 1; atom_s <= Complex_Structure.Residue[residue_s].size; atom_s++) {
if (strcmp(Complex_Structure.Residue[residue_s].Atom[atom_s].atom_name, " CA ") == 0) {
C_Alpha_Complex_Structure.Residue[residue_s].Atom[1] = Complex_Structure.Residue[residue_s].Atom[atom_s];
}
}
}
sprintf(complex_file_name, "CA_Complex_%d%c.pdb", complex_id, gf_one_letter_code);
write_structure_to_pdb(C_Alpha_Complex_Structure, complex_file_name);
} else {
write_structure_to_pdb(Complex_Structure, complex_file_name);
}
/************/
/* Free some memory */
for (j = 1; j <= Rotated_at_Origin_Mobile_Structure.length; j++) {
free(Rotated_at_Origin_Mobile_Structure.Residue[j].Atom);
free(Translated_and_Rotated_at_Origin_Mobile_Structure.Residue[j].Atom);
}
free(Rotated_at_Origin_Mobile_Structure.Residue);
free(Translated_and_Rotated_at_Origin_Mobile_Structure.Residue);
for (j = 1; j <= Complex_Structure.length; j++) {
free(Complex_Structure.Residue[j].Atom);
}
free(Complex_Structure.Residue);
}
}
int main( int argc , char *argv[] ) {
/* index counters */
int i ;
/* Command line options */
char *output_file_name ;
char *static_file_name ;
char *mobile_file_name ;
int global_grid_size ;
int angle_step ;
float surface ;
float internal_value ;
int electrostatics ;
int keep_per_rotation ;
int kept_scores ;
int rescue ;
int calculate ;
float reverse_calculated_one_span ;
char *default_global_grid_size ;
char *default_angle_step ;
char *default_surface ;
char *default_internal_value ;
char *default_electrostatics ;
char *default_keep_per_rotation ;
/* File stuff */
FILE *ftdock_file ;
char line_buffer[100] ;
int id , id2 , SCscore ;
float RPscore ;
int x , y , z , z_twist , theta , phi ;
/* Angles stuff */
struct Angle Angles ;
int first_rotation , rotation ;
/* Structures */
struct Structure Static_Structure , Mobile_Structure ;
struct Structure Origin_Static_Structure , Origin_Mobile_Structure ;
struct Structure Rotated_at_Origin_Mobile_Structure ;
/* Co-ordinates */
int xyz , fx , fy , fz , fxyz ;
/* Grid stuff */
float grid_span , one_span ;
float *static_grid ;
float *mobile_grid ;
float *convoluted_grid ;
float *static_elec_grid = ( void * ) 0 ;
float *mobile_elec_grid = ( void * ) 0 ;
float *convoluted_elec_grid = ( void * ) 0 ;
/* FFTW stuff */
fftwf_plan ps, pse, pm, pme, pinvs, pinvse;
fftwf_complex *static_fsg ;
fftwf_complex *mobile_fsg ;
fftwf_complex *multiple_fsg ;
fftwf_complex *static_elec_fsg = ( void * ) 0 ;
fftwf_complex *mobile_elec_fsg = ( void * ) 0 ;
fftwf_complex *multiple_elec_fsg = ( void * ) 0 ;
/* Scores */
struct Score *Scores ;
float max_es_value ;
/* Timing */
unsigned long tb, ta;
struct rusage rb, ra;
struct timeval tvb, tva;
/************/
/* Its nice to tell people what going on straight away */
setvbuf( stdout , (char *)NULL , _IONBF , 0 ) ;
printf( "\n 3D-Dock Suite (March 2001)\n" ) ;
printf( " Copyright (C) 1997-2000 Gidon Moont\n" ) ;
printf( " This program comes with ABSOLUTELY NO WARRANTY\n" ) ;
printf( " for details see license. This program is free software,\n");
printf( " and you may redistribute it under certain conditions.\n\n");
printf( " Biomolecular Modelling Laboratory\n" ) ;
printf( " Imperial Cancer Research Fund\n" ) ;
printf( " 44 Lincoln's Inn Fields\n" ) ;
printf( " London WC2A 3PX\n" ) ;
printf( " +44 (0)20 7269 3348\n" ) ;
printf( " http://www.bmm.icnet.uk/\n\n" ) ;
printf( "Starting FTDock (v2.0) global search program\n" ) ;
/************/
/* Memory allocation */
if( ( ( output_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) ||
( ( static_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) ||
( ( mobile_file_name = ( char * ) malloc ( 500 * sizeof( char ) ) ) == NULL ) ) {
GENERAL_MEMORY_PROBLEM
}
/************/
/* Command Line defaults */
strcpy( output_file_name , "ftdock_global.dat" ) ;
strcpy( static_file_name , " --static file name was not provided--" ) ;
strcpy( mobile_file_name , " --mobile file name was not provided--" ) ;
global_grid_size = 128 ;
angle_step = 12 ;
surface = 1.3 ;
internal_value = -15 ;
electrostatics = 1 ;
keep_per_rotation = 3 ;
rescue = 0 ;
calculate = 1 ;
reverse_calculated_one_span = 0.7 ;
default_global_grid_size = "(default calculated)" ;
default_angle_step = "(default)" ;
default_surface = "(default)" ;
default_internal_value = "(default)" ;
default_electrostatics = "(default)" ;
default_keep_per_rotation = "(default)" ;
/* Command Line parse */
for( i = 1 ; i < argc ; i ++ ) {
if( strcmp( argv[i] , "-out" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( output_file_name , argv[i] ) ;
} else {
if( strcmp( argv[i] , "-static" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( static_file_name , argv[i] ) ;
} else {
if( strcmp( argv[i] , "-mobile" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
strcpy( mobile_file_name , argv[i] ) ;
} else {
if( strcmp( argv[i] , "-grid" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%d" , &global_grid_size ) ;
if( ( global_grid_size % 2 ) != 0 ) {
printf( "Grid size must be even\n" ) ;
exit( EXIT_FAILURE ) ;
}
default_global_grid_size = "(user defined)" ;
calculate = 0 ;
} else {
if( strcmp( argv[i] , "-angle_step" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%d" , &angle_step ) ;
default_angle_step = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-surface" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%f" , &surface ) ;
default_surface = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-internal" ) == 0 ) {
i ++ ;
if( i == argc ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%f" , &internal_value ) ;
default_internal_value = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-noelec" ) == 0 ) {
electrostatics = 0 ;
default_electrostatics = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-keep" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
sscanf( argv[i] , "%d" , &keep_per_rotation ) ;
default_keep_per_rotation = "(user defined)" ;
} else {
if( strcmp( argv[i] , "-rescue" ) == 0 ) {
rescue = 1 ;
} else {
if( strcmp( argv[i] , "-calculate_grid" ) == 0 ) {
i ++ ;
if( ( i == argc ) || ( strncmp( argv[i] , "-" , 1 ) == 0 ) ) {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
calculate = 1 ;
default_global_grid_size = "(user defined calculated)" ;
sscanf( argv[i] , "%f" , &reverse_calculated_one_span ) ;
} else {
printf( "Bad command line\n" ) ;
exit( EXIT_FAILURE ) ;
}
}
}
}
}
}
}
}
}
}
}
}
/************/
/* Rescue option */
if( rescue == 1 ) {
printf( "RESCUE mode\n" ) ;
if( ( ftdock_file = fopen( "scratch_parameters.dat" , "r" ) ) == NULL ) {
printf( "Could not open scratch_parameters.dat for reading.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
calculate = 0 ;
default_global_grid_size = "(read from rescue file)" ;
default_angle_step = "(read from rescue file)" ;
default_surface = "(read from rescue file)" ;
default_internal_value = "(read from rescue file)" ;
default_electrostatics = "(read from rescue file)" ;
while( fgets( line_buffer , 99 , ftdock_file ) ) {
if( strncmp( line_buffer , "Static molecule" , 15 ) == 0 ) sscanf( line_buffer , "Static molecule :: %s" , static_file_name ) ;
if( strncmp( line_buffer , "Mobile molecule" , 15 ) == 0 ) sscanf( line_buffer , "Mobile molecule :: %s" , mobile_file_name ) ;
if( strncmp( line_buffer , "Output file name" , 16 ) == 0 ) sscanf( line_buffer , "Output file name :: %s" , output_file_name ) ;
if( strncmp( line_buffer , "Global grid size" , 16 ) == 0 ) sscanf( line_buffer , "Global grid size :: %d" , &global_grid_size ) ;
if( strncmp( line_buffer , "Global search angle step" , 24 ) == 0 ) sscanf( line_buffer , "Global search angle step :: %d" , &angle_step ) ;
if( strncmp( line_buffer , "Global surface thickness" , 24 ) == 0 ) sscanf( line_buffer , "Global surface thickness :: %f" , &surface ) ;
if( strncmp( line_buffer , "Global internal deterrent value" , 31 ) == 0 ) sscanf( line_buffer , "Global internal deterrent value :: %f" , &internal_value ) ;
if( strncmp( line_buffer , "Electrostatics :: on" , 44 ) == 0 ) electrostatics = 1 ;
if( strncmp( line_buffer , "Electrostatics :: off" , 44 ) == 0 ) electrostatics = 0 ;
if( strncmp( line_buffer , "Global keep per rotation" , 25 ) == 0 ) sscanf( line_buffer , "Global keep per rotation :: %d" , &keep_per_rotation ) ;
}
fclose( ftdock_file ) ;
if( ( ftdock_file = fopen( "scratch_scores.dat" , "r" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for reading.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
char* r = fgets( line_buffer , 99 , ftdock_file ) ;
while( fgets( line_buffer , 99 , ftdock_file ) ) {
sscanf( line_buffer , "G_DATA %d " , &first_rotation ) ;
}
fclose( ftdock_file ) ;
first_rotation ++ ;
printf( "Will be starting from rotation %d\n" , first_rotation ) ;
/************/
} else {
first_rotation = 1 ;
}
/************/
/* Do these things first so that bad inputs will be caught soonest */
/* Read in Structures from pdb files */
Static_Structure = read_pdb_to_structure( static_file_name ) ;
Mobile_Structure = read_pdb_to_structure( mobile_file_name ) ;
if( Mobile_Structure.length > Static_Structure.length ) {
printf( "WARNING\n" ) ;
printf( "The mobile molecule has more residues than the static\n" ) ;
printf( "Are you sure you have the correct molecules?\n" ) ;
printf( "Continuing anyway\n" ) ;
}
/************/
/* Get angles */
Angles = generate_global_angles( angle_step ) ;
printf( "Total number of rotations is %d\n" , Angles.n ) ;
/************/
/* Assign charges */
if( electrostatics == 1 ) {
printf( "Assigning charges\n" ) ;
assign_charges( Static_Structure ) ;
assign_charges( Mobile_Structure ) ;
}
/************/
/* Store new structures centered on Origin */
Origin_Static_Structure = translate_structure_onto_origin( Static_Structure ) ;
Origin_Mobile_Structure = translate_structure_onto_origin( Mobile_Structure ) ;
/* Free some memory */
for( i = 1 ; i <= Static_Structure.length ; i ++ ) {
free( Static_Structure.Residue[i].Atom ) ;
}
free( Static_Structure.Residue ) ;
for( i = 1 ; i <= Mobile_Structure.length ; i ++ ) {
free( Mobile_Structure.Residue[i].Atom ) ;
}
free( Mobile_Structure.Residue ) ;
/************/
/* Calculate Grid stuff */
grid_span = total_span_of_structures( Origin_Static_Structure , Origin_Mobile_Structure ) ;
if( calculate == 1 ) {
printf( "Using automatic calculation for grid size\n" ) ;
global_grid_size = (int)( grid_span / reverse_calculated_one_span ) ;
if( ( global_grid_size % 2 ) != 0 ) global_grid_size ++ ;
}
one_span = grid_span / (float)global_grid_size ;
printf( "Span = %.3f angstroms\n" , grid_span ) ;
printf( "Grid size = %d\n" , global_grid_size ) ;
printf( "Each Grid cube = %.5f angstroms\n" , one_span ) ;
/************/
/* Memory Allocation */
if( ( Scores = ( struct Score * ) malloc ( ( keep_per_rotation + 2 ) * sizeof( struct Score ) ) ) == NULL ) {
GENERAL_MEMORY_PROBLEM
}
if(
( ( static_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( mobile_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( convoluted_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
) {
printf( "Not enough memory for surface grids\nUse (sensible) smaller grid size\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
static_fsg = ( fftwf_complex * ) static_grid ;
mobile_fsg = ( fftwf_complex * ) mobile_grid ;
multiple_fsg = ( fftwf_complex * ) convoluted_grid ;
if( electrostatics == 1 ) {
if(
( ( static_elec_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( mobile_elec_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
||
( ( convoluted_elec_grid = ( float * ) malloc
( global_grid_size * global_grid_size * ( 2 * ( global_grid_size / 2 + 1 ) ) * sizeof( float ) ) ) == NULL )
) {
printf( "Not enough memory for electrostatic grids\nSwitch off electrostatics or use (sensible) smaller grid size\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
} else {
/* all ok */
printf( "Electrostatics are on\n" ) ;
}
static_elec_fsg = ( fftwf_complex * ) static_elec_grid ;
mobile_elec_fsg = ( fftwf_complex * ) mobile_elec_grid ;
multiple_elec_fsg = ( fftwf_complex * ) convoluted_elec_grid ;
}
/************/
/* Create FFTW plans */
printf( "Creating plans\n" ) ;
ps = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , static_grid, (fftwf_complex*)static_grid,
FFTW_MEASURE) ;
if( electrostatics == 1 ) {
pse = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , static_elec_grid, (fftwf_complex*)static_elec_grid,
FFTW_MEASURE ) ;
}
pm = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , mobile_grid, (fftwf_complex*)mobile_grid,
FFTW_MEASURE ) ;
if (electrostatics == 1) {
pme = fftwf_plan_dft_r2c_3d( global_grid_size , global_grid_size , global_grid_size , mobile_elec_grid, (fftwf_complex*)mobile_elec_grid,
FFTW_MEASURE) ;
}
pinvs = fftwf_plan_dft_c2r_3d( global_grid_size , global_grid_size , global_grid_size , multiple_fsg, (float*)multiple_fsg,
FFTW_MEASURE ) ;
if (electrostatics == 1) {
pinvse = fftwf_plan_dft_c2r_3d( global_grid_size , global_grid_size , global_grid_size , multiple_elec_fsg, (float*)multiple_elec_fsg,
FFTW_MEASURE ) ;
}
/************/
getrusage(RUSAGE_SELF, &rb);
gettimeofday(&tvb, NULL);
printf( "Setting up Static Structure\n" ) ;
/* Discretise and surface the Static Structure (need do only once) */
discretise_structure( Origin_Static_Structure , grid_span , global_grid_size , static_grid ) ;
printf( " surfacing grid\n" ) ;
surface_grid( grid_span , global_grid_size , static_grid , surface , internal_value ) ;
/* Calculate electic field at all grid nodes (need do only once) */
if( electrostatics == 1 ) {
electric_field( Origin_Static_Structure , grid_span , global_grid_size , static_elec_grid ) ;
electric_field_zero_core( global_grid_size , static_elec_grid , static_grid , internal_value ) ;
}
/* Fourier Transform the static grids (need do only once) */
printf( " one time forward FFT calculations\n" ) ;
fftwf_execute(ps);
if( electrostatics == 1 ) {
fftwf_execute(pse);
}
printf( " done\n" ) ;
/************/
/* Store paramaters in case of rescue */
if( ( ftdock_file = fopen( "scratch_parameters.dat" , "w" ) ) == NULL ) {
printf( "Could not open scratch_parameters.dat for writing.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
fprintf( ftdock_file, "\nGlobal Scan\n" ) ;
fprintf( ftdock_file, "\nCommand line controllable values\n" ) ;
fprintf( ftdock_file, "Static molecule :: %s\n" , static_file_name ) ;
fprintf( ftdock_file, "Mobile molecule :: %s\n" , mobile_file_name ) ;
fprintf( ftdock_file, "Output file name :: %s\n" , output_file_name ) ;
fprintf( ftdock_file, "\n" ) ;
fprintf( ftdock_file, "Global grid size :: %6d %s\n" , global_grid_size , default_global_grid_size ) ;
fprintf( ftdock_file, "Global search angle step :: %6d %s\n" , angle_step , default_angle_step ) ;
fprintf( ftdock_file, "Global surface thickness :: %9.2f %s\n" , surface , default_surface ) ;
fprintf( ftdock_file, "Global internal deterrent value :: %9.2f %s\n" , internal_value , default_internal_value ) ;
if( electrostatics == 1 ) {
fprintf( ftdock_file, "Electrostatics :: on %s\n" , default_electrostatics ) ;
} else {
fprintf( ftdock_file, "Electrostatics :: off %s\n" , default_electrostatics ) ;
}
fprintf( ftdock_file, "Global keep per rotation :: %6d %s\n" , keep_per_rotation , default_keep_per_rotation ) ;
fprintf( ftdock_file, "\nCalculated values\n" ) ;
fprintf( ftdock_file, "Global rotations :: %6d\n" , Angles.n ) ;
fprintf( ftdock_file, "Global total span (angstroms) :: %10.3f\n" , grid_span ) ;
fprintf( ftdock_file, "Global grid cell span (angstroms) :: %10.3f\n" , one_span ) ;
fclose( ftdock_file ) ;
/************/
/* Main program loop */
max_es_value = 0 ;
printf( "Starting main loop through the rotations\n" ) ;
/* PCA: start comment
for( rotation = first_rotation ; rotation <= Angles.n ; rotation ++ ) {
* PCA: end comment
*/
for( rotation = first_rotation ; rotation <= 10/*Angles.n*/ ; rotation ++ ) {
printf( "." ) ;
if( ( rotation % 50 ) == 0 ) printf( "\nRotation number %5d\n" , rotation ) ;
/* Rotate Mobile Structure */
Rotated_at_Origin_Mobile_Structure =
rotate_structure( Origin_Mobile_Structure , (int)Angles.z_twist[rotation] , (int)Angles.theta[rotation] , (int)Angles.phi[rotation] ) ;
/* Discretise the rotated Mobile Structure */
discretise_structure( Rotated_at_Origin_Mobile_Structure , grid_span , global_grid_size , mobile_grid ) ;
/* Electic point charge approximation onto grid calculations ( quicker than filed calculations by a long way! ) */
if( electrostatics == 1 ) {
electric_point_charge( Rotated_at_Origin_Mobile_Structure , grid_span , global_grid_size , mobile_elec_grid ) ;
}
/* Forward Fourier Transforms */
fftwf_execute(pm);
if( electrostatics == 1 ) {
fftwf_execute(pme);
}
/************/
/* Do convolution of the two sets of grids
convolution is equivalent to multiplication of the complex conjugate of one
fourier grid with other (raw) one
hence the sign changes from a normal complex number multiplication
*/
for( fx = 0 ; fx < global_grid_size ; fx ++ ) {
for( fy = 0 ; fy < global_grid_size ; fy ++ ) {
for( fz = 0 ; fz < global_grid_size/2 + 1 ; fz ++ ) {
fxyz = fz + ( global_grid_size/2 + 1 ) * ( fy + global_grid_size * fx ) ;
multiple_fsg[fxyz][0] =
c_re(static_fsg[fxyz]) * c_re(mobile_fsg[fxyz]) + c_im(static_fsg[fxyz]) * c_im(mobile_fsg[fxyz]) ;
multiple_fsg[fxyz][1] =
c_im(static_fsg[fxyz]) * c_re(mobile_fsg[fxyz]) - c_re(static_fsg[fxyz]) * c_im(mobile_fsg[fxyz]) ;
if( electrostatics == 1 ) {
multiple_elec_fsg[fxyz][0] =
c_re(static_elec_fsg[fxyz]) * c_re(mobile_elec_fsg[fxyz]) + c_im(static_elec_fsg[fxyz]) * c_im(mobile_elec_fsg[fxyz]) ;
multiple_elec_fsg[fxyz][1] =
c_im(static_elec_fsg[fxyz]) * c_re(mobile_elec_fsg[fxyz]) - c_re(static_elec_fsg[fxyz]) * c_im(mobile_elec_fsg[fxyz]) ;
}
}
}
}
/* Reverse Fourier Transform */
fftwf_execute(pinvs);
if( electrostatics == 1 ) {
fftwf_execute(pinvse);
}
/************/
/* Get best scores */
for( i = 0 ; i < keep_per_rotation ; i ++ ) {
Scores[i].score = 0 ;
Scores[i].rpscore = 0.0 ;
Scores[i].coord[1] = 0 ;
Scores[i].coord[2] = 0 ;
Scores[i].coord[3] = 0 ;
}
for( x = 0 ; x < global_grid_size ; x ++ ) {
fx = x ;
if( fx > ( global_grid_size / 2 ) ) fx -= global_grid_size ;
for( y = 0 ; y < global_grid_size ; y ++ ) {
fy = y ;
if( fy > ( global_grid_size / 2 ) ) fy -= global_grid_size ;
for( z = 0 ; z < global_grid_size ; z ++ ) {
fz = z ;
if( fz > ( global_grid_size / 2 ) ) fz -= global_grid_size ;
xyz = z + ( 2 * ( global_grid_size / 2 + 1 ) ) * ( y + global_grid_size * x ) ;
if( ( electrostatics == 0 ) || ( convoluted_elec_grid[xyz] < 0 ) ) {
/* Scale factor from FFTs */
if( (int)convoluted_grid[xyz] != 0 ) {
convoluted_grid[xyz] /= ( global_grid_size * global_grid_size * global_grid_size ) ;
}
if( (int)convoluted_grid[xyz] > Scores[keep_per_rotation-1].score ) {
i = keep_per_rotation - 2 ;
while( ( (int)convoluted_grid[xyz] > Scores[i].score ) && ( i >= 0 ) ) {
Scores[i+1].score = Scores[i].score ;
Scores[i+1].rpscore = Scores[i].rpscore ;
Scores[i+1].coord[1] = Scores[i].coord[1] ;
Scores[i+1].coord[2] = Scores[i].coord[2] ;
Scores[i+1].coord[3] = Scores[i].coord[3] ;
i -- ;
}
Scores[i+1].score = (int)convoluted_grid[xyz] ;
if( ( electrostatics != 0 ) && ( convoluted_elec_grid[xyz] < 0.1 ) ) {
Scores[i+1].rpscore = (float)convoluted_elec_grid[xyz] ;
} else {
Scores[i+1].rpscore = (float)0 ;
}
Scores[i+1].coord[1] = fx ;
Scores[i+1].coord[2] = fy ;
Scores[i+1].coord[3] = fz ;
}
}
}
}
}
if( rotation == 1 ) {
if( ( ftdock_file = fopen( "scratch_scores.dat" , "w" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for writing.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
} else {
if( ( ftdock_file = fopen( "scratch_scores.dat" , "a" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for writing.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
}
for( i = 0 ; i < keep_per_rotation ; i ++ ) {
max_es_value = min( max_es_value , Scores[i].rpscore ) ;
/* PCA: start comment
fprintf( ftdock_file, "G_DATA %6d %6d %7d %.0f %4d %4d %4d %4d%4d%4d\n" ,
rotation , 0 , Scores[i].score , (float)Scores[i].rpscore , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3 ] ,
Angles.z_twist[rotation] , Angles.theta[rotation] , Angles.phi[rotation] ) ;
* PCA: Stop comment
*/
fprintf( stdout, "G_DATA %6d %6d %7d %4d %4d %4d %4d%4d%4d\n" ,
rotation , 0 , Scores[i].score , Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3 ] ,
Angles.z_twist[rotation] , Angles.theta[rotation] , Angles.phi[rotation] ) ;
}
fclose( ftdock_file ) ;
/* Free some memory */
for( i = 1 ; i <= Rotated_at_Origin_Mobile_Structure.length ; i ++ ) {
free( Rotated_at_Origin_Mobile_Structure.Residue[i].Atom ) ;
}
free( Rotated_at_Origin_Mobile_Structure.Residue ) ;
}
/* Finished main loop */
/************/
/* Free the memory */
fftwf_destroy_plan( ps ) ;
fftwf_destroy_plan( pse ) ;
fftwf_destroy_plan( pm ) ;
fftwf_destroy_plan( pme ) ;
fftwf_destroy_plan( pinvs ) ;
fftwf_destroy_plan( pinvse ) ;
free( static_grid ) ;
free( mobile_grid ) ;
free( convoluted_grid ) ;
if( electrostatics == 1 ) {
free( static_elec_grid ) ;
free( mobile_elec_grid ) ;
free( convoluted_elec_grid ) ;
}
for( i = 1 ; i <= Origin_Static_Structure.length ; i ++ ) {
free( Origin_Static_Structure.Residue[i].Atom ) ;
}
free( Origin_Static_Structure.Residue ) ;
for( i = 1 ; i <= Origin_Mobile_Structure.length ; i ++ ) {
free( Origin_Mobile_Structure.Residue[i].Atom ) ;
}
free( Origin_Mobile_Structure.Residue ) ;
/* PCA: Finishing programm here*/
getrusage(RUSAGE_SELF, &ra);
gettimeofday(&tva, NULL);
struct timeval usertimea = ra.ru_utime;
struct timeval systimea = ra.ru_stime;
unsigned long long usera = usertimea.tv_sec*1e6 + usertimea.tv_usec;
unsigned long long sysa = systimea.tv_sec*1e6 + systimea.tv_usec;
struct timeval usertimeb = rb.ru_utime;
struct timeval systimeb = rb.ru_stime;
unsigned long long userb = usertimeb.tv_sec*1e6 + usertimeb.tv_usec;
unsigned long long sysb = systimeb.tv_sec*1e6 + systimeb.tv_usec;
unsigned long long user = usera - userb;
unsigned long long sys = sysa - sysb;
unsigned long long mem_max = ra.ru_maxrss;
unsigned long long elapsed = (tva.tv_sec - tvb.tv_sec)*1e6 + (tva.tv_usec - tvb.tv_usec);
fprintf(stderr, "{ \"elapsed\": %llu, \"user\": %llu, \"sys\": %llu, \"mem_max\": %llu }", elapsed, user, sys, mem_max);
return 0;
/* PCA: */
/************/
/* Read in all the scores */
printf( "\nReloading all the scores\n" ) ;
if( ( ftdock_file = fopen( "scratch_scores.dat" , "r" ) ) == NULL ) {
printf( "Could not open scratch_scores.dat for reading.\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
if( ( Scores = ( struct Score * ) realloc ( Scores , ( 1 + keep_per_rotation ) * Angles.n * sizeof( struct Score ) ) ) == NULL ) {
printf( "Not enough memory left for storing scores\nProbably keeping too many per rotation\nDying\n\n" ) ;
exit( EXIT_FAILURE ) ;
}
kept_scores = 0 ;
while( fgets( line_buffer , 99 , ftdock_file ) ) {
sscanf( line_buffer , "G_DATA %d %d %d %f %d %d %d %d %d %d" , &id , &id2 , &SCscore , &RPscore ,
&x , &y , &z , &z_twist , &theta , &phi ) ;
Scores[kept_scores].score = SCscore ;
Scores[kept_scores].rpscore = RPscore ;
Scores[kept_scores].coord[1] = x ;
Scores[kept_scores].coord[2] = y ;
Scores[kept_scores].coord[3] = z ;
Scores[kept_scores].angle[1] = z_twist ;
Scores[kept_scores].angle[2] = theta ;
Scores[kept_scores].angle[3] = phi ;
kept_scores ++ ;
}
fclose( ftdock_file ) ;
kept_scores -- ;
qsort_scores( Scores , 0 , kept_scores ) ;
/************/
/* Writing data file */
if( ( ftdock_file = fopen( output_file_name , "w" ) ) == NULL ) {
printf( "Could not open %s for writing.\nDying\n\n" , output_file_name ) ;
exit( EXIT_FAILURE ) ;
}
fprintf( ftdock_file, "FTDOCK data file\n" ) ;
fprintf( ftdock_file, "\nGlobal Scan\n" ) ;
fprintf( ftdock_file, "\nCommand line controllable values\n" ) ;
fprintf( ftdock_file, "Static molecule :: %s\n" , static_file_name ) ;
fprintf( ftdock_file, "Mobile molecule :: %s\n" , mobile_file_name ) ;
fprintf( ftdock_file, "\n" ) ;
fprintf( ftdock_file, "Global grid size :: %6d %s\n" , global_grid_size , default_global_grid_size ) ;
fprintf( ftdock_file, "Global search angle step :: %6d %s\n" , angle_step , default_angle_step ) ;
fprintf( ftdock_file, "Global surface thickness :: %9.2f %s\n" , surface , default_surface ) ;
fprintf( ftdock_file, "Global internal deterrent value :: %9.2f %s\n" , internal_value , default_internal_value ) ;
if( electrostatics == 1 ) {
fprintf( ftdock_file, "Electrostatics :: on %s\n" , default_electrostatics ) ;
} else {
fprintf( ftdock_file, "Electrostatics :: off %s\n" , default_electrostatics ) ;
}
fprintf( ftdock_file, "Global keep per rotation :: %6d %s\n" , keep_per_rotation , default_keep_per_rotation ) ;
fprintf( ftdock_file, "\nCalculated values\n" ) ;
fprintf( ftdock_file, "Global rotations :: %6d\n" , Angles.n ) ;
fprintf( ftdock_file, "Global total span (angstroms) :: %10.3f\n" , grid_span ) ;
fprintf( ftdock_file, "Global grid cell span (angstroms) :: %10.3f\n" , one_span ) ;
fprintf( ftdock_file, "\nData\n" ) ;
fprintf( ftdock_file , "Type ID prvID SCscore ESratio Coordinates Angles\n\n" ) ;
if( electrostatics == 1 ) {
for( i = 0 ; i <= min( kept_scores , ( NUMBER_TO_KEEP - 1 ) ) ; i ++ ) {
fprintf( ftdock_file, "G_DATA %6d %6d %7d %8.3f %4d %4d %4d %4d%4d%4d\n" ,
i + 1 , 0 , Scores[i].score , 100 * ( Scores[i].rpscore / max_es_value ) ,
Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3] ,
Scores[i].angle[1] , Scores[i].angle[2] , Scores[i].angle[3] ) ;
}
} else {
for( i = 0 ; i <= min( kept_scores , ( NUMBER_TO_KEEP - 1 ) ) ; i ++ ) {
fprintf( ftdock_file, "G_DATA %6d %6d %7d %8.3f %4d %4d %4d %4d%4d%4d\n" ,
i + 1 , 0 , Scores[i].score , 0.0 ,
Scores[i].coord[1] , Scores[i].coord[2] , Scores[i].coord[3] ,
Scores[i].angle[1] , Scores[i].angle[2] , Scores[i].angle[3] ) ;
}
}
fclose( ftdock_file ) ;
/************/
printf( "\n\nFinished\n\n" ) ;
return( 0 ) ;
} /* end main */
