genmdeterministicgenerator.java

化学图形处理软件

				 }

				 /* If all the following judgement are satisfactory, it should be one set of basic unit.Output them*/
				 generateBasicFragments();
			 }while(false);

			 /* exit from the distribution hydrogen, backtracking*/
			 do
			 {
				 iter1-=1;
				 if(iter1==6)return;
				 if(numberOfBasicUnit[iter1]>=maxNumberOfBasicUnit[iter1])continue;

				 do
				 {
					 numberOfBasicUnit[iter1]+=1;
					 if(iter1==7)//SiH3
					 {
						 iter3=numberOfBasicUnit[7];
						 if(iter3>molecularFormula[7])break;
					 }
					 else if(iter1==8)//SiH2
					 {
						 iter3=numberOfBasicUnit[7]+numberOfBasicUnit[8];
						 if(iter3>molecularFormula[7])break;
					 }
					 else if(iter1==9)//SiH2
					 {
						 iter3=numberOfBasicUnit[7]+numberOfBasicUnit[8]+numberOfBasicUnit[9];
						 if(iter3>molecularFormula[7])break;
					 }
					 else if(iter1==10)//PH2
					 {
						 iter3=numberOfBasicUnit[10];
						 if(iter3>molecularFormula[6])break;
					 }
					 else if(iter1==11)//PH
					 {
						 iter3=numberOfBasicUnit[10]+numberOfBasicUnit[11];
						 if(iter3>molecularFormula[6])break;
					 }
					 else if(iter1==13)//NH2
					 {
						 iter3=numberOfBasicUnit[13];
						 if(iter3>molecularFormula[4])break;
					 }
					 else if(iter1==14)//NH
					 {
						 iter3=numberOfBasicUnit[13]+numberOfBasicUnit[14];
						 if(iter3>molecularFormula[4])break;
					 }
					 else if(iter1==16)//CH3
					 {
						 iter3=numberOfBasicUnit[16];
						 if(iter3>molecularFormula[1])break;
						 iter4=numberOH+3*numberOfBasicUnit[16];
						 if(iter4>molecularFormula[2])break;
						 i=molecularFormula[2]-iter4;
						 j=molecularFormula[1]-iter3;
						 k=2*j;
						 if(i>k)continue;
						 else break;
					 }
					 else if(iter1==17)//CH2
					 {
						 iter3=numberOfBasicUnit[16]+numberOfBasicUnit[17];
						 if(iter3>molecularFormula[1])break;
						 iter4=numberOH+3*numberOfBasicUnit[16]+2*numberOfBasicUnit[17];
						 if(iter4>molecularFormula[2])break;
						 i=molecularFormula[2]-iter4;
						 j=molecularFormula[1]-iter3;
						 if(i>j)continue;
						 else break;
					 }
					 else
					 {
						 break;
					 }
					 break;
				 }while(true);
				 break;
			 }while(true);

		 }while(iter1>6);
		 return;
	 }


	/**
	 * Second step: generate basic fragments, the generating rules from basic
	 * units are as follows.
	 * For carbon:
	 * <ul>
	 *  <li>>C<, >C=,=C=,-C#(triple bond), 1~4
	 *  <li>CH: >CH-,=CH-,CH#, 5~7
	 *  <li>CH2: -CH2-,CH2=, 11~12
	 *  <li>CH3: CH3-,19
	 * </ul>
	 *
	 * For nitrogen:
	 * <ul>
	 *  <li>>N-,-N=,N#,8~10
	 *  <li>NH: -NH-, NH= ,13~14
	 *  <li>NH2: NH2-,20
	 * </ul>
	 *
	 * For oxygen:
	 * <ul>
	 *  <li>-O-,O=, 15~16
	 *  <li>OH: -OH, 21
	 * </ul>
	 *
	 * For sulfur:
	 * <ul>
	 *  <li>-S-,S=, 17~18
	 *  <li>SH, -SH,22
	 * </ul>
	 *
	 * For phosphorus:
	 * <ul>
	 *  <li>>P-, 23
	 *  <li>PH: -PH-,24
	 *  <li>PH2: -PH2,25
	 * </ul>
	 *
	 * For silicon:
	 * <ul>
	 *  <li>>Si< 26
	 *  <li>SiH: >SiH- 27
	 *  <li>SiH2: -SiH2- 28
	 *  <li>SiH3: SiH3- 29
	 * </ul>
	 *
	 * For others:
	 * <ul>
	 *  <li>F- 30
	 *  <li>Cl- 31
	 *  <li>Br- 32
	 *  <li>I- 33
	 * </ul>
	 * It could be easily add the new fragments, such as valence, variable
	 * valence, such as N,P,also, fragments contains charges.
	 * It is a combinatorial algorithm, as in n1*n2*n3.
	 */
	 public void generateBasicFragments() throws java.lang.Exception
	 {
		 int i,k;
		 int iter1;
		 boolean flag;
		 int[] maxNumberOfBasicFragment=new int[34];
		 /*initialization for the variables*/
		 if (logger.isDebugEnabled()) for(i=0;i<=22;i++) if(numberOfBasicUnit[i]!=0)logger.debug("numberOfBasicUnit["+i+"]=", numberOfBasicUnit[i]);
		 for(i=1;i<34;i++)numberOfBasicFragment[i]=0;

		 /* maximum number of basic fragments*/
		 maxNumberOfBasicFragment[1]=numberOfBasicUnit[6];//>C<
		 maxNumberOfBasicFragment[2]=numberOfBasicUnit[6];//>C=
		 maxNumberOfBasicFragment[3]=numberOfBasicUnit[6];//=C=
		 maxNumberOfBasicFragment[4]=numberOfBasicUnit[6];//-C#

		 maxNumberOfBasicFragment[5]=numberOfBasicUnit[18];//>CH-
		 maxNumberOfBasicFragment[6]=numberOfBasicUnit[18];//=CH-
		 maxNumberOfBasicFragment[7]=numberOfBasicUnit[18];//CH#

		 maxNumberOfBasicFragment[8]=numberOfBasicUnit[4];//>N-
		 maxNumberOfBasicFragment[9]=numberOfBasicUnit[4];//-N=
		 maxNumberOfBasicFragment[10]=numberOfBasicUnit[4];//N#

		 maxNumberOfBasicFragment[11]=numberOfBasicUnit[17];//-CH2-
		 maxNumberOfBasicFragment[12]=numberOfBasicUnit[17];//CH2=

		 maxNumberOfBasicFragment[13]=numberOfBasicUnit[14];//-NH-
		 maxNumberOfBasicFragment[14]=numberOfBasicUnit[14];//NH=

		 maxNumberOfBasicFragment[15]=numberOfBasicUnit[5];//-O-
		 maxNumberOfBasicFragment[16]=numberOfBasicUnit[5];//O=

		 maxNumberOfBasicFragment[17]=numberOfBasicUnit[3];//-S-
		 maxNumberOfBasicFragment[18]=numberOfBasicUnit[3];//S=

		 numberOfBasicFragment[19]=numberOfBasicUnit[16];
		 numberOfBasicFragment[20]=numberOfBasicUnit[13];
		 numberOfBasicFragment[21]=numberOfBasicUnit[15];
		 numberOfBasicFragment[22]=numberOfBasicUnit[12];
		 numberOfBasicFragment[23]=numberOfBasicUnit[2];
		 numberOfBasicFragment[24]=numberOfBasicUnit[11];
		 numberOfBasicFragment[25]=numberOfBasicUnit[10];
		 numberOfBasicFragment[26]=numberOfBasicUnit[1];
		 numberOfBasicFragment[27]=numberOfBasicUnit[9];
		 numberOfBasicFragment[28]=numberOfBasicUnit[8];
		 numberOfBasicFragment[29]=numberOfBasicUnit[7];
		 numberOfBasicFragment[30]=numberOfBasicUnit[19];
		 numberOfBasicFragment[31]=numberOfBasicUnit[20];
		 numberOfBasicFragment[32]=numberOfBasicUnit[21];
		 numberOfBasicFragment[33]=numberOfBasicUnit[22];

		 iter1=17;
		 //iter2=0;
		 while(iter1>0)
		 {
			 iter1+=1;

			 while(iter1<18)
			 {
				numberOfBasicFragment[iter1]=0;
				iter1+=1;
			 }

			 do
			 {
				 numberOfBasicFragment[18]=numberOfBasicUnit[3]-numberOfBasicFragment[17];
				 if(numberOfBasicFragment[18]<0)break;
				 numberOfBasicFragment[16]=numberOfBasicUnit[5]-numberOfBasicFragment[15];
				 if(numberOfBasicFragment[16]<0)break;
				 numberOfBasicFragment[14]=numberOfBasicUnit[14]-numberOfBasicFragment[13];
				 if(numberOfBasicFragment[14]<0)break;
				 numberOfBasicFragment[12]=numberOfBasicUnit[17]-numberOfBasicFragment[11];
				 if(numberOfBasicFragment[12]<0)break;
				 numberOfBasicFragment[10]=numberOfBasicUnit[4]-numberOfBasicFragment[8]-numberOfBasicFragment[9];
				 if(numberOfBasicFragment[10]<0)break;

				 numberOfBasicFragment[7]=numberOfBasicUnit[18]-numberOfBasicFragment[5]-numberOfBasicFragment[6];
				 if(numberOfBasicFragment[7]<0)break;
				 numberOfBasicFragment[4]=numberOfBasicUnit[6]-numberOfBasicFragment[1]-numberOfBasicFragment[2]-numberOfBasicFragment[3];
				 if(numberOfBasicFragment[4]<0)break;

				 flag=testBasicFragment();
				 if(flag)
				 {
					 numberOfSetFragment+=1;
					 logger.debug("Fragment Set	", numberOfSetFragment);
					 if (logger.isDebugEnabled()) {
						 for(i=1;i<34;i++) {
							 if(numberOfBasicFragment[i]!=0)logger.debug(((BasicFragment)(basicFragment.get(i-1))).getBasicFragment()+"		"+numberOfBasicFragment[i]);
						 }
					 }
					generateIsomers();
				}

			 }while(false);

			 do
			 {
				 iter1=iter1-1;
				 if(iter1==0)return;

				 if(numberOfBasicFragment[iter1]>=maxNumberOfBasicFragment[iter1])continue;
				 numberOfBasicFragment[iter1]=numberOfBasicFragment[iter1]+1;

				 if(iter1==2)
				 {
					 k=numberOfBasicFragment[1]+numberOfBasicFragment[2];
					 if(k>numberOfBasicUnit[6])continue;
					 else break;
				 }
				 else if(iter1==3)
				 {
					 k=numberOfBasicFragment[1]+numberOfBasicFragment[2]+numberOfBasicFragment[3];
					 if(k>numberOfBasicUnit[6])continue;
					 else break;
				 }
				 else if(iter1==4)
				 {
					 k=numberOfBasicFragment[1]+numberOfBasicFragment[2]+numberOfBasicFragment[3]+numberOfBasicFragment[4];
					 if(k>numberOfBasicUnit[6])continue;
					 else break;
				 }
				 else if(iter1==6)
				 {
					 k=numberOfBasicFragment[5]+numberOfBasicFragment[6];
					 if(k>numberOfBasicUnit[18])continue;
					 else break;
				 }
				 else if(iter1==7)
				 {
					 k=numberOfBasicFragment[5]+numberOfBasicFragment[6]+numberOfBasicFragment[7];
					 if(k>numberOfBasicUnit[18])continue;
					 else break;
				 }

				 else if(iter1==9)
				 {
					 k=numberOfBasicFragment[8]+numberOfBasicFragment[9];
					 if(k>numberOfBasicUnit[4])continue;
					 else break;
				 }
				 else if(iter1==10)
				 {
					 k=numberOfBasicFragment[8]+numberOfBasicFragment[9]+numberOfBasicFragment[10];
					 if(k>numberOfBasicUnit[4])continue;
					 else break;
				 }
				 else if(iter1==12)
				 {
					 k=numberOfBasicFragment[11]+numberOfBasicFragment[12];
					 if(k>numberOfBasicUnit[17])continue;
					 else break;
				 }
				 else if(iter1==14)
				 {
					 k=numberOfBasicFragment[13]+numberOfBasicFragment[14];
					 if(k>numberOfBasicUnit[14])continue;
					 else break;
				 }
				 else if(iter1==16)
				 {
					 k=numberOfBasicFragment[15]+numberOfBasicFragment[16];
					 if(k>numberOfBasicUnit[5])continue;
					 else break;
				 }
				 else if(iter1==18)
				 {
					 k=numberOfBasicFragment[17]+numberOfBasicFragment[18];
					 if(k>numberOfBasicUnit[3])continue;
					 else break;
				 }
				 break;
			 }while(true);
		 }
	 }



	 /**
	 * Test for the set of basic fragment.
	 */
	 public boolean testBasicFragment()
	 {
		 int i,j;
		 int numberOfFragment,numberOfOneFreeValence,numberOfTwoFreeValence;
		 int numberOfThreeFreeValence,numberOfFourFreeValence;
		 int numberOfSideDoubleBond,numberOfMiddleDoubleBond;
		 int totalFreeValence,totalDoubleBond,totalTripleBond;
		 int numberOfSideTripleBond,numberOfMiddleTripleBond;
		 //boolean flag=true;

		 /* initialization the variable*/
		 numberOfFragment=0;
		 numberOfOneFreeValence=0;
		 numberOfTwoFreeValence=0;
		 numberOfThreeFreeValence=0;
		 numberOfFourFreeValence=0;
		 numberOfSideDoubleBond=0;
		 numberOfMiddleDoubleBond=0;
		 numberOfSideTripleBond=0;
		 numberOfMiddleTripleBond=0;
		 totalTripleBond=0;
		 totalFreeValence=0;

		 for(i=1;i<34;i++)
		 {
			 numberOfFragment+=numberOfBasicFragment[i];
			 j=((BasicFragment)(basicFragment.get(i-1))).getNumberOfFreeValence();
			 switch(j)
			 {
				 case 1: numberOfOneFreeValence+=numberOfBasicFragment[i];break;
				 case 2: numberOfTwoFreeValence+=numberOfBasicFragment[i];break;
				 case 3: numberOfThreeFreeValence+=numberOfBasicFragment[i];break;
				 case 4: numberOfFourFreeValence+=numberOfBasicFragment[i];break;
			 }

		 }
		 /* 1. total free valence test*/
		 totalFreeValence=numberOfOneFreeValence+numberOfTwoFreeValence*2+numberOfThreeFreeValence*3+numberOfFourFreeValence*4;
		 if((totalFreeValence%2)!=0)return false;

		 totalFreeValence/=2;
		 if(numberOfFragment>(totalFreeValence+1))return false;

		 /*2. double bond test: */
		 numberOfSideDoubleBond=numberOfBasicFragment[12]+numberOfBasicFragment[14]+numberOfBasicFragment[16]+numberOfBasicFragment[18];
		 numberOfMiddleDoubleBond=numberOfBasicFragment[2]+numberOfBasicFragment[6]+numberOfBasicFragment[9];
		 if(numberOfBasicFragment[3]==0)
		 {
			 if(numberOfSideDoubleBond>numberOfMiddleDoubleBond && numberOfMiddleDoubleBond>0)return false;
			 totalDoubleBond=numberOfSideDoubleBond+numberOfMiddleDoubleBond;
			 if((totalDoubleBond%2)!=0)return false;
			 if((numberOfMiddleDoubleBond==0)&& (numberOfSideDoubleBond==2)&&(numberOfFragment>2))return false;
		 }
		 if(numberOfBasicFragment[3]>0)
		 {
			 if((numberOfMiddleDoubleBond==0)&&(numberOfBasicFragment[3]<(numberOfFragment-2)))return false;
			 if((numberOfMiddleDoubleBond+numberOfSideDoubleBond==0)&&(numberOfBasicFragment[3]<numberOfFragment))return false;
		 }

		 /*triple bond test*/

		 numberOfSideTripleBond=numberOfBasicFragment[7]+numberOfBasicFragment[10];
		 numberOfMiddleTripleBond=numberOfBasicFragment[4];
		 totalTripleBond=numberOfSideTripleBond+numberOfMiddleTripleBond;

		 if((totalTripleBond%2)!=0)return false;
		 if(numberOfMiddleTripleBond==0 && numberOfSideTripleBond!=0)return false;
		 return true;
	 }
	 
	 List setOfBasicFragment = new ArrayList();
	 IntArray storedSymbolOfStructure = new IntArray();
	 
	/**
	 * The thrid step: generate all the possible consititional isomers.
	 */
	 public void generateIsomers()
	 {
		 int i,j,rows;
		 int step,firstUnfilledRow;//equivalentClass;
		 int[] totalNumberOfTheSet=new int[1];
		 int totalNumberOfAtomAndBond=0;
		 totalNumberOfTheSet[0]=0;

		 boolean flag,nextWCF,isForced,isPossibleFilling;
		 int[][] adjacencyMatrix;
		 int[][] previousMatrix;
		 int[] rowMatrix;
		 //int[] setOfStability;
		 //int[] category;
		 int[] bondAttribute;
		 int[] parentID;
		 // reinitialize
		 storedSymbolOfStructure.clear();
		 setOfBasicFragment.clear();
		 IAtomContainer atomContainer=null;

		 /*1. prepare the vector of basic fragment and atomContainer
		 * atomContainer put the bond formed, while set of basic fragment
		 * put the source basic fragment.
		 */