Cleaning the AlgorithmicGroupTheory Repository and updating MAVEN files

Author: MehmetAzizYirik

.settings/org.eclipse.core.resources.prefs

@@ -1,3 +1,2 @@
 eclipse.preferences.version=1
 encoding//src/main/java/AlgorithmicGroupTheory/PermutationGroupFunctions.java=UTF-8
-encoding//src/test/java/testCanonicalBlockwiseTest.java=UTF-8

hs_err_pid21084.log

@@ -3,14 +3,7 @@
   <groupId>AlgorithmicGroupTheory</groupId>
   <artifactId>AlgorithmicGroupTheory</artifactId>
   <version>1.0</version>
-  <name>AlgorithmicGroupTheory</name>
-  <description>This project is for Algorithmic group theory, especially for orbit calculations.</description>
-  <packaging>jar</packaging>
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    <maven.compiler.source>1.8</maven.compiler.source>
- 	<maven.compiler.target>1.8</maven.compiler.target>
-  </properties>
+  <description>This project is for Algorithmic group theory, especially for implementation in molecular structure generation.</description>
   <dependencies>  
 	<!-- https://mvnrepository.com/artifact/org.junit/junit -->
 	<dependency>
@@ -158,13 +151,13 @@
       			<archive>
         			<manifest>
          				<addClasspath>true</addClasspath>
-          				<mainClass>AlgorithmicGroupTheory/canonicalBlockwiseTest</mainClass>
+          				<mainClass>AlgorithmicGroupTheory/MORGEN</mainClass>
         			</manifest>
       			</archive>
-        		<finalName>AlgorithmicGroupTheory</finalName>   
+        		<finalName>MORGEN</finalName> 
         		<descriptorRefs>
         			<descriptorRef>jar-with-dependencies</descriptorRef>
-      			</descriptorRefs>               
+      			</descriptorRefs>                 
     		</configuration>
   		</plugin> 
 	</plugins>

hs_err_pid9244.log

@@ -35,13 +35,9 @@
 package AlgorithmicGroupTheory;
 
 import java.io.FileNotFoundException;
-import java.io.IOException;
 import java.io.UnsupportedEncodingException;
-import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
@@ -59,7 +55,6 @@
 import org.openscience.cdk.interfaces.IAtom;
 import org.openscience.cdk.interfaces.IAtomContainer;
 import org.openscience.cdk.interfaces.IChemObjectBuilder;
-import org.openscience.cdk.interfaces.IIsotope;
 import org.openscience.cdk.interfaces.IMolecularFormula;
 import org.openscience.cdk.silent.AtomContainer;
 import org.openscience.cdk.silent.SilentChemObjectBuilder;
@@ -138,7 +133,7 @@ public static int[] setValues(int[] partition, int[] degrees) {
 			capacity[i]=(degrees[sum-1]-1)*partition[i];
 			i++;
 		}
-
+		
 		HydrogenDistributor.capacity=capacity;
 		HydrogenDistributor.valences=valences;
 		HydrogenDistributor.totalAtom=totalAtom;

hs_err_pid9764.log

@@ -15,6 +15,13 @@
 import java.util.Set;
 import java.util.stream.IntStream;
 
+import org.apache.commons.cli.CommandLine;
+import org.apache.commons.cli.CommandLineParser;
+import org.apache.commons.cli.DefaultParser;
+import org.apache.commons.cli.HelpFormatter;
+import org.apache.commons.cli.Option;
+import org.apache.commons.cli.Options;
+import org.apache.commons.cli.ParseException;
 import org.openscience.cdk.Atom;
 import org.openscience.cdk.DefaultChemObjectBuilder;
 import org.openscience.cdk.depict.DepictionGenerator;
