parameter.c

药物开发中的基于结构的从头设计代码

# include "link.h"

Parameter::Parameter(char *filename)
{
	strcpy(seed_file,"none");
	strcpy(parameter_dir,"none");
	strcpy(fraglib_dir,"none");
	strcpy(forbidlib_dir,"none");
	strcpy(toxiclib_dir,"none");
	strcpy(pocket_file,"none");
	strcpy(grid_file,"none");

	grow_ratio=1.00;
	link_ratio=1.00;
	mutate_ratio=0.50;

	// default parameters for chemical rules

	strcpy(apply_chemical_rules,"YES");
	strcpy(apply_forbidden_check,"YES");
	strcpy(apply_toxicity_check,"YES");

	max_weight=600;
	min_weight=200;
	max_logp=6.00;
	min_logp=2.00;
	max_donor=6;
	min_donor=2;
	max_acceptor=6;
	min_acceptor=2;
	max_pkd=10.00;
	min_pkd=5.00;

	// default parameters for generational replacement strategy

	num_generation=30000;
	max_population=1000;

	strcpy(population_file, "population.lig");
	strcpy(ligands_file,"ligands.lig");

	ga_starting_mode=1;	

	// mode 1: start from a seed structure, in Mol2 format
	// mode 2: start from an existed population, in Lig format

	Read_Index(filename);

	Detect_GA_Start(seed_file);

	Check_Output();
}

Parameter::~Parameter()
{
	// deconstructor
}

