extern "C" char *
ob_strip_salts (char *smiles, int neutralize_residue)
{
OBAtom atom;
OBMol mol, largestFragment;
OBConversion conv;
string tmpStr (smiles);
string outstring;
istringstream molstream1 (tmpStr);
ostringstream molstream2;
vector<OBMol> fragments;
vector <OBMol>::const_iterator i;
char *tmpMolfile;
int max = 0;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream1);
fragments = mol.Separate();
for( i = fragments.begin(); i != fragments.end(); i++ ) {
if (i->NumAtoms() > max) {
max=i->NumAtoms();
largestFragment = *i;
}
}
if(neutralize_residue != 0) {
largestFragment.ConvertDativeBonds();
FOR_ATOMS_OF_MOL(atom, largestFragment) {
atom->SetFormalCharge(0);
}
extern "C" char *
ob_add_hydrogens (char *smiles, int polaronly, int correct4PH)
{
OBMol mol;
OBConversion conv;
string tmpStr (smiles);
string outstring;
istringstream molstream1 (tmpStr);
ostringstream molstream2;
char *tmpMolfile;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream1);
mol.AddHydrogens (polaronly != 0, correct4PH != 0);
conv.Write (&mol, &molstream2);
outstring = molstream2.str ();
// remove the trailling $$$$\n from the SDFile
if (outstring.find ("$$$$\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 5);
}
else if (outstring.find ("$$$$\r\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 6);
}
tmpMolfile = strdup (outstring.c_str ());
return (tmpMolfile);
}
extern "C" char *
ob_mol_to_canonical_smiles (char *molfile, int omit_iso_and_chiral_markings)
{
OBMol mol;
OBConversion conv;
string tmpStr (molfile);
string outstring;
istringstream molstream (tmpStr);
ostringstream smilesstream;
char *tmpSmiles;
conv.SetInAndOutFormats ("MDL", "CAN");
conv.AddOption ("n", OBConversion::OUTOPTIONS);
//conv.AddOption ("c", OBConversion::OUTOPTIONS);
if (omit_iso_and_chiral_markings != 0)
{
conv.AddOption ("i", OBConversion::OUTOPTIONS);
}
conv.Read (&mol, &molstream);
if (mol.Empty ())
return NULL;
conv.Write (&mol, &smilesstream);
outstring = smilesstream.str ();
outstring = outstring.substr (0, outstring.length () - 1);
tmpSmiles = strdup (outstring.c_str ());
return (tmpSmiles);
}
extern "C" char *
ob_V3000_to_mol (char *V3000)
{
OBMol mol;
OBConversion conv;
string tmpStr (V3000);
string outstring;
istringstream V3000stream (tmpStr);
ostringstream molstream;
char *tmpMolfile;
conv.SetInAndOutFormats ("MDL", "MDL");
conv.AddOption ("3", OBConversion::INOPTIONS);
conv.AddOption ("2", OBConversion::OUTOPTIONS);
conv.Read (&mol, &V3000stream);
conv.Write (&mol, &molstream);
outstring = molstream.str ();
// remove the trailling $$$$\n from the SDFile
if (outstring.find ("$$$$\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 5);
}
else if (outstring.find ("$$$$\r\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 6);
}
tmpMolfile = strdup (outstring.c_str ());
return (tmpMolfile);
}
void InputFileExtension::readOutputFile(const QString filename)
{
QApplication::setOverrideCursor(Qt::WaitCursor);
OBConversion conv;
OBFormat *inFormat = conv.FormatFromExt( filename.toAscii() );
if ( !inFormat || !conv.SetInFormat( inFormat ) ) {
QApplication::restoreOverrideCursor();
QMessageBox::warning(m_widget, tr("Avogadro"),
tr("Cannot read file format of file %1.").arg(filename));
return;
}
// TODO: Switch to MoleculeFile
ifstream ifs;
ifs.open(QFile::encodeName(filename));
if (!ifs) { // shouldn't happen, already checked file above
QApplication::restoreOverrideCursor();
QMessageBox::warning(m_widget, tr("Avogadro"),
tr("Cannot read file %1.").arg( filename ) );
return;
}
OBMol *obmol = new OBMol;
if (conv.Read(obmol, &ifs)) {
Molecule *mol = new Molecule;
mol->setOBMol(obmol);
mol->setFileName(filename);
emit moleculeChanged(mol, Extension::DeleteOld);
m_molecule = mol;
}
QApplication::restoreOverrideCursor();
}
bool MakeQueriesFromMolInFile(vector<OBQuery*>& queries, const std::string& filename, int* pnAtoms, bool noH)
{
OBMol patternMol;
patternMol.SetIsPatternStructure();
OBConversion patternConv;
OBFormat* pFormat;
//Need to distinguish between filename and SMARTS. Not infallable...
if( filename.empty() ||
filename.find('.')==string::npos ||
!(pFormat = patternConv.FormatFromExt(filename.c_str())) ||
!patternConv.SetInFormat(pFormat) ||
!patternConv.ReadFile(&patternMol, filename) ||
patternMol.NumAtoms()==0)
return false;
if(noH)
patternMol.DeleteHydrogens();
do
{
*pnAtoms = patternMol.NumHvyAtoms();
queries.push_back(CompileMoleculeQuery(&patternMol));
}while(patternConv.Read(&patternMol));
return true;
}
// Helper function to read molecule from file
shared_ptr<OBMol> GetMol(const std::string &filename)
{
// Create the OBMol object.
shared_ptr<OBMol> mol(new OBMol);
// Create the OBConversion object.
OBConversion conv;
OBFormat *format = conv.FormatFromExt(filename.c_str());
if (!format || !conv.SetInFormat(format)) {
std::cout << "Could not find input format for file " << filename << std::endl;
return mol;
}
// Open the file.
std::ifstream ifs(filename.c_str());
if (!ifs) {
std::cout << "Could not open " << filename << " for reading." << std::endl;
return mol;
}
// Read the molecule.
if (!conv.Read(mol.get(), &ifs)) {
std::cout << "Could not read molecule from file " << filename << std::endl;
return mol;
}
return mol;
}
int main(int argc,char **argv)
{
char *program_name= argv[0];
int c;
char *FileIn = NULL;
if (argc != 2) {
cerr << " Usage: " << program_name << " <input file>\n";
exit(-1);
}
else {
FileIn = argv[1];
}
// Find Input filetype
OBConversion conv;
OBFormat *inFormat = conv.FormatFromExt(FileIn);
if (!inFormat || !conv.SetInFormat(inFormat)) {
cerr << program_name << ": cannot read input format!" << endl;
exit (-1);
}
ifstream ifs;
// Read the file
ifs.open(FileIn);
if (!ifs) {
cerr << program_name << ": cannot read input file!" << endl;
exit (-1);
}
OBMol mol;
OBPointGroup pg;
for (c = 1;; ++c)
{
mol.Clear();
conv.Read(&mol, &ifs);
if (mol.Empty())
break;
// not needed by OBPointGroup, but useful for external programs
mol.Center();
mol.ToInertialFrame();
pg.Setup(&mol);
cout << "Point Group: " << pg.IdentifyPointGroup() << endl;
} // end for loop
return(1);
}
void testAutomorphismMask() {
// read file: 3 6-rings
//
// /\ /\ /\
// | | | |
// \/ \/ \/
//
cout << "testAutomorphismMask" << endl;
OBMol mol;
OBConversion conv;
conv.SetInFormat("cml");
std::ifstream ifs(OBTestUtil::GetFilename("isomorphism1.cml").c_str());
OB_REQUIRE( ifs );
conv.Read(&mol, &ifs);
OBIsomorphismMapper::Mappings maps;
// First of all, how many automorphisms are there without any mask?
// This takes about 20 seconds, so you may want to comment this out while debugging
FindAutomorphisms(&mol, maps);
cout << maps.size() << endl;
OB_ASSERT( maps.size() == 4 );
// Now, let's remove the bridge (atomId 6) of the central ring.
//
// /\ /\ /\
// | | | |
// \/ \/
// both rings can be flipped around exocyclic bond, the whole molecule can be mirrored
// horizontally, this results in 2 x 2 x 2 = 8 automorphisms
OBBitVec mask;
mask.SetRangeOn(1, mol.NumAtoms());
mask.SetBitOff(6+1);
FindAutomorphisms(&mol, maps, mask);
cout << maps.size() << endl;
for (unsigned int i = 0; i < maps.size(); ++i) {
OBIsomorphismMapper::Mapping::const_iterator j;
for (j = maps[i].begin(); j != maps[i].end(); ++j)
cout << j->second << " ";
cout << endl;
}
OB_ASSERT( maps.size() == 8 );
// Verify that atom Id 6 does not occur anywhere in the mappings
OBIsomorphismMapper::Mappings::const_iterator a;
OBIsomorphismMapper::Mapping::const_iterator b;
for (a = maps.begin(); a != maps.end(); ++a)
for (b = a->begin(); b!= a->end(); ++b) {
OB_ASSERT( b->first != 6 );
OB_ASSERT( b->second != 6 );
}
}
int main(int argc, char **argv)
{
OBFunctionFactory *factory = OBFunctionFactory::GetFactory("MMFF94");
OBFunction *function = factory->NewInstance();
if (!function) {
cout << "ERROR: could not find MMFF94 function" << endl;
return -1;
}
if (argc < 2) {
cout << "Usage: " << argv[0] << " <filename>" << endl;
return -1;
}
OBMol mol;
OBConversion conv;
OBFormat *format = conv.FormatFromExt(argv[1]);
if (!format || !conv.SetInFormat(format)) {
cout << "ERROR: could not find format for file " << argv[1] << endl;
return -1;
}
std::ifstream ifs;
ifs.open(argv[1]);
conv.Read(&mol, &ifs);
ifs.close();
cout << "# atoms = " << mol.NumAtoms() << endl;
function->GetLogFile()->SetOutputStream(&std::cout);
function->GetLogFile()->SetLogLevel(OBLogFile::Low);
// read options file
if (argc == 3) {
std::ifstream cifs;
cifs.open(argv[2]);
std::stringstream options;
std::string line;
while (std::getline(cifs, line))
options << line << std::endl;
function->SetOptions(options.str());
}
function->Setup(mol);
OBMinimize minimize(function);
minimize.SteepestDescent(50);
}
void testIsomorphismMask()
{
// read file: 3 6-rings
//
// /\ /\ /\
// | | | |
// \/ \/ \/
//
OBMol mol;
OBConversion conv;
conv.SetInFormat("cml");
std::ifstream ifs(OBTestUtil::GetFilename("isomorphism1.cml").c_str());
OB_REQUIRE( ifs );
conv.Read(&mol, &ifs);
OBQuery *query = CompileSmilesQuery("C1CCCCC1");
OBIsomorphismMapper *mapper = OBIsomorphismMapper::GetInstance(query);
// no mask
OBIsomorphismMapper::Mappings maps;
mapper->MapUnique(&mol, maps);
cout << maps.size() << endl;
OB_ASSERT( maps.size() == 3 );
// mask first ring
OBBitVec mask;
for (int i = 0; i < 6; ++i)
mask.SetBitOn(i+1);
mapper->MapUnique(&mol, maps, mask);
cout << maps.size() << endl;
OB_ASSERT( maps.size() == 1 );
// mask second ring also
for (int i = 6; i < 10; ++i)
mask.SetBitOn(i+1);
mapper->MapUnique(&mol, maps, mask);
cout << maps.size() << endl;
OB_ASSERT( maps.size() == 2 );
// just mask last ring (atomIds 7-8, 10-13)
mask.Clear();
for (int i = 10; i < 14; ++i)
mask.SetBitOn(i+1);
mask.SetBitOn(7 + 1); mask.SetBitOn(8 + 1);
mapper->MapUnique(&mol, maps, mask);
cout << maps.size() << endl;
OB_ASSERT( maps.size() == 1 ); // Should be same result as masking just the first ring
delete query;
delete mapper;
}
extern "C" unsigned int
ob_is_nostruct (char *molfile)
{
OBMol mol;
OBConversion conv;
string tmpStr (molfile);
istringstream molstream (tmpStr);
conv.SetInAndOutFormats ("MDL", "MDL");
conv.Read (&mol, &molstream);
return (mol.Empty ())? 1 : 0;
}
extern "C" char *
ob_delete_hydrogens (char *smiles, int nonpolaronly)
{
OBMol mol;
OBConversion conv;
string tmpStr (smiles);
string outstring;
istringstream molstream1 (tmpStr);
ostringstream molstream2;
char *tmpMolfile;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream1);
if(mol.NumHvyAtoms () > 0) {
if (nonpolaronly != 0)
{
mol.DeleteNonPolarHydrogens ();
}
else
{
mol.DeleteHydrogens ();
}
} else {
cout << "Warning: Cannot remove hydrogens. Resulting molecule would be empty!" << endl;
}
conv.Write (&mol, &molstream2);
outstring = molstream2.str ();
// remove the trailling $$$$\n from the SDFile
if (outstring.find ("$$$$\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 5);
}
else if (outstring.find ("$$$$\r\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 6);
}
tmpMolfile = strdup (outstring.c_str ());
return (tmpMolfile);
}
/*****************************************************************
* This function Copyright (c) 2004
* by Bayer Business Services GmbH
*****************************************************************/
extern "C" double
ob_molweight (char *smiles)
{
OBMol mol;
OBConversion conv;
string tmpStr (smiles);
istringstream molstream (tmpStr);
double molweight = 0.0;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream);
molweight = mol.GetMolWt ();
return (molweight);
}
extern "C" unsigned int
ob_num_heavy_atoms (char *smiles)
{
OBMol mol;
OBConversion conv;
string tmpStr (smiles);
istringstream molstream (tmpStr);
unsigned int numheavyatoms = 0;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream);
numheavyatoms = mol.NumHvyAtoms ();
return (numheavyatoms);
}
extern "C" int
ob_total_charge (char *smiles)
{
OBMol mol;
OBConversion conv;
string tmpStr (smiles);
istringstream molstream (tmpStr);
int totalcharge = 0;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream);
totalcharge = mol.GetTotalCharge ();
return (totalcharge);
}
extern "C" unsigned int
ob_num_rotatable_bonds (char *smiles)
{
OBMol mol;
OBConversion conv;
string tmpStr (smiles);
istringstream molstream (tmpStr);
unsigned int numrotors = 0;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream);
numrotors = mol.NumRotors ();
return (numrotors);
}
char *serializeMolecule(const char *molecule) {
string instring(molecule);
string outstring;
istringstream inStream(instring);
LibHandler ob_lib;
if (!ob_lib.isLoaded()) {
return NULL;
}
OBMol mol;
OBConversion conv;
conv.SetInFormat(MOLECULE_TYPE);
conv.Read(&mol,&inStream);
return serializeOBMol(mol);
}
extern "C" int
ob_3D (char *molfile)
{
OBMol mol;
OBConversion conv;
string tmpStr (molfile);
istringstream molstream (tmpStr);
int threed = 0;
conv.SetInAndOutFormats ("MDL", "MDL");
conv.Read (&mol, &molstream);
if (mol.Has3D ())
threed++;
return (threed);
}
extern "C" unsigned int
ob_is_chiral (char *molfile)
{
OBMol mol;
OBConversion conv;
string tmpStr (molfile);
istringstream molstream (tmpStr);
int chiral = 0;
conv.SetInAndOutFormats ("MDL", "MDL");
conv.Read (&mol, &molstream);
mol.FindChiralCenters ();
chiral = mol.IsChiral ()? 1 : 0;
return (chiral);
}
extern "C" unsigned int
ob_num_bonds (char *smiles)
{
OBMol mol;
OBConversion conv;
string tmpStr (smiles);
istringstream molstream (tmpStr);
unsigned int numbonds = 0;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream);
//mol.AddHydrogens (false, false);
numbonds = mol.NumBonds ();
return (numbonds);
}
int main(int argc, char **argv)
{
if (argc < 2) {
std::cerr << "Usage: " << argv[0] << " filename" << std::endl;
return -1;
}
// read a molecule
OBConversion conv;
OBFormat *format = conv.FormatFromExt(argv[1]);
conv.SetInFormat(format);
std::string filename(argv[1]);
std::ifstream ifs;
ifs.open(filename.c_str());
if (!ifs) {
std::cerr << "Could not open " << filename << std::endl;
return -1;
}
CairoPainter *painter = new CairoPainter;
OBDepict depictor(painter);
string::size_type pos = filename.find_last_of(".");
if (pos != string::npos)
filename = filename.substr(0, pos);
OBMol mol;
unsigned int count = 1;
while (conv.Read(&mol, &ifs)) {
// depict the molecule
depictor.DrawMolecule(&mol);
depictor.AddAtomLabels(OBDepict::AtomSymmetryClass);
std::stringstream ss;
ss << filename << count << ".png";
painter->WriteImage(ss.str());
count++;
}
return 0;
}
extern "C" char *
ob_hillformula (char *smiles)
{
string tmpStr (smiles);
istringstream molstream (tmpStr);
string molfmla;
OBMol mol;
OBConversion conv;
char *tmpFormula;
conv.SetInAndOutFormats ("SMI", "SMI");
conv.Read (&mol, &molstream);
molfmla = mol.GetFormula ();
tmpFormula = strdup (molfmla.c_str ());
return (tmpFormula);
}
void testAutomorphismMask2()
{
// The test molecule is progesterone, a steroid (four fused non-planar rings)
cout << "testAutomorphismMask2" << endl;
OBMol mol;
OBConversion conv;
conv.SetInFormat("sdf");
std::ifstream ifs(OBTestUtil::GetFilename("progesterone.sdf").c_str());
OB_REQUIRE( ifs );
OB_REQUIRE( conv.Read(&mol, &ifs) );
Automorphisms _aut;
OBBitVec _frag_atoms;
FOR_ATOMS_OF_MOL(a, mol) {
if(!(a->IsHydrogen()))
_frag_atoms.SetBitOn(a->GetIdx());
}
FindAutomorphisms((OBMol*)&mol, _aut, _frag_atoms);
OB_ASSERT( _aut.size() == 1 );
}
bool verifyLSSR(const std::string &filename, const LSSR &ref)
{
cout << "Verify LSSR: " << filename << endl;
std::string file = OBTestUtil::GetFilename(filename);
// read a smiles string
OBMol mol;
OBConversion conv;
OBFormat *format = conv.FormatFromExt(file.c_str());
OB_REQUIRE( format );
OB_REQUIRE( conv.SetInFormat(format) );
std::ifstream ifs;
ifs.open(file.c_str());
OB_REQUIRE( ifs );
OB_REQUIRE( conv.Read(&mol, &ifs) );
std::vector<int> ringSizeCount(20, 0);
std::vector<OBRing*> lssr = mol.GetLSSR();
for (unsigned int i = 0; i < lssr.size(); ++i) {
ringSizeCount[lssr[i]->_path.size()]++;
}
/*
cout << "ringSize: ringCount" << endl;
cout << "3: " << ringSizeCount[3] << endl;
cout << "4: " << ringSizeCount[4] << endl;
cout << "5: " << ringSizeCount[5] << endl;
cout << "6: " << ringSizeCount[6] << endl;
*/
bool fail = false;
for (unsigned int i = 0; i < ref.size_count.size(); ++i) {
const LSSR::Size_Count &size_count = ref.size_count[i];
OB_ASSERT( ringSizeCount[size_count.ringSize] == size_count.ringCount );
}
return true;
}
extern "C" char *
ob_inchi_to_mol (char *inchi)
{
OBMol mol;
OBConversion conv;
string tmpStr (inchi);
string outstring;
istringstream inchistream (tmpStr);
ostringstream molstream;
char *tmpMolfile;
conv.SetInAndOutFormats ("INCHI", "MDL");
conv.Read (&mol, &inchistream);
if (mol.Empty ())
return NULL;
conv.Write (&mol, &molstream);
outstring = molstream.str ();
// remove the trailling $$$$\n from the SDFile
if (outstring.find ("$$$$\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 5);
}
else if (outstring.find ("$$$$\r\n", 0) != string::npos)
{
outstring = outstring.substr (0, outstring.length () - 6);
}
tmpMolfile = strdup (outstring.c_str ());
return (tmpMolfile);
}
bool doShuffleTestMultiFile(const std::string &filename)
{
cout << "Shuffling: " << filename << endl;
std::string file = OBTestUtil::GetFilename(filename);
// read a smiles string
OBMol mol;
OBConversion conv;
OBFormat *format = conv.FormatFromExt(file.c_str());
OB_REQUIRE( format );
OB_REQUIRE( conv.SetInFormat(format) );
std::ifstream ifs;
ifs.open(file.c_str());
OB_REQUIRE( ifs );
bool result = true;
while (conv.Read(&mol, &ifs)) {
bool res = doShuffleTestMolecule(mol);
if (!res)
result = res;
}
return result;
}
int main(int argc, char **argv)
{
if (argc < 3) {
std::cerr << "Usage: " << argv[0] << " <molecule_file> <output_score_file>" << std::endl;
return 1;
}
unsigned long numAtoms = 0;
unsigned long numAromaticAtoms = 0;
unsigned long numCyclicAtoms = 0;
std::map<int, unsigned long> mass;
std::map<int, unsigned long> elem;
std::map<int, unsigned long> aromelem;
std::map<int, unsigned long> aliphelem;
std::map<int, unsigned long> hcount;
std::map<int, unsigned long> charge;
std::map<int, unsigned long> connect;
std::map<int, unsigned long> degree;
std::map<int, unsigned long> implicit;
std::map<int, unsigned long> rings;
std::map<int, unsigned long> size;
std::map<int, unsigned long> valence;
std::map<int, unsigned long> chiral;
std::map<int, unsigned long> hyb;
std::map<int, unsigned long> ringconnect;
unsigned long numBonds = 0;
unsigned long numSingleBonds = 0;
unsigned long numDoubleBonds = 0;
unsigned long numTripleBonds = 0;
unsigned long numAromaticBonds = 0;
unsigned long numRingBonds = 0;
OBConversion conv;
conv.SetInFormat(conv.FormatFromExt(argv[1]));
std::ifstream ifs(argv[1]);
conv.SetInStream(&ifs);
OBMol mol;
unsigned long molecule = 0;
while (conv.Read(&mol)) {
++molecule;
//if ((molecule % 1000) == 0)
// std::cout << molecule << std::endl;
FOR_ATOMS_OF_MOL (atom, mol) {
numAtoms++;
if (atom->IsAromatic()) {
numAromaticAtoms++;
aromelem[atom->GetAtomicNum()]++;
} else
aliphelem[atom->GetAtomicNum()]++;
if (atom->IsInRing())
numCyclicAtoms++;
mass[atom->GetIsotope()]++;
elem[atom->GetAtomicNum()]++;
hcount[atom->ExplicitHydrogenCount() + atom->ImplicitHydrogenCount()]++;
charge[atom->GetFormalCharge()]++;
connect[atom->GetImplicitValence()]++;
degree[atom->GetValence()]++;
implicit[atom->ImplicitHydrogenCount()]++;
rings[atom->MemberOfRingCount()]++;
for (int i = 3; i < 25; ++i)
if (atom->IsInRingSize(i))
size[i]++;
valence[atom->KBOSum() - (atom->GetSpinMultiplicity() ? atom->GetSpinMultiplicity() - 1 : 0)]++;
hyb[atom->GetHyb()]++;
ringconnect[atom->CountRingBonds()]++;
}
FOR_BONDS_OF_MOL (bond, mol) {
numBonds++;
if (bond->IsSingle())
numSingleBonds++;
else if (bond->IsDouble())
numDoubleBonds++;
else if (bond->IsTriple())
numTripleBonds++;
if (bond->IsAromatic())
numAromaticBonds++;
if (bond->IsInRing())
numRingBonds++;;
}
///////////////////////////////////////////////////////////////////////////////
//! \brief Generate rough 3D coordinates for SMILES (or other 0D files).
//
int main(int argc,char **argv)
{
char *program_name= argv[0];
int c;
string basename, filename = "", option, option2, ff = "MMFF94";
list<string> argl(argv+1, argv+argc);
list<string>::iterator optff = find(argl.begin(), argl.end(), "-ff");
if (optff != argl.end()) {
list<string>::iterator optffarg = optff;
++optffarg;
if (optffarg != argl.end()) {
ff = *optffarg;
argl.erase(optff,++optffarg);
} else {
argl.erase(optff);
}
}
if (argl.empty()) {
cout << "Usage: obgen <filename> [options]" << endl;
cout << endl;
cout << "options: description:" << endl;
cout << endl;
cout << " -ff select a forcefield" << endl;
cout << endl;
OBPlugin::List("forcefields", "verbose");
exit(-1);
}
basename = filename = *argl.begin();
size_t extPos = filename.rfind('.');
if (extPos!= string::npos) {
basename = filename.substr(0, extPos);
}
// Find Input filetype
OBConversion conv;
OBFormat *format_in = conv.FormatFromExt(filename.c_str());
OBFormat *format_out = conv.FindFormat("sdf");
if (!format_in || !format_out || !conv.SetInAndOutFormats(format_in, format_out)) {
cerr << program_name << ": cannot read input/output format!" << endl;
exit (-1);
}
ifstream ifs;
ofstream ofs;
// Read the file
ifs.open(filename.c_str());
if (!ifs) {
cerr << program_name << ": cannot read input file!" << endl;
exit (-1);
}
OBMol mol;
for (c=1;;c++) {
mol.Clear();
if (!conv.Read(&mol, &ifs))
break;
if (mol.Empty())
break;
OBForceField* pFF = OBForceField::FindForceField(ff);
if (!pFF) {
cerr << program_name << ": could not find forcefield '" << ff << "'." <<endl;
exit (-1);
}
//mol.AddHydrogens(false, true); // hydrogens must be added before Setup(mol) is called
pFF->SetLogFile(&cerr);
pFF->SetLogLevel(OBFF_LOGLVL_LOW);
//pFF->GenerateCoordinates();
OBBuilder builder;
builder.Build(mol);
mol.AddHydrogens(false, true); // hydrogens must be added before Setup(mol) is called
if (!pFF->Setup(mol)) {
cerr << program_name << ": could not setup force field." << endl;
exit (-1);
}
pFF->SteepestDescent(500, 1.0e-4);
pFF->WeightedRotorSearch(250, 50);
pFF->SteepestDescent(500, 1.0e-6);
pFF->UpdateCoordinates(mol);
//pFF->ValidateGradients();
//pFF->SetLogLevel(OBFF_LOGLVL_HIGH);
//pFF->Energy();
//char FileOut[32];
//sprintf(FileOut, "%s_obgen.pdb", basename.c_str());
//ofs.open(FileOut);
//conv.Write(&mol, &ofs);
//ofs.close();
conv.Write(&mol, &cout);
} // end for loop
return(0);
}
bool FastSearchFormat::ObtainTarget(OBConversion* pConv, vector<OBMol>& patternMols, const string& indexname)
{
//Obtains an OBMol from:
// the filename in the -s option or
// the SMARTS string in the -s option or
// by converting the file in the -S or -aS options (deprecated).
// If there is no -s -S or -aS option, information on the index file is displayed.
OBMol patternMol;
patternMol.SetIsPatternStructure();
const char* p = pConv->IsOption("s",OBConversion::GENOPTIONS);
bool OldSOption=false;
//If no -s option, make OBMol from file in -S option or -aS option (both deprecated)
if(!p)
{
p = pConv->IsOption("S",OBConversion::GENOPTIONS);
if(!p)
p = pConv->IsOption("S",OBConversion::INOPTIONS);//for GUI mainly
OldSOption = true;
}
if(p)
{
vector<string> vec;
tokenize(vec, p);
//ignore leading ~ (not relevant to fastsearch)
if(vec[0][0]=='~')
vec[0].erase(0,1);
if(vec.size()>1 && vec[1]=="exact")
pConv->AddOption("e", OBConversion::INOPTIONS);
OBConversion patternConv;
OBFormat* pFormat;
//Interpret as a filename if possible
string& txt =vec [0];
if( txt.empty() ||
txt.find('.')==string::npos ||
!(pFormat = patternConv.FormatFromExt(txt.c_str())) ||
!patternConv.SetInFormat(pFormat) ||
!patternConv.ReadFile(&patternMol, txt) ||
patternMol.NumAtoms()==0)
//if false, have a valid patternMol from a file
{
//is SMARTS/SMILES
//Replace e.g. [#6] in SMARTS by C so that it can be converted as SMILES
//for the fingerprint phase, but allow more generality in the SMARTS phase.
for(;;)
{
string::size_type pos1, pos2;
pos1 = txt.find("[#");
if(pos1==string::npos)
break;
pos2 = txt.find(']');
int atno;
if(pos2!=string::npos && (atno = atoi(txt.substr(pos1+2, pos2-pos1-2).c_str())) && atno>0)
txt.replace(pos1, pos2-pos1+1, etab.GetSymbol(atno));
else
{
obErrorLog.ThrowError(__FUNCTION__,"Ill-formed [#n] atom in SMARTS", obError);
return false;
}
}
bool hasTildeBond;
if( (hasTildeBond = (txt.find('~')!=string::npos)) ) // extra parens to indicate truth value
{
//Find ~ bonds and make versions of query molecule with a single and aromatic bonds
//To avoid having to parse the SMILES here, replace ~ by $ (quadruple bond)
//and then replace this in patternMol. Check first that there are no $ already
//Sadly, isocynanides may have $ bonds.
if(txt.find('$')!=string::npos)
{
obErrorLog.ThrowError(__FUNCTION__,
"Cannot use ~ bonds in patterns with $ (quadruple) bonds.)", obError);
return false;
}
replace(txt.begin(),txt.end(), '~' , '$');
}
//read as standard SMILES
patternConv.SetInFormat("smi");
if(!patternConv.ReadString(&patternMol, vec[0]))
{
obErrorLog.ThrowError(__FUNCTION__,"Cannot read the SMILES string",obError);
return false;
}
if(hasTildeBond)
{
AddPattern(patternMols, patternMol, 0); //recursively add all combinations of tilde bond values
return true;
}
}
else
{
// target(s) are in a file
patternMols.push_back(patternMol);
while(patternConv.Read(&patternMol))
patternMols.push_back(patternMol);
return true;
}
}
if(OldSOption) //only when using deprecated -S and -aS options
{
//make -s option for later SMARTS test
OBConversion conv;
if(conv.SetOutFormat("smi"))
{
string optiontext = conv.WriteString(&patternMol, true);
pConv->AddOption("s", OBConversion::GENOPTIONS, optiontext.c_str());
}
}
if(!p)
{
//neither -s or -S options provided. Output info rather than doing search
const FptIndexHeader& header = fs.GetIndexHeader();
string id(header.fpid);
if(id.empty())
id = "default";
clog << indexname << " is an index of\n " << header.datafilename
<< ".\n It contains " << header.nEntries
<< " molecules. The fingerprint type is " << id << " with "
<< OBFingerprint::Getbitsperint() * header.words << " bits.\n"
<< "Typical usage for a substructure search:\n"
<< "obabel indexfile.fs -osmi -sSMILES\n"
<< "(-s option in GUI is 'Convert only if match SMARTS or mols in file')" << endl;
return false;
}
patternMols.push_back(patternMol);
return true;
}