genmdeterministicgenerator.java

化学图形处理软件

		 for(i=1;i<34;i++)
			 if(numberOfBasicFragment[i]!=0)
			 {
				 for(j=1;j<=numberOfBasicFragment[i];j++)
					 totalNumberOfAtomAndBond+=((BasicFragment)(basicFragment.get(i-1))).getNumberOfFreeValence();

			 }
		 totalNumberOfAtomAndBond/=2;


		 for(i=1;i<34;i++)
			 if(numberOfBasicFragment[i]!=0)
			 {
				 for(j=1;j<=numberOfBasicFragment[i];j++)
				 {
					totalNumberOfAtomAndBond+=1;
				 }

				 // consider the complex fragment
				 switch(i)
				 {
					 case 2:
					 	for(j=1;j<=numberOfBasicFragment[i];j++)
						{
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(33)));
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(34)));
						}

						break;
					 case 4:
					 	for(j=1;j<=numberOfBasicFragment[i];j++)
						{
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(35)));
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(36)));
						}
						break;
					case 6:
					 	for(j=1;j<=numberOfBasicFragment[i];j++)
						{
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(37)));
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(38)));
						}
						break;
					 case 9:
					 	for(j=1;j<=numberOfBasicFragment[i];j++)
						{
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(39)));
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(40)));
						}
						break;
					default:
						for(j=1;j<=numberOfBasicFragment[i];j++)
							setOfBasicFragment.add((BasicFragment)(basicFragment.get(i-1)));
						break;
				 }

			 }

		//order the fragments
		atomContainer= builder.newAtomContainer();

		parentID=new int[setOfBasicFragment.size()];

		/* sort the fragment set according to the free valence*/
		setOfBasicFragment=getOrderOfBasicFragmentSet(setOfBasicFragment,parentID);

		rows=setOfBasicFragment.size();
		adjacencyMatrix=new int[rows][rows];
		previousMatrix=new int[rows][rows];
		rowMatrix=new int[rows];
		//setOfStability=new int[rows];
		bondAttribute=new int[rows];

		for(i=0;i<rows;i++)
		{
			bondAttribute[i]=((BasicFragment)(setOfBasicFragment.get(i))).getAttribute();
		}

		for(i=0;i<setOfBasicFragment.size();i++)
		{
			atomContainer.addAtom(
				builder.newAtom(((BasicFragment)(setOfBasicFragment.get(i))).getHeavyAtomSymbol())
			);
		}

		//IAtom[] atom=atomContainer.getAtoms();

		for(i=0;i<atomContainer.getAtomCount();i++)
		{
			atomContainer.getAtom(i).setHydrogenCount(((BasicFragment)(setOfBasicFragment.get(i))).getNumberOfHydrogen());
		}

		 //2. initialize the matrix
		initializeMatrix(setOfBasicFragment,bondAttribute,adjacencyMatrix,previousMatrix);
		// Initial equivalent
		//equivalentClass=getEquivalentClass(setOfBasicFragment,setOfStability);
		 //3. begin, see the flowchart
		step=0;

		 //Maximum WCF(M)
		isPossibleFilling=getMaximumWCF(setOfBasicFragment,0,rowMatrix,adjacencyMatrix,previousMatrix,parentID);
		if(!isPossibleFilling)return;
		while(step<(rows-1))
		{
			// Force filling the left lines
			step+=1;
			firstUnfilledRow=forceFilling(step,setOfBasicFragment,adjacencyMatrix,previousMatrix);
			do
			{
				// Check admissibility
				flag=checkAdmissibility(step,setOfBasicFragment,adjacencyMatrix);
				if(!flag)break;

				// constraint checker
				flag=checkConstraint(firstUnfilledRow,setOfBasicFragment,adjacencyMatrix,atomContainer);
				if(!flag)break;
			}while(false);

			if(flag)
			{
				if(firstUnfilledRow<rows)
				{
					step=firstUnfilledRow;
					isPossibleFilling=getMaximumWCF(setOfBasicFragment,step,rowMatrix,adjacencyMatrix,previousMatrix,parentID);
					if(!isPossibleFilling)return;
					continue;
				}
				else
				{
					getFinalStructure(setOfBasicFragment,adjacencyMatrix,storedSymbolOfStructure,totalNumberOfTheSet,totalNumberOfAtomAndBond);
					step-=1;
				}
			}
			else step-=1;

			// judge whether the line is forcefilling or not
			isForced=isForceFilling(step,previousMatrix,adjacencyMatrix);
			while(isForced)
			{
				step-=1;
				isForced=isForceFilling(step,previousMatrix,adjacencyMatrix);
			}

			//get rowMatrix
			for(i=0;i<rowMatrix.length;i++)rowMatrix[i]=adjacencyMatrix[step][i];
			// backtracking: restore the matrix to previous step
			restoreMatrix(step,bondAttribute,previousMatrix,adjacencyMatrix);
			nextWCF=getNextWCF(setOfBasicFragment,step,rowMatrix,adjacencyMatrix,previousMatrix,parentID);

			while(!nextWCF)
			{
				step-=1;
				if(step<0)return;
				else
				{
					isForced=isForceFilling(step,previousMatrix,adjacencyMatrix);
					while(isForced)
					{
						step-=1;
						isForced=isForceFilling(step,previousMatrix,adjacencyMatrix);
					}
					for(i=0;i<rowMatrix.length;i++)
					{
						rowMatrix[i]=adjacencyMatrix[step][i];
					}
					restoreMatrix(step,bondAttribute,previousMatrix,adjacencyMatrix);
					nextWCF=getNextWCF(setOfBasicFragment,step,rowMatrix,adjacencyMatrix,previousMatrix,parentID);
					if(nextWCF)break;
				}
			}
		 }
		 return;
	 }

	/**
	 * Initialized the adjacency matrix.
	 *
	 * @param	setOfBasicFragment	set of basic fragment
	 * @param	bondAttribute		to distinguish the bond
	 * @param	adjacency		adjacency matrix
	 * @param	previousMatrix		tracing the change of adjacency matrix
	 */
	 public void initializeMatrix(List setOfBasicFragment, int[] bondAttribute,int[][] adjacency,int[][] previousMatrix)
	 {
		int i,j,row,sum;
		row=setOfBasicFragment.size();

		int[] valenceOfFragment=new int[row];


		for(i=0;i<adjacency.length;i++)
			for(j=0;j<adjacency.length;j++)
				adjacency[i][j]=-1;
		for(i=0;i<adjacency.length;i++)
		{
				adjacency[i][i]=0;
				valenceOfFragment[i]=0;
		}


		/* if there are two basic fragments which is 1 free valence, appraently it is impossible to
		* be bonded between these two fragments.
		*/
		sum=0;
		if(row>2)
		{
			for(i=0;i<row;i++)
			{
				if(((BasicFragment)(setOfBasicFragment.get(i))).getNumberOfFreeValence()==1
					&& ((BasicFragment)(setOfBasicFragment.get(i))).getID()<=33)valenceOfFragment[i]=1;
				sum+=valenceOfFragment[i];
			}
			if(sum>1)
				for(i=0;i<row-1;i++)
					for(j=i+1;j<row;j++)
					{
						if(valenceOfFragment[i]==1 &&valenceOfFragment[j]==1)
						{
							adjacency[i][j]=0;
							adjacency[j][i]=0;
						}
					}
		}
		// The following loop is to give the zero element for bond unmatch. 28-11-2003
		for(i=0;i<row-1;i++)
			for(j=i;j<row;j++)
				if(bondAttribute[i]!=bondAttribute[j])
				{
					adjacency[i][j]=0;
					adjacency[j][i]=0;
				}
		for(i=0;i<adjacency.length;i++)
		{
			for(j=0;j<adjacency.length;j++)
			{
				previousMatrix[i][j]=adjacency[i][j];
			}
		}
		return;
	 }


	 /**
	  * Restore the adjacency matrix to previous step.
	  *
	  * @param	step		the line is filling
	  * @param	freeValence	array for free valence of each node left
	  * @param	sourceMatrix	the reference matrix
	  * @param	destMatrix	the matrix need to backtrack
	  */
	  public void restoreMatrix(int step,int[] freeValence,int[][] sourceMatrix,int[][] destMatrix)
	  {
		  int i,j;
		  for(i=step;i<sourceMatrix.length;i++)
		  {
			  if(sourceMatrix[i][i]>step)
			  {
				  destMatrix[i][i]=0;sourceMatrix[i][i]=0;
			  }

			  for(j=0;j<sourceMatrix.length;j++)
			  {
				  if(sourceMatrix[i][j]>step)
				  {
					  if(i!=j)
					 {
							 destMatrix[i][j]=-1;sourceMatrix[i][j]=-1;
					 }
				  }
			  }
		  }
		  return;
	  }

	 /**
	 * Maximum weakly canonical filling of line M.
	 *
	 * @param	setOfBasicFragment	set of basic fragment
	 * @param	step 			the line is filling
	 * @param	rowMatrix		the row which contains the filling line
	 * @param	adjacency		adjacency matrix
	 * @param	previousMatrix		matrix is used for tracing the change of adjacency matrix.
	 * @param	parentID		mainly used for unsaturated part
	 */
	 public boolean getMaximumWCF(List setOfBasicFragment,int step,int[] rowMatrix, int[][] adjacency,int[][] previousMatrix,int[] parentID)
	 {
		 int i,iter,bondOrder,size;
		 int totalBond,existBond,leftBond;
		 int[] setOfStability;
		 setOfStability=new int[rowMatrix.length];

		 /*Get the row matrix*/
		 size=setOfBasicFragment.size();
		 iter=0;
		 for(i=0;i<adjacency.length;i++)
		 {
			 rowMatrix[i]=adjacency[step][i];
			 if(rowMatrix[i]==-1)iter+=1;
		 }
		 getSetOfStability(setOfBasicFragment,step,rowMatrix,adjacency,setOfStability,parentID);
		 existBond=0;
		 for(i=0;i<adjacency.length;i++)if(rowMatrix[i]>0)existBond+=rowMatrix[i];
		 totalBond=((BasicFragment)(setOfBasicFragment.get(step))).getNumberOfFreeValence();
		 bondOrder=((BasicFragment)(setOfBasicFragment.get(step))).getAttribute();
		 leftBond=totalBond-existBond;
		 if(leftBond>iter)return false;

		 /* maximum this line*/
		 iter=leftBond;
		 for(i=1;i<rowMatrix.length;i++)
		 {
			 if(setOfStability[i]!=0)
			 {
				if(iter>0){rowMatrix[i]=bondOrder;iter-=1;}
				 else rowMatrix[i]=0;
			 }
		 }
		 /* A(i,j)=A(j,i)*/
		 for(i=0;i<adjacency.length;i++)
		 {
			 adjacency[step][i]=rowMatrix[i];
			 if(previousMatrix[step][i]==-1)previousMatrix[step][i]=step+1;

			 adjacency[i][step]=rowMatrix[i];
			 if(previousMatrix[i][step]==-1)previousMatrix[i][step]=step+1;
		 }

		 //for unsaturated part
		 int decomposedNumber=0;
		 int number1=0;
		 int number2=0;
		 if(parentID[step]==-1)return true;
		 else
		 {

			 for(i=0;i<size;i++)
				 if(parentID[i]!=-1)decomposedNumber+=1;
			 for(i=0;i<adjacency.length;i++)
				 if(rowMatrix[i]>0 && parentID[i]!=-1)
				 {

					  number1=parentID[step];
					  number2=parentID[i];
					  if((adjacency[step][i]>0 || adjacency[i][step]>0) && adjacency[number1][number2]==-1)
					  {
						adjacency[number1][number2]=0;
						adjacency[number2][number1]=0;
						 if(previousMatrix[number1][number2]==-1)
							 previousMatrix[number1][number2]=step+1;
					 	if(previousMatrix[number2][number1]==-1)
							previousMatrix[number2][number1]=step+1;
					  }
				 }
		 }
		 return true;
	 }


	 /**
	 * Get the partition for the left fragment at every step.
	 *
	 * @param	setOfBasicFragment	set of basic fragment
	 * @param	step			the line is filling
	 * @param	rowMatrix		the row which contains the filling line
	 * @param	adjacency		adjacency matrix
	 * @param	setOfStability		the previous equivalent partition
	 * @param	parentID		mainly used for unsaturated part
	 */
	 public  void getSetOfStability(List setOfBasicFragment,int step,int[] rowMatrix, int[][] adjacency,int[] setOfStability,int[] parentID)
	 {
		 int i,j,count,line;
		 int temp,size;
		 size=rowMatrix.length;
		 //boolean[] isAdded=new boolean[size];
		 int[] category=new int[size+1];
		 int[] equivalentClass=new int[size];

		 line=0;
		 for(i=0;i<adjacency.length;i++)setOfStability[i]=0;
		 if(step==0)
		 {
			for(i=1;i<setOfBasicFragment.size();i++)
			{
				if(rowMatrix[i]==-1)
				{
					setOfStability[i]=((BasicFragment)(setOfBasicFragment.get(i))).getID();
				}
			}

		 }
		 else
		 {
			for(i=step+1;i<setOfBasicFragment.size();i++)
			{
				if(rowMatrix[i]==-1)
				{
					setOfStability[i]=((BasicFragment)(setOfBasicFragment.get(i))).getID();
				}
			}

			/* judge temporatory equivalent at this line. */
			for(i=step+1;i<setOfStability.length-1;i++)
				for(j=i+1;j<setOfStability.length;j++)
				{
					if(rowMatrix[i]==-1 && rowMatrix[j]==-1 && setOfStability[i]==setOfStability[j])
					{
						for(line=0;line<step;line++)
						{
							if(adjacency[line][i]==adjacency[line][j])continue;
							else break;
						}
						if(line<step)setOfStability[j]+=100;//
					}
				}
		 }

		 temp=0;
		 for(i=0;i<parentID.length;i++)
		 {
			 if(parentID[i]!=-1)temp+=1;
		 }
		 if(temp>4)
		 {
			 int[] fragmentID=new int[setOfBasicFragment.size()];
			 for(i=0;i<setOfBasicFragment.size();i++)
				 fragmentID[i]=((BasicFragment)(setOfBasicFragment.get(i))).getID();
			 for(i=step+1;i<setOfBasicFragment.size()-1;i++)