void Parameter::Read_Index(char *filename)
{
	FILE *fp;
	char buf[160],head[80];
	int num_error;

	if((fp=fopen(filename,"r"))==NULL) Openning_File_Error(filename);

	for(;;)
		{
		 if(fgets(buf,160,fp)==NULL) break;
		 else if(buf[0]=='#') continue;
		 else if(Blank_Line_Check(buf)==TRUE) continue;
		 else sscanf(buf,"%s",head);

		 if(!strcmp(head,"SEED_LIGAND_FILE"))
			{
			 sscanf(buf,"%*s%s",seed_file);
			}
		 else if(!strcmp(head,"POCKET_ATOM_FILE"))
			{ 
			 sscanf(buf,"%*s%s",pocket_file); 
			}
		 else if(!strcmp(head,"POCKET_GRID_FILE"))
			{
			 sscanf(buf,"%*s%s",grid_file); 
			}
		 else if(!strcmp(head,"PARAMETER_DIRECTORY"))
			{
			 sscanf(buf,"%*s%s",parameter_dir);
			}
                 else if(!strcmp(head,"BUILDING_BLOCK_LIBRARY"))
                        {
                         sscanf(buf,"%*s%s",fraglib_dir);
                        }
		 else if(!strcmp(head,"FORBIDDEN_STRUCTURE_LIBRARY"))
                        {
                         sscanf(buf,"%*s%s",forbidlib_dir);
                        }
		 else if(!strcmp(head,"TOXIC_STRUCTURE_LIBRARY"))
                        {
                         sscanf(buf,"%*s%s",toxiclib_dir);
                        }
		 else if(!strcmp(head,"GROWING_PROBABILITY"))
                        {
                         sscanf(buf,"%*s%f",&grow_ratio);
                        }
		 else if(!strcmp(head,"LINKING_PROBABILITY"))
                        {
                         sscanf(buf,"%*s%f",&link_ratio);
                        }
		 else if(!strcmp(head,"MUTATION_PROBABILITY"))
                        {
                         sscanf(buf,"%*s%f",&mutate_ratio);
                        }
                 else if(!strcmp(head,"APPLY_CHEMICAL_RULES"))
                        {
                         sscanf(buf,"%*s%s",apply_chemical_rules);
                        }
		 else if(!strcmp(head,"APPLY_FORBIDDEN_STRUCTURE_CHECK"))
                        {
                         sscanf(buf,"%*s%s",apply_forbidden_check);
                        }
		 else if(!strcmp(head,"APPLY_TOXIC_STRUCTURE_CHECK"))
                        {
                         sscanf(buf,"%*s%s",apply_toxicity_check);
                        }
                 else if(!strcmp(head,"MAXIMAL_MOLECULAR_WEIGHT"))
                        {
                         sscanf(buf,"%*s%d",&max_weight);
                        }
		 else if(!strcmp(head,"MINIMAL_MOLECULAR_WEIGHT"))
                        {
                         sscanf(buf,"%*s%d",&min_weight);
                        }
		 else if(!strcmp(head,"MAXIMAL_LOGP"))
                        {
                         sscanf(buf,"%*s%f",&max_logp);
                        }
		 else if(!strcmp(head,"MINIMAL_LOGP"))
                        {
                         sscanf(buf,"%*s%f",&min_logp);
                        }
		 else if(!strcmp(head,"MAXIMAL_HB_DONOR_ATOM"))
                        {
                         sscanf(buf,"%*s%d",&max_donor);
                        }	
		 else if(!strcmp(head,"MINIMAL_HB_DONOR_ATOM"))
                        {
                         sscanf(buf,"%*s%d",&min_donor);
                        }
		 else if(!strcmp(head,"MAXIMAL_HB_ACCEPTOR_ATOM"))
                        {
                         sscanf(buf,"%*s%d",&max_acceptor);
                        }						
		 else if(!strcmp(head,"MINIMAL_HB_ACCEPTOR_ATOM"))
                        {
                         sscanf(buf,"%*s%d",&min_acceptor);
                        }
		 else if(!strcmp(head,"MAXIMAL_PKD"))
                        {
                         sscanf(buf,"%*s%f",&max_pkd);
			}
		 else if(!strcmp(head,"MINIMAL_PKD"))
                        {
                         sscanf(buf,"%*s%f",&min_pkd);
                        }
		 else if(!strcmp(head,"NUMBER_OF_GENERATION"))
                        {
                         sscanf(buf,"%*s%d",&num_generation);
                        }
		 else if(!strcmp(head,"NUMBER_OF_POPULATION"))
			{
			 sscanf(buf,"%*s%d",&max_population); 
			}
		 else if(!strcmp(head,"POPULATION_RECORD_FILE"))
                        {
                         sscanf(buf,"%*s%s",population_file);
                        }
		 else if(!strcmp(head,"LIGAND_COLLECTION_FILE"))
                        {
                         sscanf(buf,"%*s%s",ligands_file);
                        }
		 else continue;
		}

	fclose(fp);

	num_error=0;

	if(!strcmp(seed_file,"none")) 
		{
		 Missing_Parameter_Error("SEED_LIGAND_FILE");
		 num_error++;
		}
	if(!strcmp(pocket_file,"none"))	
		{
		 Missing_Parameter_Error("POCKET_ATOM_FILE");
		 num_error++;
		}
	if(!strcmp(grid_file,"none")) 
		{
		 Missing_Parameter_Error("POCKET_GRID_FILE");
		 num_error++;
		}
	if(!strcmp(parameter_dir,"none")) 
		{
		 Missing_Parameter_Error("PARAMETER_DIRECTORY");
		 num_error++;
		}
	if(!strcmp(fraglib_dir,"none"))	
		{
		 Missing_Parameter_Error("BUILDING_BLOCK_LIBRARY");
		 num_error++;
		}
	if(!strcmp(forbidlib_dir,"none")) 
		{
		 Missing_Parameter_Error("FORBIDDEN_STRUCTURE_LIBRARY");
		 num_error++;
		}
	if(!strcmp(toxiclib_dir,"none")) 
		{
		 Missing_Parameter_Error("TOXIC_STRUCTURE_LIBRARY");
		 num_error++;
		}

        Check_Directory(parameter_dir);
        Check_Directory(fraglib_dir);
        Check_Directory(forbidlib_dir);
        Check_Directory(toxiclib_dir);

	if(grow_ratio<0.00||grow_ratio>1.00)
                {
		 Invalid_Parameter_Error("GROWING_PROBABILITY");
		 num_error++;
                }
	if(link_ratio<0.00||link_ratio>1.00)
                {
                 Invalid_Parameter_Error("LINKING_PROBABILITY");
                 num_error++;
                }
	if(mutate_ratio<0.00||mutate_ratio>1.00)
                {
                 Invalid_Parameter_Error("MUTATION_PROBABILITY");
                 num_error++;
                }

	if(!strncmp(apply_chemical_rules,"y",1)||
 	   !strncmp(apply_chemical_rules,"Y",1))
		strcpy(apply_chemical_rules,"YES");
	else if(!strncmp(apply_chemical_rules,"n",1)||
		!strncmp(apply_chemical_rules,"N",1))
		strcpy(apply_chemical_rules,"NO");
	else 
		{
		 Invalid_Parameter_Error("APPLY_CHEMICAL_RULES"); 
		 num_error++;
		}

	if(!strncmp(apply_forbidden_check,"y",1)||
	   !strncmp(apply_forbidden_check,"Y",1))
		strcpy(apply_forbidden_check,"YES");
	else if(!strncmp(apply_forbidden_check,"n",1)||
		!strncmp(apply_forbidden_check,"N",1))
		strcpy(apply_forbidden_check,"NO");
	else 
		{
		 Invalid_Parameter_Error("APPLY_FORBIDDEN_STRUCTURE_CHECK");
		 num_error++;
		}

	if(!strncmp(apply_toxicity_check,"y",1)||
	   !strncmp(apply_toxicity_check,"Y",1))
		strcpy(apply_toxicity_check,"YES");
	else if(!strncmp(apply_toxicity_check,"n",1)||
		!strncmp(apply_toxicity_check,"N",1))
		strcpy(apply_toxicity_check,"NO");
	else 
		{
		 Invalid_Parameter_Error("APPLY_TOXIC_STRUCTURE_CHECK");
		 num_error++;
		}

	if(max_weight<min_weight)
		{
		 puts("Error: MAXIMAL_MOLECULAR_WEIGHT < MINIMAL_MOLECULAR_WEIGHT");
		 num_error++;
		}
	if(max_logp<min_logp)
		{
		 puts("Error: MAXIMAL_LOGP < MINIMAL_LOGP");
		 num_error++;
		}

	if(max_donor<min_donor)
                {
                 puts("Error: MAXIMAL_HB_DONOR_ATOM < MINIMAL_HB_DONOR_ATOM");
		 num_error++;
                }

	if(max_acceptor<min_acceptor)
                {
                 puts("Error: MAXIMAL_HB_ACCEPTOR_ATOM < MINIMAL_HB_ACCEPTOR_ATOM");
		 num_error++;
                }

	if(max_pkd<min_pkd)
                {
                 puts("Error: MAXIMAL_PKD < MINIMAL_PKD");
		 num_error++;
                }

	if(num_error!=0)
		{
		 printf("\n");
	 	 printf("%d errors have been detected in the parameter file.\n",num_error);
		 printf("Please correct them and try again.\n");
		 exit(1);
		}

	return;
}