@@ -273,7 +280,6 @@ public static void initialDegrees(){
 
 	 public static void build(String mol) throws IOException, CloneNotSupportedException, CDKException {
 		 for(int i=0;i<firstSymbols.size();i++) {
-			 System.out.println(firstSymbols.get(i)+" "+firstOccurrences.get(i));
 			 for(int j=0;j<firstOccurrences.get(i);j++) {
 				 atomContainer.addAtom(new Atom(firstSymbols.get(i)));
 			 }
@@ -737,7 +743,18 @@ public static int[][] forwardSubRow(int lInverse, int cInverse, int maximalX,int
 					}
 					//IAtomContainer molden= buildC(addHydrogens(mat2,hIndex));
 					if(connectivityTest(hIndex,addHydrogens(mat2,hIndex))){
-						/**pWriter.println("canonical matrix"+" "+count);
+						/**System.out.println("**************");
+						for(int s=0;s<10;s++) {
+							for(int k=0; k<s;k++) {
+								System.out.print(" ");
+							}
+							for(int k=s+1; k<10;k++) {
+								System.out.print(mat2[s][k]);
+							}
+							System.out.println();
+						}
+						System.out.println("**************");
+						pWriter.println("canonical matrix"+" "+count);
 						for(int s=0;s<6;s++) {
 							for(int k=0; k<s;k++) {
 								pWriter.print(" ");
@@ -747,8 +764,8 @@ public static int[][] forwardSubRow(int lInverse, int cInverse, int maximalX,int
 							}
 							pWriter.println();
 						}**/
-						//IAtomContainer mol= buildC(addHydrogens(mat2,hIndex));
-						//outFile.write(mol);
+						IAtomContainer mol= buildC(addHydrogens(mat2,hIndex));
+						outFile.write(mol);
 						//depict(mol,filedir+count+".png");
 						count++;
 					}
@@ -880,10 +897,8 @@ public static int nextCount(int i, int size, Integer[] degrees, ArrayList<Intege
 		 }
 		 return count;
 	 }
-	 public static void run(String molecularFormula, String filePath) throws IOException, CDKException, CloneNotSupportedException {
+	 public static void run() throws IOException, CDKException, CloneNotSupportedException {
 		 long startTime = System.nanoTime(); 
-		 formula=molecularFormula;
-		 filedir=filePath;
 		 getSymbolsOccurrences(formula);
 		 initialDegrees();
 		 //initialPartition=occurrences;
@@ -929,24 +944,22 @@ public static List<int[]> distributeHydrogens(ArrayList<Integer> partition, int[
 	 public static void canonicalBlockbasedGeneratorDemo() throws IOException, CloneNotSupportedException, CDKException{
 		size=initialDegrees.length;
 		List<int[]> newDegrees= distributeHydrogens(firstOccurrences, firstDegrees);
+		//System.out.println(initialPartition);
 		//partitionList.add(0,initialPartition);		
 		/**int[] newDegrees = new int[6];
 		newDegrees[0]=3;
 		newDegrees[1]=3;
 		newDegrees[2]=3;
 		newDegrees[3]=3;
 		newDegrees[4]=3;
-		newDegrees[5]=3;**/
-		//genStrip(newDegrees);
+		newDegrees[5]=3;
+		genStrip(newDegrees);**/
 		for(int[] degree: newDegrees) {
 			partitionList.clear();
 			formerPermutations.clear();
 			//genDemo(degree);
 			initialPartition=getPartition(degree,occurrences);
-			System.out.println(Arrays.toString(degree)+" "+initialPartition);
-			System.out.println("count"+" "+count);
 			partitionList.add(0,initialPartition);
-			System.out.println("hIndex"+" "+hIndex);
 			genStrip(degree);
 		}
 	 } 
@@ -1507,10 +1520,62 @@ public static ArrayList<Integer> partitionCriteria(ArrayList<Integer> partEx, in
 		 return partNew;
 	 }
 
-	public static void main(String[] args) throws IOException, CDKException, CloneNotSupportedException {
-		//FileWriter fWriter = new FileWriter("C:\\Users\\mehme\\Desktop\\No-Backup Zone\\outputs\\output.txt"); 
-		//pWriter = new PrintWriter(fWriter);
-		run("C3NO2SH7","C:\\Users\\mehme\\Desktop\\No-Backup Zone\\outputs\\");
-		//pWriter.close();
+	 private void parseArgs(String[] args) throws ParseException, IOException, org.apache.commons.cli.ParseException{
+		 Options options = setupOptions(args);	
+		 CommandLineParser parser = new DefaultParser();
+		 try {
+			 CommandLine cmd = parser.parse(options, args);
+			 MORGEN.formula = cmd.getOptionValue("formula");
+			 MORGEN.filedir = cmd.getOptionValue("filedir");				 
+			 if (cmd.hasOption("verbose")) MORGEN.verbose = true;		
+		 } catch (ParseException e) {
+			 HelpFormatter formatter = new HelpFormatter();
+			 formatter.setOptionComparator(null);
+			 String header = "\nGenerates 	molecular structures for a given molecular formula."
+						 + " The input is a molecular formula string."
+						 + "For example 'C2OH4'."
+						 +"For this version, the hydrogens should be kept at the end of the string."
+						 + "Besides this formula, the directory is needed to be specified for the output"
+						 + "file. \n\n";
+			 String footer = "\nPlease report issues at https://github.com/MehmetAzizYirik/AlgorithmicGroupTheory";
+			 formatter.printHelp( "java -jar AlgorithmicGroupTheory.jar", header, options, footer, true );
+			 throw new ParseException("Problem parsing command line");
+		 }
+	 }
+				
+	 private Options setupOptions(String[] args){
+		 Options options = new Options();
+		 Option formula = Option.builder("f")
+					 			.required(true)
+					 			.hasArg()
+					 			.longOpt("formula")
+					 			.desc("formula (required)")
+					 			.build();
+		 options.addOption(formula);
+		 Option verbose = Option.builder("v")
+								.required(false)
+								.longOpt("verbose")
+								.desc("print message")
+								.build();
+		 options.addOption(verbose);	
+		 Option filedir = Option.builder("d")
+					 			.required(true)
+					 			.hasArg()
+					 			.longOpt("filedir")
+					 			.desc("Creates and store the output txt file in the directory (required)")
+					 			.build();
+		 options.addOption(filedir);
+		 return options;
+	 }
+	 
+	public static void main(String[] arguments) throws IOException, CDKException, CloneNotSupportedException {
+		MORGEN gen= new MORGEN();
+		//String[] argument= {"-f","C4H8", "-d", "C:\\Users\\mehme\\Desktop\\", "-v"};
+		try {
+			gen.parseArgs(arguments);
+			MORGEN.run();
+		} catch (Exception e) {
+			if (MORGEN.verbose) e.getCause(); 
+		}
 	}
 }

nulloutput.sdf

@@ -0,0 +1,49 @@
+package AlgorithmicGroupTheory;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.openscience.cdk.exception.CDKException;
+
+public class MyRunnable implements Runnable {
+	private final int[] degree;
+
+	MyRunnable(int[] degree2) {
+		this.degree = degree2;
+	}
+
+	public ThreadLocal<ArrayList<Integer>> getPartition(int[] degrees, ArrayList<Integer> partition){
+		ThreadLocal<ArrayList<Integer>> initial= new ThreadLocal<ArrayList<Integer>>();
+		ArrayList<Integer> newPartition = new ArrayList<Integer>();
+		int i=0;
+   	 	for(Integer p:partition) {
+   	 		Integer[] subArray= trialAbstractClass.getBlocks(degrees,i,p+i);
+   	 		newPartition.addAll(trialAbstractClass.getSubPartition(subArray));
+   	 		i=i+p; 
+   	 	}
+   	    initial.set(newPartition);
+   	 	return initial;
+	}
+	
+	@Override
+	public void run() {
+			System.out.println(Arrays.toString(degree));
+			ThreadLocal<List<ArrayList<Integer>>> partList= new ThreadLocal<List<ArrayList<Integer>>>();
+			//trialAbstractClass.partitionList.clear();
+			ThreadLocal<ThreadLocal<List<ArrayList<Integer>>>> formers= new ThreadLocal<ThreadLocal<List<ArrayList<Integer>>>>();
+			//trialAbstractClass.formerPermutations.clear();
+			trialAbstractClass.initialPartition=trialAbstractClass.getPartition(degree,trialAbstractClass.occurrences);
+			//trialAbstractClass.partitionList.add(0,trialAbstractClass.initialPartition);
+			List<ArrayList<Integer>> list= new ArrayList<ArrayList<Integer>>();
+			list.add(0,trialAbstractClass.initialPartition);
+			partList.set(list);
+			try {
+				trialAbstractClass.genStrip(degree);
+			} catch (IOException | CloneNotSupportedException | CDKException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+	}
+}