void delete_file(const char *path, const char *filename){
/*Deletes file*/
char *path_file_name;
path_file_name = path_join_file(path, filename);
remove(path_file_name);
free(path_file_name);
}
void saving_time_execution(const char *local, const double *finished, const double *started,
const time_t *f_time, const time_t *s_time){
FILE *f_info;
char *f_information = NULL;
char *path_file_name = NULL;
double diff_t;
f_information = (char*)malloc(sizeof(char)*MAX_FILE_NAME);
diff_t = difftime(*f_time, *s_time);
strcpy(f_information, NAME_FILE);
path_file_name = path_join_file(local, f_information);
f_info = open_file(path_file_name, fAPPEND);
fprintf(f_info, "\n\nDate \n");
fprintf(f_info,"Started on %s", asctime(gmtime(s_time)));
fprintf(f_info, "Finished on %s", asctime(gmtime(f_time)));
fprintf(f_info, "Total time %f seconds \n",diff_t);
fprintf(f_info, "\n\nTime Execution\n");
fprintf(f_info, "Started = %f\n", *started);
fprintf(f_info, "Finished = %f\n", *finished);
fprintf(f_info, "Runtime = %9.4f\n", *finished - *started);
fclose(f_info);
free(path_file_name);
free(f_information);
}
void save_information(const char *local_execute, const int *num_proc,
const int *v_num_dock, const int *nthreads){
FILE *f_info;
char *f_information = NULL;
char *path_file_name = NULL;
int num_dock_total;
int i;
f_information = (char*)malloc(sizeof(char)*MAX_FILE_NAME);
strcpy(f_information, NAME_FILE);
path_file_name = path_join_file(local_execute, f_information);
f_info = open_file(path_file_name, fWRITE);
fprintf(f_info, "Process Number = %d\n", *num_proc);
fprintf(f_info, "Threads Number = %d\n", *nthreads);
num_dock_total = 0;
fprintf(f_info, "Docking Number per process\n");
for (i = 0; i < *num_proc; i++){
fprintf(f_info, "\t%d\t%d\n", i, v_num_dock[i]);
num_dock_total = num_dock_total + v_num_dock[i];
}
fprintf(f_info, "Docking Number total %d\n", num_dock_total);
fclose(f_info);
free(path_file_name);
free(f_information);
}
//create a file with docking
void save_file_docking_from_array(const docking_t *v_doc, const int *num_doc,
const char *local_execute, const int *suf){
FILE *f_dock=NULL;
char *line=NULL;
char *f_file = NULL;
char *path_file_name = NULL;
int d;
f_file = (char*)malloc(sizeof(char)*MAX_FILE_NAME);
build_docking_file_name(f_file, suf);
path_file_name = path_join_file(local_execute, f_file);
f_dock = open_file(path_file_name, fWRITE);
fprintf(f_dock, "%d\n", *num_doc);
for(d = 0; d < *num_doc; d++){
fprintf(f_dock, "%s\t%s\t%d\t%d\n", v_doc[d].receptor,
v_doc[d].compound,
v_doc[d].num_torsion_angle,
v_doc[d].num_atom);
}
fclose(f_dock);
free(path_file_name);
free(f_file);
}
void load_docking_from_file(docking_t *v_doc, const int *num_dock,
const char *local, const int *suf){
char *path_file_name = NULL;
FILE *f_dock=NULL;
char *f_file = NULL;
char *line=NULL;
int d;
line = (char*)malloc(MAX_LINE_FILE);
f_file = (char*)malloc(sizeof(char)*MAX_FILE_NAME);
build_docking_file_name(f_file, suf);
path_file_name = path_join_file(local, f_file);
f_dock = open_file(path_file_name, fREAD);
//ignoring first line of file
fgets(line, MAX_LINE_FILE, f_dock);
for (d = 0; d < *num_dock; d++){
fgets(line, MAX_LINE_FILE, f_dock);
set_receptor_compound(v_doc[d].receptor, v_doc[d].compound,
&v_doc[d].num_torsion_angle,
&v_doc[d].num_atom,
line);
}
fclose(f_dock);
free(line);
free(f_file);
free(path_file_name);
}
void save_values_to_analysis(const float *energy_after_mc_criteria,
const float *energy_new_solution, const float *ener_before_mc_crit,
const float *prob, const float *rr,
const input_parameters_t *in_para, const int *num_sol){
FILE * energy_file;
char *file_name;
file_name = Malloc(char, MAX_FILE_NAME);
strcpy(file_name, "monte_carlo_energies.fit");
char *fname = path_join_file(in_para->path_local_execute, file_name);
if (*num_sol == 1){
energy_file = open_file(fname, fWRITE);
fprintf (energy_file,"#Index\tEnergy_After_Criteria\tEnergy_Before_Criteria\tNew_Solution\tProb\trr\n");
}else{
energy_file = open_file(fname, fAPPEND);
}
fprintf (energy_file,"%i\t%.10e\t%.10e\t%.10e\t%f\t%f\n", *num_sol, *energy_after_mc_criteria,
*ener_before_mc_crit, *energy_new_solution, *prob, *rr);
fclose(energy_file);
free(fname);
free(file_name);
}
void save_solution_file(const char *path, const char *file_name,
const int *fit, const solution_t *solutions, const int *pop_size,
const int *tag, const input_parameters_t *in_para){
char *fname = path_join_file(path,file_name);
FILE *fit_file = open_file(fname,fWRITE);
write_header_generation(fit_file, tag);
/* objective that must be maximized. When they are obtained these values
* are multiplied by -1 because 2PG works with these opposite values.
* However, when they will be stored, they must be written in original
* value */
if ( (in_para->fitness_energies[*fit] == fit_hbond) ||
(in_para->fitness_energies[*fit] == fit_hydrophilic)||
(in_para->fitness_energies[*fit] == fit_hbond_main) ||
(in_para->fitness_energies[*fit] == fit_stride_total) ||
(in_para->fitness_energies[*fit] == fit_stride_helix) ||
(in_para->fitness_energies[*fit] == fit_stride_beta) ) {
write_oposite_objective_values(fit_file,fit,solutions,pop_size);
}else{
write_objectives_values(fit_file,fit,solutions,pop_size);
}
fclose(fit_file);
free(fname);
}
void save_solution(const solution_t *solution_curr,
const input_parameters_t *in_para, const int *model){
const protein_t* p_curr;
FILE * pdbfile;
char *file_name;
file_name = Malloc(char, MAX_FILE_NAME);
strcpy(file_name, "monte_carlo_solutions.pdb");
char *fname = path_join_file(in_para->path_local_execute,
file_name);
p_curr = (protein_t*) solution_curr->representation;
if (*model == 1){
pdbfile = open_file(fname, fWRITE);
writeHeader(pdbfile, 0.00, &p_curr->p_topol->numatom);
}else{
pdbfile = open_file(fname, fAPPEND);
}
writeModel(pdbfile, model);
writeATOM(pdbfile, p_curr->p_atoms, &p_curr->p_topol->numatom);
writeEndModel(pdbfile);
fclose(pdbfile);
free(fname);
free(file_name);
}
int main(int argc, char *argv[]){
input_parameters_t in_param;
display_msg("Reading the configure file \n");
load_parameters_from_file(&in_param,argv[1]);
/*Represents extension of files that will be looked in directory*/
char *ext = NULL;
/*Represents how many files there is in directory*/
int num_files;
/*Represents file names that are in directory and have target extension*/
owner_file_t *file_names = NULL;
protein_t *population_p= NULL; // main population of protein
solution_t *solutions_p= NULL; // main solution
dominance_t *dominance= NULL; // main of dominance
ea_nsga2_t *nsga2_solutions_p= NULL; // main of front
/**************** START GETTING FILE NAMES *************************/
ext = Malloc(char, 4);
strcpy(ext, "pdb");
num_files = how_many_files_directory_by_extension(in_param.path_local_execute, ext);
file_names = allocate_file_t(&num_files, &in_param.number_fitness);
insert_files_directory_by_extension(file_names, in_param.path_local_execute, ext);
free(ext);
/**************** FINISHED GETTING FILE NAMES *************************/
/**************** START GETTING THE OBJECTIVES *************************/
init_gromacs_execution();
/*
// RUN PDB2GMX IN ALL FILES FOR PATTERN OF ATOM NAMES
display_msg("Run of pdb2gmx for pattern of atom names\n");
for (int ind = 0; ind < num_files; ind ++){
call_pdb2gmx_for_pattern_atom_names(file_names[ind].file_name, in_param.path_local_execute, in_param.path_gromacs_programs, in_param.force_field);
clean_gromacs_simulation(in_param.path_local_execute);
}
// FINISHED RUN PDB2GMX
*/
population_p = allocateProtein(&num_files);
solutions_p = allocate_solution(&num_files, &in_param.number_fitness);
for (int ind = 0; ind < num_files; ind ++){
printf("Computing Objectives of %s\n", file_names[ind].file_name);
char *path_PDB_file_name = path_join_file(in_param.path_local_execute, file_names[ind].file_name);
int num_atom = get_num_atom(path_PDB_file_name);
population_p[ind].p_atoms = allocate_pdbatom(&num_atom);
load_pdb_file_without_num_atom(population_p[ind].p_atoms, NULL, path_PDB_file_name);
int num_res = get_number_residues_from_atom(population_p[ind].p_atoms, &num_atom);
population_p[ind].p_topol = allocateTop_Global(&num_res, &num_atom);
renumerate_residue_number(population_p[ind].p_atoms, &num_atom);
build_topology_individual(&population_p[ind]);
solutions_p[ind].representation = &population_p[ind];
get_gromacs_objectives_of_solution(&solutions_p[ind], &in_param, &ind);
desAllocateTop_Global(population_p[ind].p_topol);
desAllocate_pdbatom(population_p[ind].p_atoms);
free(path_PDB_file_name);
}
finish_gromacs_execution();
//Deleting temporary files
system("rm PROT_IND_*.pdb");
/**************** FINISHED GETTING THE OBJECTIVES *************************/
/**************** START GETTING FRONT *************************/
in_param.size_population = num_files;
nsga2_solutions_p = allocate_nsga2_without_allocation_of_representation(&in_param);
//Setting identification
for (int i = 0; i < num_files; i++){
nsga2_solutions_p[i].sol->ID = i+1;
}
//Setting dominance
dominance = allocate_dominance(&num_files);
set_dominance(dominance, solutions_p, &num_files);
//Coping values of dominance
for (int ind = 0; ind < num_files; ind++){
// Indicates number of solutions that are dominated by me
file_names[ind].number_solutions_are_dominated = dominance[ind].max_dominated;
}
//Coping values of objective
for (int ind = 0; ind < num_files; ind++){
for (int ob = 0; ob < in_param.number_fitness; ob++)
nsga2_solutions_p[ind].sol->obj_values[ob] = solutions_p[ind].obj_values[ob];
}
//Setting front based on dominance concept
compute_fronts(nsga2_solutions_p, dominance, &num_files);
//Coping values from nsga2_solutions_p to owner_file_t
for (int ind = 0; ind < num_files; ind++){
//Coping objectives
for (int ob = 0; ob < in_param.number_fitness; ob++){
file_names[ind].obj_values[ob] = nsga2_solutions_p[ind].sol->obj_values[ob];
}
file_names[ind].front = nsga2_solutions_p[ind].front;
}
desallocate_dominance(dominance, &num_files);
desallocate_solution_nsga2(nsga2_solutions_p, &num_files);
/**************** FINISHED GETTING FRONT *************************/
/**************** START GETTING FINAL RESULTS *************************/
//Sorting solutions
sorting_solutions_by_front_dominance(file_names, &num_files, &in_param.number_fitness);
//Saving file
save_analysis_files(file_names, &num_files, &in_param.number_fitness, in_param.fitness_energies);
/**************** FINISHED FINAL RESULTS *************************/
desalocate_file_t(file_names, &num_files);
desallocate_solution(solutions_p, &num_files);
desallocateProtein(population_p, &num_files);
deAllocateload_parameters(&in_param);
display_msg("Done !!! \n");
return 0;
}