void Parameter::Detect_GA_Start(char *filename)
{
	FILE *fp;
	char buf[160],head[80];

	if((fp=fopen(filename,"r"))==NULL) Openning_File_Error(filename);

	ga_starting_mode=0;

	while(1)
	{
	 if(fgets(buf,160,fp)==NULL) break;
	 sscanf(buf,"%s", head);
	 if(!strcmp(head,"@<TRIPOS>MOLECULE")) {ga_starting_mode=1; break;} 
	 else if(!strcmp(head,"<MOLECULE>")) {ga_starting_mode=2; break;} 
	 else continue;
	}

	fclose(fp);

	if(ga_starting_mode==0) Reading_File_Error(filename);

	return;
}

void Parameter::Check_Output()
{
	FILE *fp;

	if((fp=fopen(population_file,"w"))==NULL)
		Openning_File_Error(population_file);
	else fclose(fp);
		
	if((fp=fopen(ligands_file,"w"))==NULL)
		Openning_File_Error(ligands_file);
	else fclose(fp);

	return;
}

void Parameter::Show_Content() const
{
        printf("SEED_LIGAND_FILE\t\t%s\n",seed_file);
        printf("POCKET_ATOM_FILE\t\t%s\n",pocket_file);
        printf("POCKET_GRID_FILE\t\t%s\n",grid_file);

        printf("PARAMETER_DIRECTORY\t\t%s\n",parameter_dir);

        printf("BUILDING_BLOCK_LIBRARY\t\t%s\n",fraglib_dir);
	printf("FORBIDDEN_STRUCTURE_LIBRARY\t%s\n",forbidlib_dir);
	printf("TOXIC_STRUCTURE_LIBRARY\t\t%s\n",toxiclib_dir);

	printf("GROWING_PROBABILITY\t\t%-5.2f\n",grow_ratio);
	printf("LINKING_PROBABILITY\t\t%-5.2f\n",link_ratio);
	printf("MUTATION_PROBABILITY\t\t%-5.2f\n",mutate_ratio);

	printf("APPLY_CHEMICAL_RULES\t\t%s\n",apply_chemical_rules);
	printf("APPLY_FORBIDDEN_STRUCTURE_CHECK\t%s\n",apply_forbidden_check);
	printf("APPLY_TOXIC_STRUCTURE_CHECK\t%s\n",apply_toxicity_check);

        printf("MAXIMAL_MOLECULAR_WEIGHT\t%d\n",max_weight);
	printf("MINIMAL_MOLECULAR_WEIGHT\t%d\n",min_weight);
	printf("MAXIMAL_LOGP\t\t\t%-6.2f\n",max_logp);
	printf("MINIMAL_LOGP\t\t\t%-6.2f\n",min_logp);
	printf("MAXIMAL_HB_DONOR_ATOM\t\t%d\n",max_donor);
	printf("MINIMAL_HB_DONOR_ATOM\t\t%d\n",min_donor);
	printf("MAXIMAL_HB_ACCEPTOR_ATOM\t%d\n",max_acceptor);
	printf("MINIMAL_HB_ACCEPTOR_ATOM\t%d\n",min_acceptor);
	printf("MAXIMAL_PKD\t\t\t%-6.2f\n",max_pkd);
        printf("MINIMAL_PKD\t\t\t%-6.2f\n",min_pkd);

	printf("GA_STARTING_MODE\t\t%d\n",ga_starting_mode);

        printf("NUMBER_OF_GENERATION\t\t%d\n",num_generation);
        printf("NUMBER_OF_POPULATION\t\t%d\n",max_population);

        printf("POPULATION_RECORD_FILE\t\t%s\n",population_file);
	printf("LIGAND_COLLECTION_FILE\t\t%s\n",ligands_file);

	return;
}