/** Produce the secondary radius based upon the second atom radius. */ public float getSplitBondRadius(final Bond bond) { final Atom atom = bond.getAtom(1); final StructureMap structureMap = atom.getStructure().getStructureMap(); final StructureStyles structureStyles = structureMap.getStructureStyles(); final AtomStyle atomStyle = (AtomStyle) structureStyles.getStyle(atom); return this.scale * atomStyle.getAtomRadius(atom); }
/* public void fixAtomsOfBond(){ // do fix bonds of Atom first ArrayList<Atom> temp = new ArrayList<Atom>(atomList.size()); ArrayList<Bond> temp2 = new ArrayList<Bond>(bondList.size()); for(int i = 0; i < temp2.size(); i++){ // iterates bondList for(int j = 0; j < atomList.size(); j++){//iterates atomlist temp2 = atomList.get(j).getAdjacentBonds(); for(int k = 0; k < temp2.size(); k++){ //iterates bonds on atomList if(temp2.get(k).getEdgeNum() == bondList.get(k).getEdgeNum()){ temp.set(k, bondList.get(j)); } } bondList.get(i).setAdjacentAtoms(temp); } } } */ public String toString() { String temp = " "; if (atomList == null) { return "Null found for atomList"; } for (Atom a : atomList) { temp = temp.concat(a.toString()) + "\n"; } if (bondList == null) { return "Null found for bondList"; } if (bondList.isEmpty()) { temp += " bondList is empty"; // return "bondList is empty"; } for (Bond b : bondList) { temp = temp.concat(b.toString()) + "\n"; } return temp; }
@Test public void testSetSorting() { Set<String> stringHashSet = Sets.newHashSet("b", "a", "z", "g"); Set<StringObject> stringObjectHashSet = Sets.newHashSet( new StringObject("b"), new StringObject("a"), new StringObject("z"), new StringObject("g")); Bond.obs("stringHashSet", serializer.serialize(stringHashSet)) .obs("stringObjectHashSet", serializer.serialize(stringObjectHashSet)) .spy("hash sets"); Set<String> stringOnlyTreeSet = new TreeSet<>(REVERSE_SORT_COMPARATOR); stringOnlyTreeSet.add("b"); stringOnlyTreeSet.add("a"); stringOnlyTreeSet.add("z"); stringOnlyTreeSet.add("g"); Bond.obs("stringOnlyTreeSet", serializer.serialize(stringOnlyTreeSet)).spy("tree sets"); }
@Test public void testBond() { Fragment frag = new Fragment(mock(Element.class)); Atom a1 = new Atom(1, ChemEl.C, frag); Atom a2 = new Atom(2, ChemEl.C, frag); frag.addAtom(a1); frag.addAtom(a2); Bond bond = new Bond(a1, a2, 1); assertNotNull("Got bond", bond); assertEquals("From = 1", 1, bond.getFrom()); assertEquals("To = 2", 2, bond.getTo()); assertEquals("Order = 1", 1, bond.getOrder()); assertEquals(a1, bond.getFromAtom()); assertEquals(a2, bond.getToAtom()); assertEquals(a2, bond.getOtherAtom(a1)); assertEquals(a1, bond.getOtherAtom(a2)); assertEquals(null, bond.getBondStereo()); assertEquals(null, bond.getSmilesStereochemistry()); }
@Test public void testMapSorting() { Map<String, String> stringOnlyHashMap = new HashMap<>(); stringOnlyHashMap.put("b", "bar"); stringOnlyHashMap.put("a", "foo"); stringOnlyHashMap.put("z", "baz"); stringOnlyHashMap.put("g", "test"); Map<StringObject, String> stringObjectHashMap = new HashMap<>(); stringObjectHashMap.put(new StringObject("b"), "bar"); stringObjectHashMap.put(new StringObject("a"), "foo"); stringObjectHashMap.put(new StringObject("z"), "baz"); stringObjectHashMap.put(new StringObject("g"), "test"); Bond.obs("stringOnlyHashMap", serializer.serialize(stringOnlyHashMap)) .obs("stringObjectHashMap", serializer.serialize(stringObjectHashMap)) .spy("hash maps"); Map<String, String> stringOnlyTreeMap = new TreeMap<>(REVERSE_SORT_COMPARATOR); stringOnlyTreeMap.put("b", "bar"); stringOnlyTreeMap.put("a", "foo"); stringOnlyTreeMap.put("z", "baz"); stringOnlyTreeMap.put("g", "test"); Bond.obs("stringOnlyTreeMap", serializer.serialize(stringOnlyTreeMap)).spy("tree maps"); }
@Test public void testCustomTypeAdapter() { serializer = serializer.withTypeAdapter( StringObject.class, new JsonSerializer<StringObject>() { @Override public JsonElement serialize( StringObject strObj, Type type, JsonSerializationContext jsc) { return new JsonPrimitive(strObj.toString() + ", with custom serialization!"); } }); Bond.obs("StringObject", serializer.serialize(new StringObject("foobar"))).spy(); }
public void paintComponent(Graphics g) { clearScreen(g); drawGrid(g); drawElements(g); if (drawBondLine == true) { Bond.drawDrag(g, Color.MAGENTA, elist.getSelected(), currentX, currentY); } if (drawArrowLine == true) { Arrow.drawDrag(g, Color.BLUE, elist.getSelected(), currentX, currentY); } drawConnections(g); }
@Test public void testBondMutation() { Fragment frag = new Fragment(mock(Element.class)); Atom a1 = new Atom(1, ChemEl.C, frag); Atom a2 = new Atom(2, ChemEl.C, frag); Atom a3 = new Atom(3, ChemEl.C, frag); Atom a4 = new Atom(4, ChemEl.C, frag); frag.addAtom(a1); frag.addAtom(a2); frag.addAtom(a3); frag.addAtom(a4); Bond bond = new Bond(a2, a3, 1); bond.setOrder(2); assertEquals("Order = 2", 2, bond.getOrder()); BondStereo bondStereo = new BondStereo(new Atom[] {a1, a2, a3, a4}, BondStereoValue.TRANS); bond.setBondStereo(bondStereo); assertEquals(bondStereo, bond.getBondStereo()); bond.setSmilesStereochemistry(SMILES_BOND_DIRECTION.LSLASH); assertEquals(SMILES_BOND_DIRECTION.LSLASH, bond.getSmilesStereochemistry()); }
@Test public void testNestedSorting() { Set<String> stringHashSet = Sets.newHashSet("b", "a", "z", "g"); Map<String, String> stringHashMap = new HashMap<>(); stringHashMap.put("b", "bar"); stringHashMap.put("a", "foo"); stringHashMap.put("z", "baz"); stringHashMap.put("g", "test"); NestingObject no = new NestingObject(); no.stringMap = stringHashMap; no.stringSet = stringHashSet; Map<String, Object> objectMap = new HashMap<>(); objectMap.put("nestingObject", no); objectMap.put("hashSet", stringHashSet); objectMap.put("hashMap", stringHashMap); Set<Object> objectSet = Sets.newHashSet(stringHashSet, stringHashMap, no); Bond.obs("objectMap", serializer.serialize(objectMap)) .obs("objectSet", serializer.serialize(objectSet)) .spy(); }
public static void makeBonds( ArrayList<Atom> atomList, ArrayList<Bond> bondList, int aLoc, int bLoc) { Atom a = atomList.get(aLoc); Atom b = atomList.get(bLoc); if (aLoc != bLoc) { // rough distance if (getRoughDist(a, b) < maxBondLength) { Double dist = getDist(a, b); if (dist < maxBondLength) { boolean skip = false; // System.out.println(atomList.get(target).connectedTo.size()); for (int i = 0; i < b.connectedTo.size(); i++) { if (b.connectedTo.get(i) == aLoc) { skip = true; } } if (!skip) { Bond newBond = new Bond(); newBond.setTargets(aLoc, bLoc); newBond.getBondAvg(a, b); if (stick && dist <= newBond.getMaxDist()) { newBond.setStick(true); } else { newBond.setStick(false); } bondList.add(newBond); bondsMade++; b.connectedTo.add(aLoc); a.connectedTo.add(bLoc); } } } } bondsChecked++; }
public void writeMeat() { try { for (int i = 0; i < aList.size(); i++) { w.write("{"); w.newLine(); Atom tempA = aList.get(i); w.write("\t" + "\"" + "vertexNum" + "\":" + tempA.getVertexNum() + "\","); w.newLine(); w.write("\t" + "\"" + "atomicNum" + "\":" + tempA.getAtomicNum() + "\","); w.newLine(); w.write("\t" + "\"" + "atomicWeight" + "\":" + tempA.getAtomicWeight() + "\","); w.newLine(); w.write("\t" + "\"" + "electroNeg" + "\":" + tempA.getElectroNeg() + "\","); w.newLine(); w.write("\t" + "\"" + "atomName" + "\":" + tempA.getAtomName() + "\","); w.newLine(); w.write("\t" + "\"" + "adjacentBonds" + "\": {"); w.newLine(); for (int z = 0; z < tempA.getAdjacentBonds().size(); z++) { w.write("\t\t" + "["); w.newLine(); w.write( "\t\t\t" + "\"" + "edgeNum" + "\":" + tempA.getAdjacentBonds().get(z).getEdgeNum() + "\","); w.newLine(); w.write( "\t\t\t" + "\"" + "bondType" + "\":" + tempA.getAdjacentBonds().get(z).getBondType() + "\","); w.newLine(); w.write( "\t\t\t" + "\"" + "exist" + "\":" + tempA.getAdjacentBonds().get(z).getExist() + "\","); w.newLine(); w.write("\t\t\t" + "\"" + "weight" + "\":" + tempA.getAdjacentBonds().get(z).getWeight()); w.newLine(); w.write("\t\t" + "]"); w.newLine(); } w.write("\t" + "}"); w.newLine(); } for (int p = 0; p < bList.size(); p++) { Bond tempB = bList.get(p); w.write("{"); w.newLine(); w.write("\t" + "\"" + "edgeNum" + "\":" + tempB.getEdgeNum() + "\","); w.newLine(); w.write("\t" + "\"" + "bondType" + "\":" + tempB.getBondType() + "\","); w.newLine(); w.write("\t" + "\"" + "exist" + "\":" + tempB.getExist() + "\","); w.newLine(); w.write("\t" + "\"" + "weight" + tempB.getWeight() + "\":"); w.newLine(); w.write("\t" + "\"" + "adjacentAtoms" + "\": {"); w.newLine(); w.write("\t\t" + "\"" + "vertexNum" + "\":" + "\","); w.newLine(); w.write("\t\t" + "\"" + "atomicNum" + "\":" + "\","); w.newLine(); w.write("\t\t" + "\"" + "atomicWeight" + "\":" + "\","); w.newLine(); w.write("\t\t" + "\"" + "electroNeg" + "\":" + "\","); w.newLine(); w.write("\t\t" + "\"" + "atomName" + "\":" + "\","); w.newLine(); } w.write("\t" + "}"); w.newLine(); } catch (IOException e) { System.out.println("error writing meat of file"); } }
@Test public void testUseToStringSerialization() { serializer = serializer.withToStringSerialization(StringObject.class); Bond.obs("StringObject.toString()", serializer.serialize(new StringObject("foobar"))).spy(); }
@Test public void testOverwriteOldDoublePrecision() { serializer = serializer.withDoublePrecision(2); serializer = serializer.withDoublePrecision(7); Bond.obs("pi", serializer.serialize(Math.PI)).spy(); }
@Test public void testRestrictedFloatPrecision() { serializer = serializer.withFloatPrecision(5); Bond.obs("1.23456789f", serializer.serialize(1.23456789f)).spy(); }
@Test public void testRestrictedDoublePrecision() { serializer = serializer.withDoublePrecision(3); Bond.obs("pi", serializer.serialize(Math.PI)).spy(); }
public AbrahamGAValue getABGroup(ChemGraph p_chemGraph) { // #[ operation getGAGroup(ChemGraph) AbramData result_abram = new AbramData(); Graph g = p_chemGraph.getGraph(); HashMap oldCentralNode = (HashMap) (p_chemGraph.getCentralNode()).clone(); // satuate radical site int max_radNum_molecule = ChemGraph.getMAX_RADICAL_NUM(); int max_radNum_atom = Math.min(8, max_radNum_molecule); int[] idArray = new int[max_radNum_molecule]; Atom[] atomArray = new Atom[max_radNum_molecule]; Node[][] newnode = new Node[max_radNum_molecule][max_radNum_atom]; int radicalSite = 0; Iterator iter = p_chemGraph.getNodeList(); FreeElectron satuated = FreeElectron.make("0"); while (iter.hasNext()) { Node node = (Node) iter.next(); Atom atom = (Atom) node.getElement(); if (atom.isRadical()) { radicalSite++; // save the old radical atom idArray[radicalSite - 1] = node.getID().intValue(); atomArray[radicalSite - 1] = atom; // new a satuated atom and replace the old one Atom newAtom = new Atom(atom.getChemElement(), satuated); node.setElement(newAtom); node.updateFeElement(); } } // add H to satuate chem graph Atom H = Atom.make(ChemElement.make("H"), satuated); Bond S = Bond.make("S"); for (int i = 0; i < radicalSite; i++) { Node node = p_chemGraph.getNodeAt(idArray[i]); Atom atom = atomArray[i]; int HNum = atom.getRadicalNumber(); for (int j = 0; j < HNum; j++) { newnode[i][j] = g.addNode(H); g.addArcBetween(node, S, newnode[i][j]); } node.updateFgElement(); } // find all the thermo groups iter = p_chemGraph.getNodeList(); while (iter.hasNext()) { Node node = (Node) iter.next(); Atom atom = (Atom) node.getElement(); if (!(atom.getType().equals("H"))) { if (!atom.isRadical()) { p_chemGraph.resetThermoSite(node); AbrahamGAValue thisAbrahamValue = thermoLibrary.findAbrahamGroup(p_chemGraph); if (thisAbrahamValue == null) { System.err.println("Abraham group not found: " + node.getID()); } else { // System.out.println(node.getID() + " " + thisGAValue.getName()+ " // "+thisGAValue.toString()); result_abram.plus(thisAbrahamValue); } } else { System.err.println("Error: Radical detected after satuation!"); } } } // // find the BDE for all radical groups // for (int i=0; i<radicalSite; i++) { // int id = idArray[i]; // Node node = g.getNodeAt(id); // Atom old = (Atom)node.getElement(); // node.setElement(atomArray[i]); // node.updateFeElement(); // // // get rid of the extra H at ith site // int HNum = atomArray[i].getRadicalNumber(); // for (int j=0;j<HNum;j++) { // g.removeNode(newnode[i][j]); // } // node.updateFgElement(); // // p_chemGraph.resetThermoSite(node); // ThermoGAValue thisGAValue = thermoLibrary.findRadicalGroup(p_chemGraph); // if (thisGAValue == null) { // System.err.println("Radical group not found: " + node.getID()); // } // else { // //System.out.println(node.getID() + " radical correction: " + // thisGAValue.getName() + " "+thisGAValue.toString()); // result.plus(thisGAValue); // } // // //recover the satuated site for next radical site calculation // node.setElement(old); // node.updateFeElement(); // for (int j=0;j<HNum;j++) { // newnode[i][j] = g.addNode(H); // g.addArcBetween(node,S,newnode[i][j]); // } // node.updateFgElement(); // // } // // // recover the chem graph structure // // recover the radical // for (int i=0; i<radicalSite; i++) { // int id = idArray[i]; // Node node = g.getNodeAt(id); // node.setElement(atomArray[i]); // node.updateFeElement(); // int HNum = atomArray[i].getRadicalNumber(); // //get rid of extra H // for (int j=0;j<HNum;j++) { // g.removeNode(newnode[i][j]); // } // node.updateFgElement(); // } // // // substrate the enthalphy of H from the result // int rad_number = p_chemGraph.getRadicalNumber(); // ThermoGAValue enthalpy_H = new ThermoGAValue(ENTHALPY_HYDROGEN * rad_number, // 0,0,0,0,0,0,0,0,0,0,0,null); // result.minus(enthalpy_H); // // // make the symmetric number correction to entropy // // if (p_chemGraph.isAcyclic()){ // int sigma = p_chemGraph.getSymmetryNumber(); // ThermoGAValue symmtryNumberCorrection = new // ThermoGAValue(0,GasConstant.getCalMolK()*Math.log(sigma),0,0,0,0,0,0,0,0,0,0,null); // result.minus(symmtryNumberCorrection); // } p_chemGraph.setCentralNode(oldCentralNode); return result_abram; // #] }