private ArrayList GetRgroupsFromCoreMolecule(string _rCoreMol)
{
ArrayList lstRGroups = new ArrayList();
try
{
if (_rCoreMol != "")
{
MolHandler mHandler = new MolHandler(_rCoreMol);
Molecule objMol = mHandler.getMolecule();
MolAtom mAtom = null;
int intRgrpId = 0;
for (int i = 0; i < objMol.getAtomCount(); i++)
{
mAtom = objMol.getAtom(i);
intRgrpId = mAtom.getRgroup();
if (intRgrpId > 0)
{
if (!lstRGroups.Contains("R" + intRgrpId))
{
lstRGroups.Add("R" + intRgrpId);
}
}
}
}
}
catch (Exception ex)
{
ErrorHandling_NTS.WriteErrorLog(ex.ToString());
}
return(lstRGroups);
}
public override void TestSearchMCS()
{
var sp = CDK.SmilesParser;
IAtomContainer target = null;
try
{
target = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
}
catch (InvalidSmilesException ex)
{
Trace.TraceError(ex.Message);
}
IAtomContainer queryac = null;
try
{
queryac = sp.ParseSmiles("Nc1ccccc1");
}
catch (InvalidSmilesException ex)
{
Trace.TraceError(ex.Message);
}
VFlibMCSHandler smsd1 = new VFlibMCSHandler();
MolHandler mol1 = new MolHandler(queryac, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
smsd1.Set(mol1, mol2);
smsd1.SearchMCS(true);
Assert.IsNotNull(smsd1.GetFirstMapping());
}
private void chemRenditor_Qry_StructureChanged(object sender, EventArgs e)
{
try
{
if (chemRenditor_Qry.MolfileString != null)
{
MolHandler molHandler = new MolHandler(chemRenditor_Qry.MolfileString);
Molecule molObj = molHandler.getMolecule();
bool blIsChiral = false;
if (molObj.isAbsStereo())
{
lblChiral_Qry.Visible = true;
}
else
{
lblChiral_Qry.Visible = false;
}
}
}
catch (Exception ex)
{
throw ex;
}
}
private void chemRenditor_Results_StructureChanged(object sender, EventArgs e)
{
try
{
chemaxon.util.MolHandler molHandler = new MolHandler(chemRenditor_Results.MolfileString);
Molecule molObj = molHandler.getMolecule();
txtMolWeight.Text = molObj.getMass().ToString();
txtMolFormula.Text = molObj.getFormula();
string strMolfile = molObj.toFormat("mol");
string strIUPACName = "";
string strErrMsg = "";
if (ChemistryOperations.GetIUPACNameFromStructure(strMolfile, out strIUPACName, out strErrMsg))
{
strIUPACName = Validations.GetConvertedIUPACName(strIUPACName);
}
else
{
strIUPACName = "IUPAC name not provided";
}
txtIUPACName.Text = strIUPACName;
}
catch (Exception ex)
{
throw ex;
}
}
public static string GetStructureInchiKey(string _molfilestring)
{
string strInchiKey = "Inchi Not generated";
try
{
MolHandler mHandler = new MolHandler(_molfilestring);
Molecule mol = mHandler.getMolecule();
try
{
strInchiKey = mol.toFormat("inchi:key");
}
catch //Exception is inchi not generated
{
// if inchi not generated
SetMolAbsStereo_Inchi_NotGenerated(ref mol);
strInchiKey = mol.toFormat("inchi:key");
}
if (strInchiKey != "")
{
strInchiKey = Validations.GetInchiKeyFromInchiString(strInchiKey);
}
return(strInchiKey);
}
catch (Exception ex)
{
ErrorHandling_NTS.WriteErrorLog(ex.ToString());
}
return(strInchiKey);
}
public void TestGetMolecule()
{
MolHandler instance = new MolHandler(new AtomContainer(), true, true);
IAtomContainer result = instance.Molecule;
Assert.IsNotNull(result);
}
private void MCSBuilder(MolHandler mol1, MolHandler mol2)
{
int rBondCount = mol1.Molecule.Bonds.Count;
int pBondCount = mol2.Molecule.Bonds.Count;
int rAtomCount = mol1.Molecule.Atoms.Count;
int pAtomCount = mol2.Molecule.Atoms.Count;
if ((rBondCount == 0 && rAtomCount > 0) || (pBondCount == 0 && pAtomCount > 0))
{
SingleMapping();
}
else
{
ChooseAlgorithm(rBondCount, pBondCount);
}
if (allAtomMCS.Count != 0 && firstAtomMCS.Count != 0 && firstAtomMCS.Count > 1)
{
AllBondMaps = MakeBondMapsOfAtomMaps(mol1.Molecule, mol2.Molecule, allAtomMCS);
var firstMap = AllBondMaps.FirstOrDefault();
if (firstMap != null)
{
SetFirstBondMap(firstMap);
}
}
}
public void TestGetRemoveHydrogenFlag()
{
MolHandler instance = new MolHandler(new AtomContainer(), true, true);
bool expResult = true;
bool result = instance.RemoveHydrogenFlag;
Assert.AreEqual(expResult, result);
}
public static RgMolecule ReturnRGroupMolecule(string _rgrpSmiles, int _rgrpNum)
{
RgMolecule rgMol = null;
try
{
if (_rgrpSmiles != "")
{
MolHandler mHandler = new MolHandler(_rgrpSmiles);
Molecule objSmileMol = mHandler.getMolecule();
rgMol = new RgMolecule();
MolAtom mAtom = new MolAtom(MolAtom.RGROUP, 1, 0, 0);
mAtom.setRgroup(_rgrpNum);
rgMol.add(mAtom);
int radNum = 0;
for (int i = 0; i < objSmileMol.getAtomCount(); i++)
{
if (objSmileMol.getAtom(i).getRadical() > 0) //objSmileMol.getRadical(i)
{
radNum = i;
break;
}
}
for (int i = 0; i < objSmileMol.getAtomCount(); i++)
{
if (i == radNum)
{
objSmileMol.getAtom(i).setRadical(MolAtom.RAD_OFF);
}
rgMol.add(objSmileMol.getAtom(i));
}
for (int j = 0; j < objSmileMol.getBondCount(); j++)
{
rgMol.add(objSmileMol.getBond(j));
}
rgMol.add(new MolBond(objSmileMol.getAtom(radNum), mAtom));
rgMol.clean(2, null, null);
return(rgMol);
}
}
catch (Exception ex)
{
PepsiLiteErrorHandling.WriteErrorLog(ex.ToString());
}
return(rgMol);
}
public static bool CheckForDuplicateStructure(string filename, string qrymolfile, int recindex, out Molecule mol_out)
{
bool blStatus = false;
try
{
bool blIsChiral = false;
MolHandler mHandler = new MolHandler(qrymolfile);
Molecule qryMol = mHandler.getMolecule();
qryMol = StandardizeMolecule(qryMol, out blIsChiral);
string strqryMolInchi = qryMol.toFormat("inchi:key");
strqryMolInchi = GetInchiKeyFromInchiString(strqryMolInchi);
//Specify input file to MolInputStream object
MolInputStream molInStream = new MolInputStream(new FileInputStream(filename));
MolImporter molImp = new MolImporter(molInStream);
Molecule objMol = new Molecule();
blIsChiral = false;
string strInchiKey = "";
int intRecIndx = 0;
Molecule molObj_Stand = null;
while (molImp.read(objMol))
{
molObj_Stand = StandardizeMolecule(objMol, out blIsChiral);
strInchiKey = objMol.toFormat("inchi:key");
strInchiKey = GetInchiKeyFromInchiString(strInchiKey);
intRecIndx++;
if ((strInchiKey == strqryMolInchi) && (intRecIndx != recindex))
{
blStatus = true;
mol_out = objMol;
return(blStatus);
}
}
molImp.close();
// molInStream.close();
}
catch (Exception ex)
{
ErrorHandling.WriteErrorLog(ex.ToString());
}
mol_out = null;
return(blStatus);
}
public virtual void TestIsSubgraph()
{
var sp = CDK.SmilesParser;
var target = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
var queryac = sp.ParseSmiles("Nc1ccccc1");
VFlibSubStructureHandler smsd1 = new VFlibSubStructureHandler();
MolHandler mol1 = new MolHandler(queryac, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
smsd1.Set(mol1, mol2);
Assert.AreEqual(true, smsd1.IsSubgraph(true));
}
public void TestSet_MolHandler_MolHandler()
{
var sp = CDK.SmilesParser;
var target1 = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
var queryac = sp.ParseSmiles("Nc1ccccc1");
MolHandler source = new MolHandler(queryac, true, true);
MolHandler target = new MolHandler(target1, true, true);
VFlibSubStructureHandler instance = new VFlibSubStructureHandler();
instance.Set(source, target);
Assert.IsTrue(instance.IsSubgraph(true));
}
public void TestSet_MolHandler_MolHandler()
{
var sp = CDK.SmilesParser;
var target1 = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
var queryac = sp.ParseSmiles("Nc1ccccc1");
MolHandler source = new MolHandler(queryac, true, true);
MolHandler target = new MolHandler(target1, true, true);
VFlibMCSHandler instance = new VFlibMCSHandler();
instance.Set(source, target);
instance.SearchMCS(true);
Assert.IsNotNull(instance.GetFirstMapping());
}
public void TestSet_MolHandler_MolHandler()
{
var sp = CDK.SmilesParser;
var target1 = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
var queryac = sp.ParseSmiles("Nc1ccccc1");
MolHandler source = new MolHandler(queryac, true, true);
MolHandler target = new MolHandler(target1, true, true);
Isomorphism smsd1 = new Isomorphism(Algorithm.Default, true);
smsd1.Init(source.Molecule, target.Molecule, true, true);
smsd1.SetChemFilters(true, true, true);
Assert.IsNotNull(smsd1.GetFirstMapping());
}
public void TestSet_IAtomContainer_IAtomContainer()
{
var sp = CDK.SmilesParser;
var target = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
var queryac = sp.ParseSmiles("Nc1ccccc1");
VFlibMCSHandler smsd1 = new VFlibMCSHandler();
MolHandler mol1 = new MolHandler(queryac, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
smsd1.Set(mol1, mol2);
smsd1.SearchMCS(true);
Assert.IsNotNull(smsd1.GetFirstMapping());
}
public void TestGetAllAtomMapping()
{
var sp = CDK.SmilesParser;
var target = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
var queryac = sp.ParseSmiles("Nc1ccccc1");
CDKMCSHandler smsd1 = new CDKMCSHandler();
MolHandler mol1 = new MolHandler(queryac, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
smsd1.Set(mol1, mol2);
smsd1.SearchMCS(true);
Assert.IsNotNull(smsd1.GetFirstMapping());
Assert.AreEqual(4, smsd1.GetAllAtomMapping().Count);
}
public static DataTable ConvertChemicalNameToSMILES_JChem(DataTable _chemnamestbl)
{
DataTable dtSmiles = null;
try
{
if (_chemnamestbl != null)
{
if (_chemnamestbl.Rows.Count > 0)
{
dtSmiles = _chemnamestbl.Copy();
MolHandler molHandler = null;
Molecule molObj = null;
string strSMILES = "";
for (int rowindex = 0; rowindex < dtSmiles.Rows.Count; rowindex++)
{
for (int colindex = 1; colindex < dtSmiles.Columns.Count; colindex++)
{
try
{
molHandler = new MolHandler(dtSmiles.Rows[rowindex][colindex].ToString());
molObj = molHandler.getMolecule();
strSMILES = molObj.toFormat("smiles:u");
}
catch
{
strSMILES = "";
}
if (strSMILES == "")
{
strSMILES = "";
}
dtSmiles.Rows[rowindex][colindex] = strSMILES;
}
}
dtSmiles.AcceptChanges();
}
}
}
catch (Exception ex)
{
PepsiLiteErrorHandling.WriteErrorLog(ex.ToString());
}
return(dtSmiles);
}
public void TestSet_IAtomContainer_IAtomContainer()
{
IAtom atomSource = new Atom("R");
IAtom atomTarget = new Atom("R");
IAtomContainer source = new AtomContainer();
source.Atoms.Add(atomSource);
IAtomContainer target = new AtomContainer();
target.Atoms.Add(atomTarget);
bool removeHydrogen = false;
SingleMappingHandler instance = new SingleMappingHandler(removeHydrogen);
MolHandler mol1 = new MolHandler(source, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
instance.Set(mol1, mol2);
Assert.IsNotNull(instance.GetFirstAtomMapping());
}
private void chemRenditor_DoubleClick(object sender, EventArgs e)
{
try
{
if (chemRenditor.MolfileString != null)
{
chemaxon.util.MolHandler molHandler = new MolHandler(chemRenditor.MolfileString);
Molecule molObj = molHandler.getMolecule();
strInchi_Before = molObj.toFormat("inchi:key");
strInchi_Before = Validations.GetInchiKeyFromInchiString(strInchi_Before);
}
}
catch (Exception ex)
{
ErrorHandling_NTS.WriteErrorLog(ex.ToString());
}
}
private void chemRenditor_Trgt_StructureChanged(object sender, EventArgs e)
{
try
{
if (chemRenditor_Trgt.MolfileString != null)
{
MolHandler molHandler1 = new MolHandler(chemRenditor_Trgt.MolfileString);
Molecule molObj1 = molHandler1.getMolecule();
txtMolWeight.Text = "";
txtMolFormula.Text = "";
txtMolWeight.Text = molObj1.getMass().ToString();
txtMolFormula.Text = molObj1.getFormula();
if (molObj1.isAbsStereo())
{
lblChiral.Visible = true;
}
else
{
lblChiral.Visible = false;
}
string strMolfile = molObj1.toFormat("mol");
string strIUPACName = "";
string strErrMsg = "";
if (ChemistryOperations.GetIUPACNameFromStructure(strMolfile, out strIUPACName, out strErrMsg))
{
//strIUPACName = Validations.RemoveSMILESFromIUPACName(strIUPACName);
strIUPACName = Validations.GetConvertedIUPACName(strIUPACName);
}
else
{
strIUPACName = "IUPAC name not provided";
}
txtIUPACName.Text = strIUPACName;
}
}
catch (Exception ex)
{
throw ex;
}
}
[TestMethod(), Ignore()] // Failing but not going to be fixed
public void TestGetAllMapping()
{
var sp = new SmilesParser(ChemObjectBuilder.Instance, false);
var target = sp.ParseSmiles("C\\C=C/Nc1cccc(c1)N(O)\\C=C\\C\\C=C\\C=C/C");
var queryac = sp.ParseSmiles("Nc1ccccc1");
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(target);
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(queryac);
MCSPlusHandler smsd1 = new MCSPlusHandler();
MolHandler mol1 = new MolHandler(queryac, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
smsd1.Set(mol1, mol2);
smsd1.SearchMCS(true);
Assert.IsNotNull(smsd1.GetFirstMapping());
Assert.AreEqual(4, smsd1.GetAllMapping().Count);
}
public override void TestSearchMCS()
{
IAtom atomSource = new Atom("R");
IAtom atomTarget = new Atom("R");
IAtomContainer source = new AtomContainer();
source.Atoms.Add(atomSource);
IAtomContainer target = new AtomContainer();
target.Atoms.Add(atomTarget);
bool removeHydrogen = false;
SingleMappingHandler instance = new SingleMappingHandler(removeHydrogen);
MolHandler mol1 = new MolHandler(source, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
instance.Set(mol1, mol2);
instance.SearchMCS(true);
Assert.IsNotNull(instance.GetAllMapping());
Assert.AreEqual(1, instance.GetAllMapping().Count);
}
public static double GetStructureMolWeight_MolFormula(string _molfilestring, out string _molformula)
{
double dblMolWeight = 0.0;
string strMolFormula = "";
try
{
MolHandler mHandler = new MolHandler(_molfilestring);
dblMolWeight = mHandler.calcMolWeight();
strMolFormula = mHandler.calcMolFormula();
_molformula = strMolFormula;
return(dblMolWeight);
}
catch (Exception ex)
{
}
_molformula = strMolFormula;
return(dblMolWeight);
}
private void chemRenditor_Results_StructureChanged(object sender, EventArgs e)
{
try
{
if (chemRenditor_Results.MolfileString != null)
{
chemaxon.util.MolHandler molHandler = new MolHandler(chemRenditor_Results.MolfileString);
Molecule molObj = molHandler.getMolecule();
txtMolWeight.Text = molObj.getMass().ToString();
txtMolFormula.Text = molObj.getFormula();
string strMolfile = molObj.toFormat("mol");
string strIUPACName = "";
string strErrMsg = "";
if (ChemistryOperations.GetIUPACNameFromStructure(strMolfile, out strIUPACName, out strErrMsg))
{
strIUPACName = Validations.GetConvertedIUPACName(strIUPACName);
}
else
{
strIUPACName = "IUPAC name not provided";
}
txtIUPACName.Text = strIUPACName;
if (molObj.isAbsStereo())
{
lblChiral.Visible = true;
}
else
{
lblChiral.Visible = false;
}
}
}
catch (Exception ex)
{
ErrorHandling_NTS.WriteErrorLog(ex.ToString());
}
}
public static bool CheckStructureIsInV3000Format(string molfilestring)
{
bool blStatus = false;
try
{
if (!string.IsNullOrEmpty(molfilestring))
{
MolHandler mHandler = new MolHandler(molfilestring);
int molCnt = mHandler.getAtomCount();
if (molCnt > 999)//upto 999 is V2000 format, else V3000 format
{
blStatus = true;
}
}
}
catch (Exception ex)
{
ErrorHandling.WriteErrorLog(ex.ToString());
}
return(blStatus);
}
public void TestSet_String_String()
{
string molfile = "NCDK.Data.MDL.decalin.mol";
string queryfile = "NCDK.Data.MDL.decalin.mol";
IAtomContainer query = new AtomContainer();
IAtomContainer target = new AtomContainer();
var ins = ResourceLoader.GetAsStream(molfile);
var reader = new MDLV2000Reader(ins, ChemObjectReaderMode.Strict);
reader.Read(query);
ins = ResourceLoader.GetAsStream(queryfile);
reader = new MDLV2000Reader(ins, ChemObjectReaderMode.Strict);
reader.Read(target);
VFlibSubStructureHandler smsd1 = new VFlibSubStructureHandler();
MolHandler mol1 = new MolHandler(query, true, true);
MolHandler mol2 = new MolHandler(target, true, true);
smsd1.Set(mol1, mol2);
Assert.IsTrue(smsd1.IsSubgraph(true));
}
public static string GetStructureInchiKey(string _molfilestring)
{
string strInchiKey = "Inchi Not generated";
try
{
MolHandler mHandler = new MolHandler(_molfilestring);
Molecule mol = mHandler.getMolecule();
try
{
strInchiKey = mol.toFormat("inchi:key");
}
catch //Exception is inchi not generated
{
// if inchi not generated
SetMolAbsStereo_Inchi_NotGenerated(ref mol);
strInchiKey = mol.toFormat("inchi:key");
}
if (!string.IsNullOrEmpty(strInchiKey))
{
strInchiKey = GetInchiKeyFromInchiString(strInchiKey);
}
//MOSFIJXAXDLOML-UHFFFAOYSA-N is a place holder for non-succesful INCHIKey conversion accroding to JCHEM
if (strInchiKey.ToUpper().Trim() == "MOSFIJXAXDLOML-UHFFFAOYSA-N")
{
strInchiKey = "";
}
return(strInchiKey);
}
catch (Exception ex)
{
//PepsiLiteErrorHandling.WriteErrorLog(ex.ToString());
}
return(strInchiKey);
}
public static string GetMoleculeFormula(string molstring)
{
//string strMolWeight = "";
string strMolFormula = "";
try
{
MolHandler mHandler = new MolHandler(molstring);
//float molWeight = mHandler.calcMolWeight();
//strMolFormula = mHandler.calcMolFormula();
//strMolWeight = molWeight.ToString();
//molweight_out = strMolWeight;
return(strMolFormula);
}
catch (Exception ex)
{
Log.This(ex);
}
//molweight_out = strMolWeight;
return(strMolFormula);
}
public static string GetStandardizedMolecule(string strMolFile, out bool isChiral_Out)
{
string strStandMol = "";
bool blIsChiral = false;
try
{
chemaxon.util.MolHandler molHandler = new MolHandler(strMolFile);
Molecule molObj = molHandler.getMolecule();
Molecule molObj_Stand = StandardizeMolecule(molObj, out blIsChiral);
strStandMol = molObj_Stand.toFormat("mol");
isChiral_Out = blIsChiral;
return(strStandMol);
}
catch (Exception ex)
{
ErrorHandling.WriteErrorLog(ex.ToString());
}
isChiral_Out = blIsChiral;
return(strStandMol);
}
public static string GetMoleculeWeightAndMolFormula(string molstring, out string molformula_out)
{
string strMolWeight = "";
string strMolFormula = "";
try
{
MolHandler mHandler = new MolHandler(molstring);
float fltMolWeight = mHandler.calcMolWeight();
strMolFormula = mHandler.calcMolFormula();
strMolWeight = fltMolWeight.ToString();
molformula_out = strMolFormula;
return(strMolWeight);
}
catch (Exception ex)
{
ErrorHandling.WriteErrorLog(ex.ToString());
}
molformula_out = strMolFormula;
return(strMolWeight);
}
