public void TestManuallyCentreActive()
{
var type = new AdductionProtonLPReaction();
var setOfReactants = GetExampleReactants();
/* manually putting the active center */
setOfReactants[0].Atoms[0].IsReactiveCenter = true;
/* initiate */
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = true;
paramList.Add(param);
type.ParameterList = paramList;
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
var product = setOfReactions[0].Products[0];
var molecule2 = GetExpectedProducts()[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(uiTester.IsIsomorph(molecule2, queryAtom));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
var type = new SharingChargeSBReaction();
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(3, setOfReactions.Count);
Assert.AreEqual(2, setOfReactions[0].Products.Count);
var product1 = setOfReactions[1].Products[0];
var molecule1 = GetExpectedProducts()[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product1);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule1, queryAtom));
var product2 = setOfReactions[0].Products[1];
var expected2 = GetExpectedProducts()[0];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(product2, queryAtom));
}
public void TestManuallyCentreActive()
{
IReactionProcess type = new SharingAnionReaction();
var setOfReactants = GetExampleReactants();
IAtomContainer molecule = setOfReactants[0];
/* manually put the center active */
molecule.Atoms[0].IsReactiveCenter = true;
molecule.Atoms[1].IsReactiveCenter = true;
molecule.Bonds[0].IsReactiveCenter = true;
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = true;
paramList.Add(param);
type.ParameterList = paramList;
/* initiate */
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
IAtomContainer product = setOfReactions[0].Products[0];
/* C=[O+] */
IAtomContainer molecule2 = GetExpectedProducts()[0];
IQueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
var type = new RadicalSiteRrGammaReaction();
var setOfReactants = GetExampleReactants();
var molecule = setOfReactants[0];
/* initiate */
molecule.Atoms[0].IsReactiveCenter = true;
molecule.Atoms[1].IsReactiveCenter = true;
molecule.Atoms[5].IsReactiveCenter = true;
molecule.Bonds[0].IsReactiveCenter = true;
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter
{
IsSetParameter = true
};
paramList.Add(param);
type.ParameterList = paramList;
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
var product = setOfReactions[0].Products[0];
var molecule2 = GetExpectedProducts()[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
IReactionProcess type = new RadicalSiteHrBetaReaction();
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(3, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
IAtomContainer product = setOfReactions[0].Products[0];
IAtomContainer molecule2 = GetExpectedProducts()[0];
IQueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
var type = new RearrangementLonePairReaction();
var setOfReactants = GetExampleReactants();
var molecule = setOfReactants[0];
/* 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(1, setOfReactions[0].Products.Count);
var product = setOfReactions[0].Products[0];
Assert.AreEqual(-1, product.Atoms[2].FormalCharge.Value);
Assert.AreEqual(0, product.GetConnectedLonePairs(product.Atoms[1]).Count());
var molecule2 = GetExpectedProducts()[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
public void TestManuallyCentreActive()
{
IReactionProcess type = new TautomerizationReaction();
var setOfReactants = GetExampleReactants();
IAtomContainer molecule = setOfReactants[0];
/* manually putting the active center */
molecule.Atoms[0].IsReactiveCenter = true;
molecule.Atoms[1].IsReactiveCenter = true;
molecule.Atoms[2].IsReactiveCenter = true;
molecule.Atoms[4].IsReactiveCenter = true;
molecule.Bonds[0].IsReactiveCenter = true;
molecule.Bonds[1].IsReactiveCenter = true;
molecule.Bonds[3].IsReactiveCenter = true;
/* initiate */
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = true;
paramList.Add(param);
type.ParameterList = paramList;
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
IAtomContainer product = setOfReactions[0].Products[0];
IAtomContainer molecule2 = GetExpectedProducts()[0];
IQueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
// reverse process
/* manually putting the active center */
molecule2.Atoms[0].IsReactiveCenter = true;
molecule2.Atoms[1].IsReactiveCenter = true;
molecule2.Atoms[2].IsReactiveCenter = true;
molecule2.Atoms[6].IsReactiveCenter = true;
molecule2.Bonds[0].IsReactiveCenter = true;
molecule2.Bonds[1].IsReactiveCenter = true;
molecule2.Bonds[5].IsReactiveCenter = true;
var setOfReactants2 = ChemObjectBuilder.Instance.NewAtomContainerSet();
setOfReactants2.Add(molecule2);
var setOfReactions2 = type.Initiate(setOfReactants2, null);
Assert.AreEqual(1, setOfReactions2.Count);
Assert.AreEqual(1, setOfReactions2[0].Products.Count);
IAtomContainer product2 = setOfReactions2[0].Products[0];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule, queryAtom));
}
public void TestOspDoubleB()
{
//CreateFromSmiles("O=C")
IAtomContainer molecule = builder.NewAtomContainer();
molecule.Atoms.Add(builder.NewAtom("O"));
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Double);
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[2], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[3], BondOrder.Single);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule);
CDK.LonePairElectronChecker.Saturate(molecule);
molecule.Atoms[0].IsReactiveCenter = true;
molecule.Atoms[1].IsReactiveCenter = true;
molecule.Bonds[0].IsReactiveCenter = true;
var setOfReactants = ChemObjectBuilder.Instance.NewAtomContainerSet();
setOfReactants.Add(molecule);
IReactionProcess type = new HeterolyticCleavagePBReaction();
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = true;
paramList.Add(param);
type.ParameterList = paramList;
/* initiate */
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
// expected products
//CreateFromSmiles("[O-][C+]")
IAtomContainer expected1 = builder.NewAtomContainer();
expected1.Atoms.Add(builder.NewAtom("O"));
expected1.Atoms[0].FormalCharge = -1;
expected1.Atoms.Add(builder.NewAtom("C"));
expected1.Atoms[1].FormalCharge = +1;
expected1.AddBond(expected1.Atoms[0], expected1.Atoms[1], BondOrder.Single);
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.AddBond(expected1.Atoms[1], expected1.Atoms[2], BondOrder.Single);
expected1.AddBond(expected1.Atoms[1], expected1.Atoms[3], BondOrder.Single);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(expected1);
CDK.LonePairElectronChecker.Saturate(expected1);
IAtomContainer product1 = setOfReactions[0].Products[0];
QueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected1);
Assert.IsTrue(uiTester.IsIsomorph(product1, queryAtom));
}
public void TestCarbons()
{
IReactionProcess type = new SharingAnionReaction();
IAtomContainer molecule = builder.NewAtomContainer();
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.Atoms[0].FormalCharge = 1;
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.Atoms[1].FormalCharge = -1;
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Single);
AddExplicitHydrogens(molecule);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule);
CDK.LonePairElectronChecker.Saturate(molecule);
var setOfReactants = ChemObjectBuilder.Instance.NewAtomContainerSet();
setOfReactants.Add(molecule);
/* 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(1, setOfReactions[0].Products.Count);
IAtomContainer product = setOfReactions[0].Products[0];
IAtomContainer molecule2 = builder.NewAtomContainer();
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.AddBond(molecule2.Atoms[0], molecule2.Atoms[1], BondOrder.Double);
AddExplicitHydrogens(molecule2);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule2);
CDK.LonePairElectronChecker.Saturate(molecule2);
IQueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
IReactionProcess type = new PiBondingMovementReaction();
// C1=C(C)-C(C)=C-C=C1
IAtomContainer molecule = builder.NewAtomContainer();
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Double);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[2], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[2], molecule.Atoms[3], BondOrder.Double);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[3], molecule.Atoms[4], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[4], molecule.Atoms[5], BondOrder.Double);
molecule.AddBond(molecule.Atoms[5], molecule.Atoms[0], BondOrder.Single);
AddExplicitHydrogens(molecule);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule);
MakeSureAtomTypesAreRecognized(molecule);
var setOfReactants = ChemObjectBuilder.Instance.NewAtomContainerSet();
setOfReactants.Add(molecule);
/* 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(1, setOfReactions[0].Products.Count);
IAtomContainer product2 = setOfReactions[0].Products[0];
IQueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule, queryAtom));
}
public void TestManuallyCentreActive()
{
var type = new RadicalSiteInitiationHReaction();
var setOfReactants = GetExampleReactants();
var molecule = setOfReactants[0];
/* initiate */
MakeSureAtomTypesAreRecognized(molecule);
/* manually put the reactive center */
molecule.Atoms[0].IsReactiveCenter = true;
molecule.Atoms[3].IsReactiveCenter = true;
molecule.Atoms[4].IsReactiveCenter = true;
molecule.Bonds[2].IsReactiveCenter = true;
molecule.Bonds[3].IsReactiveCenter = true;
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = true;
paramList.Add(param);
type.ParameterList = paramList;
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(2, setOfReactions[0].Products.Count);
var product1 = setOfReactions[0].Products[0];
/* C=C */
var molecule1 = GetExpectedProducts()[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product1);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule1, queryAtom));
var product2 = setOfReactions[0].Products[1];
/* [H*] */
var molecule2 = GetExpectedProducts()[1];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
IReactionProcess type = new TautomerizationReaction();
var setOfReactants = GetExampleReactants();
IAtomContainer molecule = setOfReactants[0];
/* 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(1, setOfReactions[0].Products.Count);
IAtomContainer product = setOfReactions[0].Products[0];
IAtomContainer molecule2 = GetExpectedProducts()[0];
IQueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
// reverse process
var setOfReactants2 = ChemObjectBuilder.Instance.NewAtomContainerSet();
setOfReactants2.Add(molecule2);
IReactionSet setOfReactions2 = type.Initiate(setOfReactants2, null);
Assert.AreEqual(1, setOfReactions2.Count);
Assert.AreEqual(1, setOfReactions2[0].Products.Count);
IAtomContainer product2 = setOfReactions2[0].Products[0];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule, queryAtom));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
var type = new AdductionProtonLPReaction();
/* initiate */
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = false;
paramList.Add(param);
type.ParameterList = paramList;
var setOfReactions = type.Initiate(GetExampleReactants(), null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
var product = setOfReactions[0].Products[0];
var molecule2 = GetExpectedProducts()[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(uiTester.IsIsomorph(molecule2, queryAtom));
}
public void TestWithNegativeCharge()
{
var type = new HyperconjugationReaction();
var setOfReactants = GetExampleReactants();
/* automatic search of the center active */
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = false;
paramList.Add(param);
type.ParameterList = paramList;
/* initiate */
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(3, setOfReactions.Count);
Assert.AreEqual(2, setOfReactions[0].Products.Count);
var product = setOfReactions[0].Products[0];
var molecule2 = GetExpectedProducts()[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(molecule2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(product, queryAtom));
product = setOfReactions[0].Products[1];
molecule2 = builder.NewAtomContainer();
molecule2.Atoms.Add(builder.NewAtom("H"));
molecule2.Atoms[0].FormalCharge = 1;
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
public void TestDoubleRingConjugated2()
{
IReactionProcess type = new PiBondingMovementReaction();
// C1=CC(=CC2=C1C=CC=C2)C
var setOfReactants = GetExampleReactants();
IAtomContainer molecule = setOfReactants[0];
/* manually putting the reaction center */
molecule.Bonds[1].IsReactiveCenter = true;
molecule.Bonds[2].IsReactiveCenter = true;
molecule.Bonds[3].IsReactiveCenter = true;
molecule.Bonds[9].IsReactiveCenter = true;
molecule.Bonds[10].IsReactiveCenter = true;
molecule.Bonds[11].IsReactiveCenter = true;
/* initiate */
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = true;
paramList.Add(param);
type.ParameterList = paramList;
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
IAtomContainer product2 = setOfReactions[0].Products[0];
IAtomContainer molecule2 = GetExpectedProducts()[0];
IQueryAtomContainer queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
}
/// <summary>
/// Search if the setOfAtomContainer contains the atomContainer
/// </summary>
/// <param name="set">ISetOfAtomContainer object where to search</param>
/// <param name="atomContainer">IAtomContainer to search</param>
/// <returns>True, if the atomContainer is contained</returns>
private bool ExistAC(IChemObjectSet <IAtomContainer> set, IAtomContainer atomContainer)
{
IAtomContainer acClone = null;
acClone = (IAtomContainer)atomContainer.Clone();
if (!lookingSymmetry)
{ /* remove all aromatic flags */
foreach (var atom in acClone.Atoms)
{
atom.IsAromatic = false;
}
foreach (var bond in acClone.Bonds)
{
bond.IsAromatic = false;
}
}
for (int i = 0; i < acClone.Atoms.Count; i++)
{
acClone.Atoms[i].Id = "" + acClone.Atoms.IndexOf(acClone.Atoms[i]);
}
if (lookingSymmetry)
{
try
{
Aromaticity.CDKLegacy.Apply(acClone);
}
catch (CDKException e)
{
Console.Error.WriteLine(e.StackTrace);
}
}
else
{
if (!lookingSymmetry)
{ /* remove all aromatic flags */
foreach (var atom in acClone.Atoms)
{
atom.IsAromatic = false;
}
foreach (var bond in acClone.Bonds)
{
bond.IsAromatic = false;
}
}
}
for (int i = 0; i < set.Count; i++)
{
var ss = set[i];
for (int j = 0; j < ss.Atoms.Count; j++)
{
ss.Atoms[j].Id = "" + ss.Atoms.IndexOf(ss.Atoms[j]);
}
try
{
if (!lookingSymmetry)
{
var qAC = QueryAtomContainerCreator.CreateSymbolChargeIDQueryContainer(acClone);
if (new UniversalIsomorphismTester().IsIsomorph(ss, qAC))
{
var qAC2 = QueryAtomContainerCreator.CreateSymbolAndBondOrderQueryContainer(acClone);
if (new UniversalIsomorphismTester().IsIsomorph(ss, qAC2))
{
return(true);
}
}
}
else
{
var qAC = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(acClone);
Aromaticity.CDKLegacy.Apply(ss);
if (new UniversalIsomorphismTester().IsIsomorph(ss, qAC))
{
return(true);
}
}
}
catch (CDKException e1)
{
Console.Error.WriteLine(e1);
Trace.TraceError(e1.Message);
Debug.WriteLine(e1);
}
}
return(false);
}
static bool Matches(IAtomContainer a, IAtomContainer b)
{
IQueryAtomContainer query = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(b);
return(new UniversalIsomorphismTester().IsIsomorph(a, query));
}
public void TestAutomaticSearchCentreActiveExample3()
{
var type = new RearrangementAnionReaction();
/* [F+]=C1-[C-]-C=C-C=C1 */
var molecule = builder.NewAtomContainer();
molecule.Atoms.Add(builder.NewAtom("F"));
molecule.Atoms[0].FormalCharge = 1;
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Double);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.Atoms[2].FormalCharge = -1;
molecule.LonePairs.Add(CDK.Builder.NewLonePair(molecule.Atoms[0]));
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[2], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[2], molecule.Atoms[3], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[3], molecule.Atoms[4], BondOrder.Double);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[4], molecule.Atoms[5], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[5], molecule.Atoms[6], BondOrder.Double);
molecule.AddBond(molecule.Atoms[6], molecule.Atoms[1], BondOrder.Single);
AddExplicitHydrogens(molecule);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule);
CDK.LonePairElectronChecker.Saturate(molecule);
var setOfReactants = CDK.Builder.NewAtomContainerSet();
setOfReactants.Add(molecule);
/* initiate */
MakeSureAtomTypesAreRecognized(molecule);
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(2, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
var product1 = setOfReactions[1].Products[0];
/* [F+]=C1-[C=]-C-[C-]-C=C1 */
var molecule2 = builder.NewAtomContainer();
molecule2.Atoms.Add(builder.NewAtom("F"));
molecule2.Atoms[0].FormalCharge = 1;
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.AddBond(molecule2.Atoms[0], molecule2.Atoms[1], BondOrder.Double);
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.AddBond(molecule2.Atoms[1], molecule2.Atoms[2], BondOrder.Single);
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.AddBond(molecule2.Atoms[2], molecule2.Atoms[3], BondOrder.Double);
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.Atoms[4].FormalCharge = -1;
molecule2.AddBond(molecule2.Atoms[3], molecule2.Atoms[4], BondOrder.Single);
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.AddBond(molecule2.Atoms[4], molecule2.Atoms[5], BondOrder.Single);
molecule2.Atoms.Add(builder.NewAtom("C"));
molecule2.AddBond(molecule2.Atoms[5], molecule2.Atoms[6], BondOrder.Double);
molecule2.AddBond(molecule2.Atoms[6], molecule2.Atoms[1], BondOrder.Single);
AddExplicitHydrogens(molecule2);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule2);
CDK.LonePairElectronChecker.Saturate(molecule2);
MakeSureAtomTypesAreRecognized(molecule2);
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product1);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule2, queryAtom));
//////////////////////////////////////////////////
var product2 = setOfReactions[0].Products[0];
/* F=c1ccccc1 */
var molecule3 = builder.NewAtomContainer();
molecule3.Atoms.Add(builder.NewAtom("F"));
molecule3.Atoms.Add(builder.NewAtom("C"));
molecule3.AddBond(molecule3.Atoms[0], molecule3.Atoms[1], BondOrder.Single);
molecule3.Atoms.Add(builder.NewAtom("C"));
molecule3.AddBond(molecule3.Atoms[1], molecule3.Atoms[2], BondOrder.Double);
molecule3.Atoms.Add(builder.NewAtom("C"));
molecule3.AddBond(molecule3.Atoms[2], molecule3.Atoms[3], BondOrder.Single);
molecule3.Atoms.Add(builder.NewAtom("C"));
molecule3.AddBond(molecule3.Atoms[3], molecule3.Atoms[4], BondOrder.Double);
molecule3.Atoms.Add(builder.NewAtom("C"));
molecule3.AddBond(molecule3.Atoms[4], molecule3.Atoms[5], BondOrder.Single);
molecule3.Atoms.Add(builder.NewAtom("C"));
molecule3.AddBond(molecule3.Atoms[5], molecule3.Atoms[6], BondOrder.Double);
molecule3.AddBond(molecule3.Atoms[6], molecule3.Atoms[1], BondOrder.Single);
AddExplicitHydrogens(molecule3);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule3);
CDK.LonePairElectronChecker.Saturate(molecule3);
MakeSureAtomTypesAreRecognized(molecule3);
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(product2);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(molecule3, queryAtom));
Assert.AreEqual(12, setOfReactions[0].Mappings.Count);
}
public void TestFspSingleB()
{
//CreateFromSmiles("FC")
var molecule = builder.NewAtomContainer();
molecule.Atoms.Add(builder.NewAtom("F"));
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[2], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[3], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[4], BondOrder.Single);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule);
CDK.LonePairElectronChecker.Saturate(molecule);
molecule.Atoms[0].IsReactiveCenter = true;
var setOfReactants = CDK.Builder.NewAtomContainerSet();
setOfReactants.Add(molecule);
var type = new ElectronImpactNBEReaction();
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter
{
IsSetParameter = true
};
paramList.Add(param);
type.ParameterList = paramList;
/* initiate */
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
// expected products
//CreateFromSmiles("[F*+]C")
var expected1 = builder.NewAtomContainer();
expected1.Atoms.Add(builder.NewAtom("F"));
expected1.Atoms[0].FormalCharge = 1;
expected1.SingleElectrons.Add(builder.NewSingleElectron(expected1.Atoms[0]));
expected1.Atoms.Add(builder.NewAtom("C"));
expected1.AddBond(expected1.Atoms[0], expected1.Atoms[1], BondOrder.Single);
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.AddBond(expected1.Atoms[1], expected1.Atoms[2], BondOrder.Single);
expected1.AddBond(expected1.Atoms[1], expected1.Atoms[3], BondOrder.Single);
expected1.AddBond(expected1.Atoms[1], expected1.Atoms[4], BondOrder.Single);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(expected1);
CDK.LonePairElectronChecker.Saturate(expected1);
var product1 = setOfReactions[0].Products[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected1);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(product1, queryAtom));
}
public void TestFluorobenzene()
{
var molecule = builder.NewAtomContainer();
molecule.Atoms.Add(builder.NewAtom("F"));
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[2], BondOrder.Double);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[2], molecule.Atoms[3], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[3], molecule.Atoms[4], BondOrder.Double);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[4], molecule.Atoms[5], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[5], molecule.Atoms[6], BondOrder.Double);
molecule.AddBond(molecule.Atoms[6], molecule.Atoms[1], BondOrder.Single);
AddExplicitHydrogens(molecule);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule);
CDK.LonePairElectronChecker.Saturate(molecule);
var type = new RearrangementLonePairReaction();
var setOfReactants = CDK.Builder.NewAtomContainerSet();
setOfReactants.Add(molecule);
/* automatic search of the center active */
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = false;
paramList.Add(param);
type.ParameterList = paramList;
/* initiate */
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(1, setOfReactions.Count);
Assert.AreEqual(1, setOfReactions[0].Products.Count);
var product1 = setOfReactions[0].Products[0];
var molecule1 = builder.NewAtomContainer();
molecule1.Atoms.Add(builder.NewAtom("F"));
molecule1.Atoms[0].FormalCharge = 1;
molecule1.Atoms.Add(builder.NewAtom("C"));
molecule1.AddBond(molecule1.Atoms[0], molecule1.Atoms[1], BondOrder.Double);
molecule1.Atoms.Add(builder.NewAtom("C"));
molecule1.Atoms[2].FormalCharge = -1;
molecule1.AddBond(molecule1.Atoms[1], molecule1.Atoms[2], BondOrder.Single);
molecule1.Atoms.Add(builder.NewAtom("C"));
molecule1.AddBond(molecule1.Atoms[2], molecule1.Atoms[3], BondOrder.Single);
molecule1.Atoms.Add(builder.NewAtom("C"));
molecule1.AddBond(molecule1.Atoms[3], molecule1.Atoms[4], BondOrder.Double);
molecule1.Atoms.Add(builder.NewAtom("C"));
molecule1.AddBond(molecule1.Atoms[4], molecule1.Atoms[5], BondOrder.Single);
molecule1.Atoms.Add(builder.NewAtom("C"));
molecule1.AddBond(molecule1.Atoms[5], molecule1.Atoms[6], BondOrder.Double);
molecule1.AddBond(molecule1.Atoms[6], molecule1.Atoms[1], BondOrder.Single);
AddExplicitHydrogens(molecule1);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule1);
CDK.LonePairElectronChecker.Saturate(molecule1);
var qAC = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(molecule1);
Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(product1, qAC));
}
public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
{
//CreateFromSmiles("CCC")
var molecule = builder.NewAtomContainer();
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.Atoms.Add(builder.NewAtom("C"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[2], BondOrder.Single);
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.Atoms.Add(builder.NewAtom("H"));
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[3], BondOrder.Single);
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[4], BondOrder.Single);
molecule.AddBond(molecule.Atoms[0], molecule.Atoms[5], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[6], BondOrder.Single);
molecule.AddBond(molecule.Atoms[1], molecule.Atoms[7], BondOrder.Single);
molecule.AddBond(molecule.Atoms[2], molecule.Atoms[8], BondOrder.Single);
molecule.AddBond(molecule.Atoms[2], molecule.Atoms[9], BondOrder.Single);
molecule.AddBond(molecule.Atoms[2], molecule.Atoms[10], BondOrder.Single);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule);
molecule.Atoms[1].IsReactiveCenter = true;
molecule.Atoms[2].IsReactiveCenter = true;
molecule.Bonds[1].IsReactiveCenter = true;
var setOfReactants = CDK.Builder.NewAtomContainerSet();
setOfReactants.Add(molecule);
var type = new HeterolyticCleavageSBReaction();
var paramList = new List <IParameterReaction>();
var param = new SetReactionCenter();
param.IsSetParameter = true;
paramList.Add(param);
type.ParameterList = paramList;
/* initiate */
var setOfReactions = type.Initiate(setOfReactants, null);
Assert.AreEqual(2, setOfReactions.Count);
// expected products
//CreateFromSmiles("C[C+]")
var expected1 = builder.NewAtomContainer();
expected1.Atoms.Add(builder.NewAtom("C"));
expected1.Atoms.Add(builder.NewAtom("C"));
expected1.Atoms[1].FormalCharge = +1;
expected1.AddBond(expected1.Atoms[0], expected1.Atoms[1], BondOrder.Single);
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.Atoms.Add(builder.NewAtom("H"));
expected1.AddBond(expected1.Atoms[0], expected1.Atoms[2], BondOrder.Single);
expected1.AddBond(expected1.Atoms[0], expected1.Atoms[3], BondOrder.Single);
expected1.AddBond(expected1.Atoms[0], expected1.Atoms[4], BondOrder.Single);
expected1.AddBond(expected1.Atoms[1], expected1.Atoms[5], BondOrder.Single);
expected1.AddBond(expected1.Atoms[1], expected1.Atoms[6], BondOrder.Single);;
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(expected1);
var product1 = setOfReactions[0].Products[0];
var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected1);
Assert.IsTrue(uiTester.IsIsomorph(product1, queryAtom));
//CreateFromSmiles("[C-]")
var expected2 = builder.NewAtomContainer();
expected2.Atoms.Add(builder.NewAtom("C"));
expected2.Atoms[0].FormalCharge = -1;
expected2.Atoms.Add(builder.NewAtom("H"));
expected2.Atoms.Add(builder.NewAtom("H"));
expected2.Atoms.Add(builder.NewAtom("H"));
expected2.AddBond(expected2.Atoms[0], expected2.Atoms[1], BondOrder.Single);
expected2.AddBond(expected2.Atoms[0], expected2.Atoms[2], BondOrder.Single);
expected2.AddBond(expected2.Atoms[0], expected2.Atoms[3], BondOrder.Single);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(expected2);
CDK.LonePairElectronChecker.Saturate(expected2);
var product2 = setOfReactions[0].Products[1];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected2);
Assert.IsTrue(uiTester.IsIsomorph(product2, queryAtom));
//CreateFromSmiles("C[C-]")
expected1.Atoms[1].FormalCharge = -1;
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(expected1);
product1 = setOfReactions[1].Products[0];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected1);
Assert.IsTrue(uiTester.IsIsomorph(product1, queryAtom));
//CreateFromSmiles("[C+]")
expected2.Atoms[0].FormalCharge = +1;
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(expected2);
product2 = setOfReactions[1].Products[1];
queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected2);
Assert.IsTrue(uiTester.IsIsomorph(product2, queryAtom));
}
