public void AtomStereo()
{
var mol = new QueryAtomContainer(null);
Assert.IsTrue(Smarts.Parse(mol, "C[C@H](O)CC"));
Assert.AreEqual("C[C@H1](O)CC", Smarts.Generate(mol));
}
public void BondStereoCisTrans()
{
var mol = new QueryAtomContainer(null);
Assert.IsTrue(Smarts.Parse(mol, "C/C=C/,\\C"));
Assert.AreEqual("C/C=C/,\\C", Smarts.Generate(mol));
}
public void TestGetSubgraphMapIAtomContainerIAtomContainer()
{
var molfile = "NCDK.Data.MDL.decalin.mol";
var queryfile = "NCDK.Data.MDL.decalin.mol";
var mol = builder.NewAtomContainer();
var temp = builder.NewAtomContainer();
QueryAtomContainer query1 = null;
QueryAtomContainer query2 = null;
var ins = ResourceLoader.GetAsStream(molfile);
var reader = new MDLV2000Reader(ins, ChemObjectReaderMode.Strict);
reader.Read(mol);
ins = ResourceLoader.GetAsStream(queryfile);
reader = new MDLV2000Reader(ins, ChemObjectReaderMode.Strict);
reader.Read(temp);
query1 = QueryAtomContainerCreator.CreateBasicQueryContainer(temp);
var sp = CDK.SmilesParser;
var atomContainer = sp.ParseSmiles("C1CCCCC1");
query2 = QueryAtomContainerCreator.CreateBasicQueryContainer(atomContainer);
var list = uiTester.GetSubgraphMap(mol, query1);
Assert.AreEqual(11, list.Count);
list = uiTester.GetSubgraphMap(mol, query2);
Assert.AreEqual(6, list.Count);
}
public void BondFalse()
{
var mol = new QueryAtomContainer(null);
Assert.IsTrue(Smarts.Parse(mol, "C!~C"));
Assert.AreEqual("C!~C", Smarts.Generate(mol));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
IReactionProcess type = new RadicalSiteInitiationReaction();
var setOfReactants = GetExampleReactants();
/* initiate */
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = false;
paramList.Add(param);
type.ParameterList = paramList;
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(2, setOfReactions[0].Products.Count);
IAtomContainer product1 = setOfReactions[0].Products[0];
/* C=C */
IAtomContainer molecule1 = GetExpectedProducts()[0];
QueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product1);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule1, queryAtom));
IAtomContainer product2 = setOfReactions[0].Products[1];
/* [C*] */
IAtomContainer molecule2 = GetExpectedProducts()[1];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
static IAtomContainer Sma(string smarts)
{
var query = new QueryAtomContainer(null);
Smarts.Parse(query, smarts);
return(query);
}
public void TestMatchInherited()
{
try
{
var builder = Silent.ChemObjectBuilder.Instance;
var c1 = new SymbolQueryAtom(builder.NewAtom("C"));
var c2 = new SymbolAndChargeQueryAtom(builder.NewAtom("C"));
var c = TestMoleculeFactory.MakeAlkane(2);
var query1 = new QueryAtomContainer();
query1.Atoms.Add(c1);
query1.Atoms.Add(c2);
query1.Bonds.Add(new NCDK.Isomorphisms.Matchers.OrderQueryBond(c1, c2, BondOrder.Single));
Assert.IsTrue(uiTester.IsSubgraph(c, query1));
var query = new QueryAtomContainer();
query.Atoms.Add(c1);
query.Atoms.Add(c2);
query.Bonds.Add(new AnyOrderQueryBond(c1, c2, BondOrder.Single));
Assert.IsTrue(uiTester.IsSubgraph(c, query));
}
catch (CDKException exception)
{
Assert.Fail(exception.Message);
}
}
/// <summary>
/// Internal - create a query atom container that exactly matches the molecule provided.
/// Similar to <see cref="QueryAtomContainerCreator"/>
/// but we can't access SMARTS query classes from that module (cdk-isomorphism).
/// </summary>
/// <param name="mol">molecule</param>
/// <returns>query container</returns>
/// <seealso cref="QueryAtomContainerCreator"/>
private static IQueryAtomContainer MatchExact(IAtomContainer mol)
{
var bldr = mol.Builder;
var qry = new QueryAtomContainer();
var atmmap = new Dictionary <IAtom, IAtom>();
foreach (var atom in mol.Atoms)
{
var qatom = MatchExact(mol, atom);
if (qatom != null)
{
atmmap[atom] = qatom;
qry.Atoms.Add(qatom);
}
}
foreach (var bond in mol.Bonds)
{
var beg = atmmap[bond.Begin];
var end = atmmap[bond.End];
// attach bond skipped
if (beg == null || end == null)
{
continue;
}
var qbond = new QueryBond(beg, end, ExprType.True);
qry.Bonds.Add(qbond);
}
return(qry);
}
public static QueryAtomContainer CreateSymbolChargeIDQueryContainer(IAtomContainer container)
{
var queryContainer = new QueryAtomContainer(container.Builder);
for (int i = 0; i < container.Atoms.Count; i++)
{
queryContainer.Atoms.Add(new SymbolChargeIDQueryAtom(container.Atoms[i]));
}
foreach (var bond in container.Bonds)
{
int index1 = container.Atoms.IndexOf(bond.Begin);
int index2 = container.Atoms.IndexOf(bond.End);
if (bond.IsAromatic)
{
QueryBond qbond = new QueryBond(queryContainer.Atoms[index1],
queryContainer.Atoms[index2],
ExprType.IsAromatic);
queryContainer.Bonds.Add(qbond);
}
else
{
QueryBond qbond = new QueryBond(queryContainer.Atoms[index1],
queryContainer.Atoms[index2],
ExprType.Order,
bond.Order.Numeric())
{
Order = bond.Order // backwards compatibility
};
queryContainer.Bonds.Add(qbond);
}
}
return(queryContainer);
}
public void TestAliphaticSymbols()
{
foreach (var e in ChemicalElement.Values)
{
switch (e.Symbol)
{
case "R":
continue;
default:
int len = e.Symbol.Length;
if (len == 1 || len == 2)
{
string smarts = $"[{e.Symbol}]";
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, smarts), smarts);
var expr = GetAtomExpr(mol.Atoms[0]);
var ee = new Expr(ExprType.Element, e.AtomicNumber);
var ea = new Expr(AliphaticElement, e.AtomicNumber);
Assert.IsTrue(expr.Equals(ee) || expr.Equals(ea));
}
break;
}
}
}
public void BondInRing()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C@C"));
Assert.AreEqual("C@C", Smarts.Generate(mol));
}
/// <summary>
/// Creates a QueryAtomContainer with the following settings:
/// <c>QueryAtomContainer.Create(container,
/// ExprType.ELEMENT,
/// ExprType.IS_AROMATIC,
/// ExprType.ALIPHATIC_ORDER);
/// </c>>
/// </summary>
/// <param name="container">The AtomContainer that stands as model</param>
/// <returns>The new QueryAtomContainer created from container.</returns>
public static QueryAtomContainer CreateAnyAtomForPseudoAtomQueryContainer(IAtomContainer container)
{
return(QueryAtomContainer.Create(container,
ExprType.Element,
ExprType.IsAromatic,
ExprType.AliphaticOrder));
}
public void BondStereoCisThenTransWithNbr()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C/C=C(C)\\C=C\\C"));
Assert.AreEqual("C/C=C(C)\\C=C\\C", Smarts.Generate(mol));
}
public void BondStereoCisThenTransUnspecWithNbrComplex()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C/?C=C(C)\\C=C\\O"));
Assert.AreEqual("C/?C=C(C)/C=C/O", Smarts.Generate(mol));
}
public void AtomStereoOrUnspec()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C[C@?H](O)CC"));
Assert.AreEqual("C[CH1@?](O)CC", Smarts.Generate(mol));
}
public void BondStereoUnspec()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C/C=C/?\\?C"));
Assert.AreEqual("C/C=C!/!\\C", Smarts.Generate(mol));
}
public void RoundTripStereo()
{
var mol = new QueryAtomContainer();
Smarts.Parse(mol, "O1.[S@]=1(C)CC");
Assert.AreEqual("O=[S@@](C)CC", Smarts.Generate(mol));
}
public void CompGroupingOnAgent()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, ">(c1ccccc1[O-].[Na+])>"));
Assert.AreEqual(">(c1c(cccc1)[O-].[Na+])>", Smarts.Generate(mol));
}
public void Reaction()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "c1ccccc1[NH2]>>c1ccccc1N(~O)~O"));
Assert.AreEqual("c1c(cccc1)[NH2]>>c1c(cccc1)N(~O)~O", Smarts.Generate(mol));
}
public void ReactionWithMaps()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "c1cccc[c:1]1[NH2:2]>>c1cccc[c:1]1[N:2](~O)~O"));
Assert.AreEqual("c1[c:1](cccc1)[NH2:2]>>c1[c:1](cccc1)[N:2](~O)~O", Smarts.Generate(mol));
}
public void AromaticBond()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "[#6]:[#6]"));
Assert.AreEqual("[#6]:[#6]", Smarts.Generate(mol));
}
public void RingClosureExprs3()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C1-,=CCCC1"));
Assert.AreEqual("C1CCCC-,=1", Smarts.Generate(mol));
}
public void NotTripleBond()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C!#C"));
Assert.AreEqual("C!#C", Smarts.Generate(mol));
}
public void BondTrue()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C~C~N(~O)~O"));
Assert.AreEqual("C~C~N(~O)~O", Smarts.Generate(mol));
}
public void CompGrouping()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "([Na+].[Cl-]).c1ccccc1"));
Assert.AreEqual("c1ccccc1.([Na+].[Cl-])", Smarts.Generate(mol));
}
/// <summary>
/// Creates a <see cref="QueryAtomContainer"/> with the following settings:
/// <c>QueryAtomContainer.Create(container,
/// ExprType.ELEMENT,
/// ExprType.FORMAL_CHARGE,
/// ExprType.IS_AROMATIC,
/// ExprType.ORDER);</c>
/// </summary>
/// <param name="container">The <see cref="IAtomContainer"/> that stands as model</param>
/// <returns>The new <see cref="QueryAtomContainer"/> created from container.</returns>
public static QueryAtomContainer CreateSymbolAndChargeQueryContainer(IAtomContainer container)
{
return(QueryAtomContainer.Create(container,
ExprType.Element,
ExprType.FormalCharge,
ExprType.IsAromatic,
ExprType.Order));
}
public void MultipleReads()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "C/C=C/C"));
Assert.IsTrue(Smarts.Parse(mol, "C/C=C\\C"));
Assert.AreEqual("C/C=C/C.C/C=C\\C", Smarts.Generate(mol));
}
public void AtomMaps()
{
var mol = new QueryAtomContainer();
Assert.IsFalse(Smarts.Parse(mol, "[:10]"));
Assert.IsTrue(Smarts.Parse(mol, "[*:10]"));
Assert.AreEqual(10, mol.Atoms[0].GetProperty <int>(CDKPropertyName.AtomAtomMapping));
}
private void InitializeQuery()
{
mappings = null;
if (!cache.TryGetValue(smarts, out query))
{
query = SMARTSParser.Parse(smarts);
cache[smarts] = query;
}
}
public void IndoleWithExprRoundTrip()
{
var mol = new QueryAtomContainer();
Assert.IsTrue(Smarts.Parse(mol, "[n;$(*C),$(*OC)]1ccc2c1cccc2"));
// CDK choice of data structures lose local arrangement but
// output is still indole
Assert.AreEqual("[n;$(*C),$(*OC)]1c2c(cc1)cccc2", Smarts.Generate(mol));
}
