import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
public IAtomContainer getStructureAsAromaticIAtomContainer() {
	IChemObjectBuilder builder = DefaultChemObjectBuilder.getInstance();
	IAtomContainer fragmentStructure = builder.newInstance(IAtomContainer.class);
	
	for(int i = 0; i < this.bondsBitArray.getSize(); i++) {
		if(this.bondsBitArray.get(i)) {
			IBond curBond = this.precursorMolecule.getStructureAsIAtomContainer().getBond(i);
			if(this.precursorMolecule.isAromaticBond(i)) curBond.setIsAromatic(true);
			for(IAtom atom : curBond.atoms()) {
				atom.setImplicitHydrogenCount(0);
				if(this.precursorMolecule.isAromaticBond(i)) atom.setIsAromatic(true);
				fragmentStructure.addAtom(atom);
			}
			fragmentStructure.addBond(curBond);
		}
	}
//	loss of hydrogens
//	MoleculeFunctions.prepareAtomContainer(fragmentStructure);
	
	return fragmentStructure;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
public IAtomContainer getStructureAsIAtomContainer() {
	IChemObjectBuilder builder = DefaultChemObjectBuilder.getInstance();
	IAtomContainer fragmentStructure = builder.newInstance(IAtomContainer.class);
	
	for(int i = 0; i < this.bondsBitArray.getSize(); i++) {
		if(this.bondsBitArray.get(i)) {
			IBond curBond = this.precursorMolecule.getStructureAsIAtomContainer().getBond(i);
			for(IAtom atom : curBond.atoms()) {
				fragmentStructure.addAtom(atom);
			}
			fragmentStructure.addBond(curBond);
		}
	}
//	loss of hydrogens
//	MoleculeFunctions.prepareAtomContainer(fragmentStructure);
	
	return fragmentStructure;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
/**
 * initialise indeces belonging to a ring in the precursor molecule
 */
protected void initialiseRingBondsBitArray() throws Exception {
	this.aromaticBonds = new BitArray(this.getNonHydrogenBondCount());
	AllRingsFinder allRingsFinder = new AllRingsFinder();
	IRingSet ringSet = allRingsFinder.findAllRings(this.precursorMolecule);
	this.initialiseRingBondToBelongingRingBondIndecesBitArrays(ringSet);
	if (ringSet.getAtomContainerCount() != 0) {
		Aromaticity arom = new Aromaticity(ElectronDonation.cdk(), Cycles.cdkAromaticSet());
		java.util.Set<IBond> aromaticBonds = arom.findBonds(this.precursorMolecule);
		java.util.Iterator<IBond> it = aromaticBonds.iterator();
		while(it.hasNext()) {
			IBond currentBond = it.next();
			this.aromaticBonds.set(this.precursorMolecule.getBondNumber(currentBond), true);
		}
	}
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
/**
 * 
 * @param molecule
 * @return
 */
public static BitArray getAromaticAtoms(IAtomContainer molecule) {
	Aromaticity arom = new Aromaticity(ElectronDonation.cdk(),
	Cycles.cdkAromaticSet());
	BitArray aromaticAtoms = new BitArray(molecule.getAtomCount());
	try {
		AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molecule);
		arom.apply(molecule);
		Set<IBond> aromaticBonds = arom.findBonds(molecule);
		Iterator<IBond> it = aromaticBonds.iterator();
		while(it.hasNext()) {
			IBond bond = it.next();
			for(int k = 0; k < bond.getAtomCount(); k++)
				aromaticAtoms.set(molecule.getAtomNumber(bond.getAtom(k)));
		}
	} catch (CDKException e) {
		e.printStackTrace();
	}
	return aromaticAtoms;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private ECFPFeature computeIterationForAtom(IAtom atom) throws FingerPrinterException, MoltyperException{
	ECFPFeature oldFeature = featuresOfLastIteration.get(atom);
       IAtomContainer newSubstructure = oldFeature.getNonDeepCloneOfSubstructure();
	List<BondOrderIdentifierTupel> connectivity = new ArrayList<BondOrderIdentifierTupel>();

	for(IAtom connectedAtom: molecule.getConnectedAtomsList(atom)){
		int identifierOfConnectedAtom = featuresOfLastIteration.get(connectedAtom).hashCode();
		//System.out.println("iterate "+connectedAtom.getAtomTypeName()+",id="+identifierOfConnectedAtom+",id="+featuresOfLastIteration.get(connectedAtom).featureToString(true));
		connectivity.add(new BondOrderIdentifierTupel(this.getBondOrder(molecule.getBond(atom,connectedAtom)),identifierOfConnectedAtom));
           IAtomContainer structure = this.featuresOfLastIteration.get(connectedAtom).representedSubstructure();
		for(IAtom a: structure.atoms()){
			if(!newSubstructure.contains(a))
				newSubstructure.addAtom(a);
		}
		for(IBond b: structure.bonds()){
			if(!newSubstructure.contains(b))
				newSubstructure.addBond(b);
		}
	}
	
	ECFPFeature newFeature = new ECFPFeature(this, molecule, atom, newSubstructure, this.iteration,oldFeature.hashCode(), connectivity);
	return newFeature;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private ArrayList<DanglingBond> detectDanglingBonds(){
	ArrayList<DanglingBond> danglingBonds = new ArrayList<DanglingBond>();
	try{
		for(IBond bond: substructure.bonds()){
			if(!substructure.contains(bond.getAtom(0))){
				danglingBonds.add(new DanglingBond(bond, bond.getAtom(0)));
				continue;
			}if(!substructure.contains(bond.getAtom(1)))
				danglingBonds.add(new DanglingBond(bond, bond.getAtom(1)));
		}
	}catch(FingerPrinterException e){
		e.printStackTrace();
		return null;
	}
	return danglingBonds;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private boolean shouldAddH(IAtomContainer mol, IAtom atom, Iterable<IBond> bonds) {
  int count = 0;
  for (IBond bond : bonds) {
    if (bond.isInRing()) {
      ++count;
    } else {
      IAtom nbr = bond.getOther(atom);
      for (IStereoElement se : mol.stereoElements()) {
        if (se.getConfigClass() == IStereoElement.TH &&
                se.getFocus().equals(nbr)) {
          count++;
        }
      }
    }
  }
  return count == 3;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
/**
 *  Tells if a certain bond is center of a valid double bond configuration.
 *
 *@param  container  The atomcontainer.
 *@param  bond       The bond.
 *@return            true=is a potential configuration, false=is not.
 */
public boolean isValidDoubleBondConfiguration(IAtomContainer container, IBond bond)
{
	IAtom atom0 = bond.getAtom(0);
	IAtom atom1 = bond.getAtom(1);
	List<IAtom> connectedAtoms = container.getConnectedAtomsList(atom0);
	IAtom from = null;
       for (IAtom connectedAtom : connectedAtoms) {
           if (connectedAtom != atom1) {
               from = connectedAtom;
           }
       }
       boolean[] array = new boolean[container.getBondCount()];
	for (int i = 0; i < array.length; i++)
	{
		array[i] = true;
	}
	if (isStartOfDoubleBond(container, atom0, from, array) && isEndOfDoubleBond(container, atom1, atom0, array) && !bond.getFlag(CDKConstants.ISAROMATIC))
	{
		return (true);
	} else
	{
		return (false);
	}
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private IAtom hasWedges(IAtomContainer ac, IAtom a)
	{
        List<IAtom> atoms = ac.getConnectedAtomsList(a);
        //		for (int i = 0; i < atoms.size(); i++)
//		{
//			atomi = (IAtom)atoms.get(i);
//			if (ac.getBond(a, atomi).getStereo() != IBond.Stereo.NONE && !atomi.getSymbol().equals("H"))
//			{
//				return (atomi);
//			}
//		}
        for (IAtom atom : atoms) {
            if (ac.getBond(a, atom).getStereo() != IBond.Stereo.NONE) {
                return (atom);
            }
        }
        return (null);
	}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
/**
 *  Append the symbol for the bond order between <code>a1</code> and <code>a2</code>
 *  to the <code>line</code>.
 *
 *@param  line           the StringBuffer that the bond symbol is appended to.
 *@param  a1             Atom participating in the bond.
 *@param  a2             Atom participating in the bond.
 *@param  atomContainer  the AtomContainer that the SMILES string is generated
 *      for.
  	 *@param useAromaticity				true=aromaticity or sp2 will trigger lower case letters, wrong=only sp2
 */
private void parseBond(StringBuffer line, IAtom a1, IAtom a2, IAtomContainer atomContainer, boolean useAromaticity)
{
	//logger.debug("in parseBond()");
	if (useAromaticity && a1.getFlag(CDKConstants.ISAROMATIC) && a2.getFlag(CDKConstants.ISAROMATIC))
	{
		return;
	}
	if (atomContainer.getBond(a1, a2) == null)
	{
		return;
	}
	IBond.Order type = atomContainer.getBond(a1, a2).getOrder();
	if (type == IBond.Order.SINGLE) {
	} else if (type == IBond.Order.DOUBLE) {
		line.append("=");
	} else if (type == IBond.Order.TRIPLE) {
		line.append("#");
	} else {
		// //logger.debug("Unknown bond type");
	}
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private void initLearn (List<Residue> roots, ResidueMappings mappings) {
	for (Residue res : roots) {
		List<MappedChain> resMappings = new ArrayList<>();
		
		for (IBond bond : res.getMolecule().bonds()) {
			Extension ext = new Extension(bond);
			Chain bloc = new Chain(ext);
			String smiles = bloc.getMySmiles();
			this.chains.put(smiles, bloc);
			this.frequence.put(smiles, 0);
			
			// Creation of residue matchings (sequences of size 1)
			for (BondMapping bm : ext.match(bond, MatchingType.EXACT)) {
				MappedChain resMap = this.createMappingFromMatch(res, bond, bloc, bm);
				resMappings.add(resMap);
			}
		}
		
		mappings.put(res, resMappings);
	}
	
	this.frequencesInit();
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private MappedChain createMappingFromMatch(ChemicalObject co, IBond bond, Chain bloc, BondMapping bm) {
	List<Integer> atoms = new ArrayList<>();
	atoms.add(co.getMolecule().getAtomNumber(bm.a0));
	atoms.add(co.getMolecule().getAtomNumber(bm.a1));
	
	List<Integer> bonds = new ArrayList<>();
	bonds.add(co.getMolecule().getBondNumber(bond));
	
	List<MatchingType> types = new ArrayList<>();
	types.add(MatchingType.EXACT);
	
	Map<Integer, Integer> hydrogens = new HashMap<>();
	hydrogens.put(co.getMolecule().getAtomNumber(bm.a0), bm.h0);
	hydrogens.put(co.getMolecule().getAtomNumber(bm.a1), bm.h1);
	
	return new MappedChain(co, bloc, atoms, bonds, types, hydrogens);
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private List<MappedChain> createBlocsFromPrevious (List<MappedChain> prevMbs) {
	List<MappedChain> nextMbs = new ArrayList<>();
	
	for (MappedChain mb : prevMbs) {
		
		ChemicalObject co = mb.getChemObject();
		IMolecule mol = co.getMolecule();
		
		List<Integer> neighbors = mb.getNeighborsBonds(mol);
		// Create a new bloc for each neighbor
		for (int idx : neighbors) {
			// Create bloc
			IBond nb = mol.getBond(idx);
			Extension ext = new Extension(nb);
			
			//Extension.setAromacityTest(false);
			List<MappedChain> newMbs = Isomorphism.searchFromPreviousMapping (mb, ext, MatchingType.EXACT);
			//Extension.setAromacityTest(true);
			
			nextMbs.addAll(newMbs);
		}

	}

	return nextMbs;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private boolean lightToStrongMatching (IAtom a1, IAtom a2, int ha1, int ha2,
		IAtom b1, IAtom b2, int hb1, int hb2,
		IBond l1, IBond l2) {
	// Aromatic matching
	if (a1.getFlag(CDKConstants.ISAROMATIC) != b1.getFlag(CDKConstants.ISAROMATIC) ||
			a2.getFlag(CDKConstants.ISAROMATIC) != b2.getFlag(CDKConstants.ISAROMATIC))
		return false;/**/
	
	// Bond type
	if (l1.getOrder() != l2.getOrder())
		return false;
	
	// Hydrogens
	if (ha1 > hb1 || ha2 > hb2)
		return false;
	
	return true;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
	// Database
	Monomer[] monos = new Monomer[1];
	Polymer pepTest = new Polymer(0, "malformin A1", "O=C1NC2C(=O)NC(C(=O)NC(C(=O)NC(C(=O)NC1CSSC2)C(C)CC)CC(C)C)C(C)C", monos);
	
	// Extensions
	IAtom a = new Atom("C");
	IBond b1 = new Bond(new Atom("S"), a, Order.SINGLE);
	this.ext1 = new Extension(b1);
	a = new Atom("C");
	IAtom a2 = new Atom("C");
	IBond b2 = new Bond(a, a2, Order.SINGLE);
	this.ext2 = new Extension(b2);
	
	// Mapped blocs
	this.mb0 = new MappedChain(pepTest, null, new ArrayList<Integer>(), new ArrayList<Integer>(), new ArrayList<MatchingType>(), new HashMap<Integer, Integer>());
	
	// For blocs Tests
	this.bloc = new Chain("S,0,c,0,0,-1,-1;c,0,c,0,0,-1,1");
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
@Override
void process(IAtomContainer mol) {
    long  t0   = System.nanoTime();
    int[] prev = new int[mol.getAtomCount()];
    int[] next = new int[mol.getAtomCount()];
    for (int i = 0; i < mol.getAtomCount(); i++) {
        next[i] = prev[i] = mol.getAtom(i).getAtomicNumber();
    }
    for (int rep = 0; rep < mol.getAtomCount(); rep++) {
        for (int j = 0; j < mol.getAtomCount(); j++) {
            IAtom atom = mol.getAtom(j);
            for (IBond bond : mol.getConnectedBondsList(atom)) {
                IAtom nbr = bond.getConnectedAtom(atom);
                next[j] += prev[mol.getAtomNumber(nbr)];
            }
        }
        System.arraycopy(next, 0, prev, 0, next.length);
    }
    long t1 = System.nanoTime();
    tRun += t1 - t0;
    for (int aNext : next) check += aNext;
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private static void highlightSmartsPattern(IAtomContainer container, Color highlightColor, String smarts) {
    if (smarts == null)
        return;
    try {
        Pattern ptrn = SmartsPattern.create(smarts,
                                            SilentChemObjectBuilder.getInstance());
        Mappings mappings = ptrn.matchAll(container);

        int[] p = mappings.first();
        for (int x : p) {
            container.getAtom(x).setProperty(HIGHLIGHT_COLOR,
                                             highlightColor);
        }
        for (IBond bond : container.bonds()) {
            if (bond.getAtom(0).getProperty(HIGHLIGHT_COLOR) != null && bond.getAtom(1).getProperty(HIGHLIGHT_COLOR) != null)
                bond.setProperty(HIGHLIGHT_COLOR,
                                 highlightColor);
        }
    } catch (IOException e) {
        System.err.println(e.getMessage());
    }
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private void setScale(IAtomContainerSet set) {
    List<Double> lengths = new ArrayList<Double>();
    for (IAtomContainer container : set.atomContainers()) {
        for (IBond bond : container.bonds()) {
            lengths.add(GeometryUtil.getLength2D(bond));
        }
    }

    if (lengths.size() == 0) {
        setScaleForBondLength(0.826);
    }
    else {
        // median
        setScaleForBondLength(lengths.get(lengths.size() / 2));
    }
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
public MolStruct( IAtomContainer base )
{	
	super( new AtomContainer(AtomContainerManipulator.removeHydrogens(base)) );
	mol_ids = new HashSet<PubchemID>();
	
	Iterator<IAtom> atoms = this.atoms().iterator();
	while( atoms.hasNext() ){
		IAtom atom = atoms.next();
		atom.setAtomTypeName("S");
		atom.setSymbol("C");
	}
	Iterator<IBond> bonds = this.bonds().iterator();
	while( bonds.hasNext() ){
		IBond bond = bonds.next();
		bond.setOrder(IBond.Order.SINGLE);
	}
	
	makeGraph(this);

	setFingerprint();
	
	PubchemID pubID = MolUtils.getPubID(base);
	this.mol_ids.add( pubID);
	this.setProperty("PUBCHEM_COMPOUND_CID", pubID.toString());
}
 

import org.openscience.cdk.interfaces.IBond; //导入依赖的package包/类
private void makeGraph(IAtomContainer base){
	graph = new SparseUndirectedGraph();
	for(int i=0; i<base.getAtomCount(); i++){
		graph.add(i);
		atomsToNodes.put(base.getAtom(i), i);
		nodesToAtoms.put(i, base.getAtom(i));
		for(int j=0; j<i; j++){
			IBond bond = base.getBond(base.getAtom(i), base.getAtom(j));
			if(  bond != null){
				Edge newEdge = new SimpleEdge(i,j);
				bondsToEdges.put(bond, newEdge);
				edgesToBonds.put(newEdge, bond);
				graph.add( newEdge);
			}
		}
	}
}