Java AtomContainerManipulator类代码示例

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
/**
 * 
 * @param container
 * @throws CDKException 
 */
protected void prepareAtomContainer(IAtomContainer container) throws CDKException {
	while(true) {
   		try {
       		AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(container);
			Aromaticity arom = new Aromaticity(ElectronDonation.cdk(), Cycles.cdkAromaticSet());
			arom.apply(container);
   		} catch (java.lang.NullPointerException e) { 
   			//bad workaround for cdk bug?! but what shall I do...
   			//sometimes NullPointerException occurs but not in one of the further trials?!
       		continue;
       	}
   		break;
       }
       CDKHydrogenAdder hAdder = CDKHydrogenAdder.getInstance(container.getBuilder());
       for(int i = 0; i < container.getAtomCount(); i++) {
      		hAdder.addImplicitHydrogens(container, container.getAtom(i));
       }
       AtomContainerManipulator.convertImplicitToExplicitHydrogens(container);
       hAdder = null;
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的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.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
/**
 * 
 * @param con
 * @return
 * @throws CDKException
 */
public static String calculateInchiKey(IAtomContainer con) throws CDKException {
	AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(con);
       CDKHydrogenAdder hAdder = CDKHydrogenAdder.getInstance(con.getBuilder());
       for(int i = 0; i < con.getAtomCount(); i++) {
       	try {
       		hAdder.addImplicitHydrogens(con, con.getAtom(i));
       	} 
       	catch(CDKException e) {
       		continue;
       	}
       }
       AtomContainerManipulator.convertImplicitToExplicitHydrogens(con);
	InChIGeneratorFactory factory = InChIGeneratorFactory.getInstance();
	InChIGenerator gen = factory.getInChIGenerator(con);
	return gen.getInchiKey().split("-")[0];
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
public static IAtomContainer getAtomContainerFromSMILES(String smiles) throws Exception {
	IAtomContainer molecule = sp.parseSmiles(smiles);
	for(int i = 0; i < molecule.getAtomCount(); i++) {
		if(molecule.getAtom(i).getSymbol().equals("H")) continue;
		else {
			java.util.List<IAtom> atoms = molecule.getConnectedAtomsList(molecule.getAtom(i));
			short numDs = 0;
			for(IAtom atom : atoms)
				if(atom.getSymbol().equals("H") && (atom.getMassNumber() != null && atom.getMassNumber() == 2))
					numDs++;
			molecule.getAtom(i).setProperty(VariableNames.DEUTERIUM_COUNT_NAME, numDs);
		}
	}
	try {
		AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molecule);
		Aromaticity arom = new Aromaticity(ElectronDonation.cdk(), Cycles.cdkAromaticSet());
		arom.apply(molecule);
	} catch (CDKException e) {
		e.printStackTrace();
	}
	return molecule;
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
/**
 * 
 * @param inchi
 * @return
 * @throws Exception 
 */
public static IAtomContainer getAtomContainerFromInChI(String inchi) throws Exception {
	de.ipbhalle.metfraglib.inchi.InChIToStructure its = inchiFactory.getInChIToStructure(inchi, DefaultChemObjectBuilder.getInstance());
	if(its == null) {
		throw new Exception("InChI problem: " + inchi);
	}
	INCHI_RET ret = its.getReturnStatus();
	if (ret == INCHI_RET.WARNING) {
	//	logger.warn("InChI warning: " + its.getMessage());
	} else if (ret != INCHI_RET.OKAY) {
		throw new Exception("InChI problem: " + inchi);
	}
	IAtomContainer molecule = its.getAtomContainer();
	try {
		AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molecule);
		Aromaticity arom = new Aromaticity(ElectronDonation.cdk(), Cycles.cdkAromaticSet());
		arom.apply(molecule);
	} catch (CDKException e) {
		e.printStackTrace();
	}
	return molecule;
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
/**
 * standard preparation protocol: remove hydrogens, types, ring detection. Uses specified errorHandler
 *
 * @param mol
 * @throws Exception
 */
public static IAtomContainer prepareMoleculeRemoveHydrogens(IAtomContainer mol, IChemObjectReaderErrorHandler errorHandler)
{
    boolean errorFlag=false;
    IAtomContainer molOrig=mol;
    try {
        AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(mol);
        Aromaticity.cdkLegacy().apply(mol);
        mol = addExplicitHydrogens(mol);

    } catch (final Exception e) {
        errorFlag=true;

        if (errorHandler != null)
            errorHandler.handleError("An error occurred while typing structure. " + e.getMessage(), e);
        else{
            System.out.println("An error occurred while typing structure, using unprocessed molecule. "+e.getMessage());
            e.printStackTrace();
        }
    }
    mol = removeHydrogens(mol);
    if(errorFlag){
        mol=molOrig;
    }
    return mol;
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
/**
 * add hydrogens
 * 
 * @param mol
 * @throws CDKException
 */
private static IAtomContainer addExplicitHydrogens(IAtomContainer mol) throws CDKException{

	CDKAtomTypeMatcher matcher = CDKAtomTypeMatcher.getInstance(mol.getBuilder());
	for (IAtom atom : mol.atoms()) {
	     IAtomType type = matcher.findMatchingAtomType(mol, atom);
	     try{
	    	 AtomTypeManipulator.configure(atom, type);
	     }
	     catch(IllegalArgumentException e){
	    	 throw new CDKException(e.toString()+" for atom "+atom.getAtomicNumber()+" "+atom.getSymbol());
	     }
	   }
	CDKHydrogenAdder hydrogenAdder = CDKHydrogenAdder.getInstance(mol.getBuilder());
	hydrogenAdder.addImplicitHydrogens(mol);
	AtomContainerManipulator.convertImplicitToExplicitHydrogens(mol);

	return mol;

}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private String fillLinksJSO(JSONArray links, Residue res) {
	IMolecule mol = res.getMolecule();
	AtomContainerManipulator.convertImplicitToExplicitHydrogens(mol);
	String smiles = SmilesConverter.conv.mol2Smiles(mol, false);
	List<IAtom> order = SmilesConverter.conv.getOrder();
	
	for (IAtom a : res.getAtomicLinks().keySet()) {
		JSONObject jso = new JSONObject();
		Rule rule = res.getAtomicLinks().get(a);
		jso.put("name", rule.getName());
		jso.put("atom", order.indexOf(a));
		links.add(jso);
	}
	AtomContainerManipulator.removeHydrogens(mol);

	return smiles;
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
void add(IAtomContainer container) {

        // remove explicit hydrogens and all stereochemistry
        AtomContainerManipulator.suppressHydrogens(container);
        container.setStereoElements(new ArrayList<IStereoElement>());

        RingSearch ringSearch = new RingSearch(container);

        List<IAtomContainer> fused = ringSearch.fusedRingFragments();
        List<IAtomContainer> isolated = ringSearch.isolatedRingFragments();

        // only use compounds with a single ring system
        if (fused.size() == 1 && isolated.isEmpty()) {
            add(fused.get(0), container);
        }
        else if (isolated.size() == 1 && fused.isEmpty()) {
            add(isolated.get(0), container);
        }
    }
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
private IAtomContainer hydrogenHandling(IAtomContainer container, String id) {
	if(container == null)
		return null;
	
	// create deep copy
	IAtomContainer copy = null;
	try {
		 copy = container.clone();
	} catch (CloneNotSupportedException e1) {
		System.err.println("Could not clone IAtomContainer - no hydrogen handling!");
		return container;
	}
	
	//add hydrogens
       try {
		AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(copy);
		CDKHydrogenAdder hAdder = CDKHydrogenAdder.getInstance(copy.getBuilder());
	    hAdder.addImplicitHydrogens(copy);
	    AtomContainerManipulator.convertImplicitToExplicitHydrogens(copy);
	} catch (CDKException e) {		// return original if adding H's fails
		System.err.println("Error adding explict H's - no hydrogen handling for ID [" + id + "]!");
		return container;
	}
       
       return copy;
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
private IAtomContainer hydrogenHandling(IAtomContainer container) {
		if(container == null)
			return container;
		
		/**
		 *  hydrogen handling
		 */
		try {
			AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(container);
			CDKHydrogenAdder hAdder = CDKHydrogenAdder.getInstance(container.getBuilder());
	        hAdder.addImplicitHydrogens(container);
	        AtomContainerManipulator.convertImplicitToExplicitHydrogens(container);
		} catch (CDKException e) {
			return container;
		}
		return container;
		
//		return AtomContainerManipulator.removeHydrogens(container);
	}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的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.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
public LabeledMolStruct(IAtomContainer base){
    super( new AtomContainer(AtomContainerManipulator.removeHydrogens(base)) );
    mol_ids = new HashSet<PubchemID>();
    
    Iterator<IBond> bonds = this.bonds().iterator();
    while( bonds.hasNext() ){
        IBond bond = bonds.next();
        bond.setOrder(IBond.Order.SINGLE);
    }
    
    makeGraph();

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

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
/**
 * SIDE EFFECT: converts implicit to explicit hydrogens in molecule, then converts them /back/
 * @param name
 * @param molecule
 */
public ChemicalCompound(String name, IMolecule molecule)
        throws CDKException
{
    this.name = name;
    this.cdkMolecule = molecule;

    AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(cdkMolecule);


    //When SmilesParser gives us a molecule, the hydrogens are implicit.  If you,
    //e.g., create a MolecularFormula object from the Molecule and ask it for its mass
    //and its formula string, they will be wrong, because they have no H's.
    //So I add the hydrogens, create the formula with the hydrogens, and then remove them
    AtomContainerManipulator.convertImplicitToExplicitHydrogens(cdkMolecule);

    formula = ChemCalcs.CDKMolForm2ChemForm(MolecularFormulaManipulator.getMolecularFormula(cdkMolecule));
    //This doesn't actually remove hydrogens in the argument, just returns a new IMolecule
    cdkMolecule = (IMolecule) AtomContainerManipulator.removeHydrogens(cdkMolecule);
    try
    {
        new LonePairElectronChecker().saturate(cdkMolecule);
    }
    catch (Exception e) //failed to saturate.  Not sure why this happens sometimes on valid SMILES strings
    {}
}
 

import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; //导入依赖的package包/类
public IMolecule createCOOH()
    {
        IChemObjectBuilder builder = NoNotificationChemObjectBuilder.getInstance();
        IMolecule molecule = builder.newMolecule();
        molecule.addAtom(builder.newAtom("C"));
        molecule.addAtom(builder.newAtom("O"));
        molecule.addBond(0, 1, IBond.Order.DOUBLE);
        molecule.addAtom(builder.newAtom("O"));
        molecule.addBond(0, 2, IBond.Order.SINGLE);

        try {

            AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molecule);
            LonePairElectronChecker lpcheck = new LonePairElectronChecker();
            lpcheck.saturate(molecule);

        }
        catch (CDKException e)
        {
            e.printStackTrace();
        }
//        Image image = MoleculeRenderer2D.renderMolecule(molecule, width, height);
//        new PanelWithBlindImageChart((BufferedImage) image, "0=C-OH").displayInTab();
        return molecule;
    }