genmdeterministicgenerator.java

化学图形处理软件

			sum+=currentFilledValue[changedCategory-2];
			iter=changedCategory-1;
			 while(leftBond>sum)
			  {
				 currentFilledValue[iter]=leftBond-sum;
				 if(currentFilledValue[iter]>category[iter] && iter<category[0])
				 {
					 currentFilledValue[iter]=category[iter];
					 sum+=currentFilledValue[iter];
					 iter+=1;
					 continue;
				 }

				 else break;
			  }
		}
		else if(changedCategory==category[0]&& previousFilledValue[changedCategory]==category[changedCategory] &&
			previousFilledValue[changedCategory-1]!=0 && previousFilledValue[changedCategory-1]==category[changedCategory-1])
		{
			while(previousFilledValue[changedCategory-2]==category[changedCategory-2])changedCategory-=1;
			changedCategory-=1;
			while(previousFilledValue[changedCategory-2]==0)changedCategory-=1;
			sum=0;
			for(i=1;i<(changedCategory-2);i++)
			{
				currentFilledValue[i]=previousFilledValue[i];
				sum+=currentFilledValue[i];
			}

			currentFilledValue[changedCategory-2]=previousFilledValue[changedCategory-2]-1;
			sum+=currentFilledValue[changedCategory-2];
			iter=changedCategory-1;
			 while(leftBond>sum)
			  {
				 currentFilledValue[iter]=leftBond-sum;
				 if(currentFilledValue[iter]>category[iter] && iter<category[0])
				 {
					 currentFilledValue[iter]=category[iter];
					 sum+=currentFilledValue[iter];
					 iter+=1;
					 continue;
				 }

				 else break;
			  }
		}
		 for(i=1;i<=category[0];i++)
		 {
			 iter=currentFilledValue[i];
			 for(j=step+1;j<rowMatrix.length;j++)
			 {
				 if(setOfStability[j]==i && iter>0)
				 {
					 rowMatrix[j]=bondOrder;
					 iter-=1;
				 }
				 else if(iter==0)break;
			}
		 }
		 for(i=step+1;i<rowMatrix.length;i++)if(rowMatrix[i]==-1)rowMatrix[i]=0;
		 for(i=0;i<adjacencyMatrix.length;i++)
		 {
			 adjacencyMatrix[step][i]=rowMatrix[i];
			 if(previousMatrix[step][i]==-1)previousMatrix[step][i]=step+1;

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

		 return true;
	 }

	 /**
	  * Judge whether this line of the adjacency matrix is forced or not.
	  *
	  * @param	step            the step of the generation
	  * @param	previousMatrix  matrix to trace the change of adjacency matrix
	  * @param	adjacency       adjacency matrix
	  * @return	a boolean value whether the line is force-filling or not
	  */
	 public boolean isForceFilling(int step,int[][] previousMatrix,int[][] adjacency)
	 {
		 if(previousMatrix[step][step]>0)return true;
		 return false;

	 }

	 /**
	  * Get the initial equivalent partition.
	  *
	  * @param	setOfBasicFragment	set of basic fragment
	  * @param	setOfStability		array contains the initial classing of the nodes
	  * @return	the number of equivalent class
	  */
	 public int getEquivalentClass(List setOfBasicFragment,int[] setOfStability)
	 {
		 int i,j,count;
		 int temp,size;

		 size=setOfBasicFragment.size();
		 int[] category=new int[size+1];
		 int[] equivalentClass=new int[size];

		 for(i=0;i<size;i++)setOfStability[i]=0;
		 for(i=0;i<size;i++)
			setOfStability[i]=((BasicFragment)(setOfBasicFragment.get(i))).getID();

		 /* get the category for this line*/
		 count=1;

		 category[1]=setOfStability[0];
		 for(i=1;i<size;i++)
		 {
			 for(j=1;j<=count;j++)
			 {
				temp=setOfStability[i]-category[j];
				 if(temp==0)break;
			 }
			 if(j>count)
			 {
				 count+=1;
				 category[count]=setOfStability[i];
			 }
		 }
		 for(i=0;i<size;i++)
			for(j=1;j<=count;j++)
			{
				temp=setOfStability[i]-category[j];
				if(temp==0)equivalentClass[i]=j;
			}
		 for(i=0;i<setOfStability.length;i++)
		 {
			 setOfStability[i]=equivalentClass[i];
		 }
		 return count;
	 }


	 /**
	  * Write adjacencyMatrix to debug. The method is only for debugging.
	  *
	  * @param	setOfBasicFragment	set of basic fragment
	  * @param	number			the sequence number of the structure
	  * @param	adjacency		adjacency matrix of the structure
	  */
	  public void writeToFile(List setOfBasicFragment,int number,int[][] adjacency)
	  {
		  int i,j,size;

          if (structureout == null) {
              logger.warn("Output writer is null. Not writing anything");
              return;
          }

          size=setOfBasicFragment.size();
			  String s="Number Of Structure is	";
			  structureout.print(s);
			  structureout.print(number);
			  structureout.println();
			  for(i=0;i<setOfBasicFragment.size();i++)
			  {
				  structureout.print(((BasicFragment)(setOfBasicFragment.get(i))).getBasicFragment());
				  structureout.print("	");
			  }
			  structureout.println();
			  for(i=0;i<size;i++)
			  {
				  for(j=0;j<size;j++)
				  {
					  structureout.print(adjacency[i][j]);
					  structureout.print("	");
				  }
				  structureout.println();
			  }
			structureout.flush();
	  }



	 /**
	  * Recursive graph traversal with the adjacency matrix.
	  *
	  * @param	adjacency	Adjacency matrix
	  * @param	number		node which would be visited
	  * @param	isVisited	boolean array which stored the visiting state for nodes
	  */
	 public void DFSM(int[][] adjacency,int number,boolean[] isVisited)
	 {
		  int j;
		  isVisited[number]=true;
		  for(j=0;j<adjacency.length;j++)
			  if((adjacency[number][j]>0) && !isVisited[j])DFSM(adjacency,j,isVisited);
	 }

	  /**
	   * Sort the basic fragment set. The purpose is to improve the generation
	   * speed by some specific ordering. In fact, it is little usage in the
	   * whole step.
	   *
	   * @param	setOfBasicFragment	set of basic fragment
	   * @param	parentID		Array for storing the previous ID, only used for special fragment.
	   * @return	List contains the sorting result.
	   */
	  public List getOrderOfBasicFragmentSet(List setOfBasicFragment,int[] parentID)
	  {
		  int i,j;
		  int size=setOfBasicFragment.size();
		  //int classID1,classID2;
		  int[] originalNumbering=new int[size];
		  int[] revisedNumbering=new int[size];

		  List orderSet=new ArrayList();
		  //int number=1;

		  for(i=0;i<size;i++)
		  {
			  parentID[i]=-1;

		  }


		  for(j=0;j<setOfBasicFragment.size();j++)
		  {
			  if(((BasicFragment)(setOfBasicFragment.get(j))).getID()==1)
				  orderSet.add((BasicFragment)(setOfBasicFragment.get(j)));
		  }
		  for(j=0;j<setOfBasicFragment.size();j++)
		  {
			  if(((BasicFragment)(setOfBasicFragment.get(j))).getID()==5)
				  orderSet.add((BasicFragment)(setOfBasicFragment.get(j)));
		  }
		  for(j=setOfBasicFragment.size()-1;j>=0;j--)
		   {
			if(((BasicFragment)(setOfBasicFragment.get(j))).getID()<=33)
				continue;
			orderSet.add((BasicFragment)(setOfBasicFragment.get(j)));
		  }

		  for(j=0;j<setOfBasicFragment.size();j++)
		  {
			if(((BasicFragment)(setOfBasicFragment.get(j))).getID()>33)
				continue;
			if(((BasicFragment)(setOfBasicFragment.get(j))).getID()==1
				|| ((BasicFragment)(setOfBasicFragment.get(j))).getID()==3
				||((BasicFragment)(setOfBasicFragment.get(j))).getID()==5)
				continue;
			orderSet.add((BasicFragment)(setOfBasicFragment.get(j)));
		  }

		  for(j=0;j<setOfBasicFragment.size();j++)
		  {
			  if(((BasicFragment)(setOfBasicFragment.get(j))).getID()==3)
				  orderSet.add((BasicFragment)(setOfBasicFragment.get(j)));
		  }

		  for(i=0;i<size;i++)
			  revisedNumbering[i]=((BasicFragment)(orderSet.get(i))).getParentID();
		  for(i=0;i<size;i++)
			  originalNumbering[i]=((BasicFragment)(orderSet.get(i))).getID();
		  for(i=0;i<(size-1);i++)
		  {
			  if(originalNumbering[i]<=33)continue;

			  for(j=i+1;j<size;j++)
			  {
				  if(originalNumbering[j]<=33)continue;

				  if(revisedNumbering[i]==revisedNumbering[j] && originalNumbering[i]!=originalNumbering[j] && j!=i && parentID[i]==-1 && parentID[j]==-1)
				  {
					  parentID[i]=j;
					  parentID[j]=i;
					  break;
				  }
			  }
		  }
		  setOfBasicFragment.clear();
		  return orderSet;
	  }


	  /**
	   * Judge the possible structure. The idea is the following:
	   * <ol>
	   *  <li>get the canonical representation for each candidate.</li>
	   *  <li>for each fragment set, compare with the previous
	   *      structures to remove redundancy.</li>
	   * </ol>
	   *
	   * @param	setOfBasicFragment	set of basic fragment
	   * @param	adjacencyMatrix		adjacency Matrix of candidate
	   * @param	storedSymbolOfStructure	structures are converted into symbol stored in one array
	   * @param	totalNumberOfThisSet	Number of the structures for this fragment set
	   * @param	totalNumberOfAtomAndBond	for one fragment, total number of atom and bond
	   */
	  public void getFinalStructure(List setOfBasicFragment,int[][] adjacencyMatrix,IntArray storedSymbolOfStructure,int[] totalNumberOfThisSet,int totalNumberOfAtomAndBond)
	  {
		  int i,j,decomposedNumber,row,column,size;
		  int m;
		  int kk,k1;

		  List originalSet=new ArrayList();
		  int[] isDecomposed=new int[adjacencyMatrix.length];
		  int[] parentID=new int[adjacencyMatrix.length];
		  int[] decomposedLine=new int[adjacencyMatrix.length];
		  int[] connectedFragment=new int[adjacencyMatrix.length];
		  int[][] originMatrix=new int[adjacencyMatrix.length][adjacencyMatrix.length];
		  int[] b=new int[400];
		  int[][] connectivity;

		  decomposedNumber=0;
		  for(i=0;i<adjacencyMatrix.length;i++)
		  {
			 isDecomposed[i]=-1;
			 parentID[i]=-1;
			 decomposedLine[i]=-1;
			 connectedFragment[i]=-1;
		  }

		  for(i=0;i<adjacencyMatrix.length;i++)
		  {
			  if(((BasicFragment)(setOfBasicFragment.get(i))).getID()>33)
			  {
				 isDecomposed[i]=((BasicFragment)(setOfBasicFragment.get(i))).getID();
				 parentID[i]=((BasicFragment)(setOfBasicFragment.get(i))).getParentID();
				 decomposedNumber+=1;
			  }
		   }

		   decomposedNumber/=2;
		   if(decomposedNumber>0)
		   {
			for(i=0;i<adjacencyMatrix.length;i++)
			{
				if(isDecomposed[i]==-1)originalSet.add(((BasicFragment)(setOfBasicFragment.get(i))));
				else
				{
					if(decomposedLine[i]==1)continue;
					for(j=i+1;j<adjacencyMatrix.length;j++)
					{
						if(isDecomposed[i]!=isDecomposed[j] && parentID[i]==parentID[j] && j>i && decomposedLine[j]==-1)
						{
							originalSet.add((BasicFragment)(basicFragment.get(parentID[i]-1)));
							decomposedLine[j]=1;
							connectedFragment[j]=i;
							connectedFragment[i]=j;
							break;
						}
					}
				}
			}
			row=0;
			for(i=0;i<adjacencyMatrix.length;i++)
			{
				int number=connectedFragment[i];

				if(decomposedLine[i]==1)continue;
				else if(number>0)
				{
					if(decomposedLine[number]==1)
					{
						originMatrix[row][row]=0;
						column=0;
						for(j=0;j<adjacencyMatrix.length;j++)
						{
							if(decomposedLine[j]==-1)
							{
								int correspondingLine=connectedFragment[j];
								if(correspondingLine!=-1)
								{
									if(adjacencyMatrix[i][j]>0)
									{
										originMatrix[row][column]=adjacencyMatrix[i][j];
										column+=1;
									}
									else if(adjacencyMatrix[i][correspondingLine]>0)
									{
										originMatrix[row][column]=adjacencyMatrix[i][correspondingLine];
										column+=1;
									}
									else if(adjacencyMatrix[number][correspondingLine]>0)
									{
										originMatrix[row][column]=adjacencyMatrix[number][correspondingLine];
										column+=1;
									}
									else if(adjacencyMatrix[number][j]>0)
									{
										originMatrix[row][column]=adjacencyMatrix[number][j];
										column+=1;
									}
									else
									{
										originMatrix[i][j]=0;
										column+=1;
									}

								}
								else
								{

									originMatrix[row][column]=adjacencyMatrix[i][j]+adjacencyMatrix[connectedFragment[i]][j];
									column+=1;
								}
							}
						}
						row+=1;
					}
				}
				else if(number<0)
				{
					originMatrix[row][row]=0;
					column=0;
					for(j=0;j<adjacencyMatrix.length;j++)
					{

						if(decomposedLine[j]==-1)
						{
							if(connectedFragment[j]==-1)
							{
								originMatrix[row][column]=adjacencyMatrix[i][j];
								column+=1;
							}
							else if(decomposedLine[connectedFragment[j]]==1)
							{
								originMatrix[row][column]=adjacencyMatrix[i][j]+adjacencyMatrix[i][connectedFragment[j]];
								column+=1;
							}