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);
}
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_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" 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" 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" 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_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);
}
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);
}
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" 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);
}
int main(int argc,char *argv[])
{
// turn off slow sync with C-style output (we don't use it anyway).
std::ios::sync_with_stdio(false);
if (argc != 1)
{
cout << "Usage: format" << endl;
cout << " Unit tests for OBFormat " << endl;
return(-1);
}
cout << "# Unit tests for OBFormat \n";
// the number of tests for "prove"
cout << "1..4\n";
cout << "ok 1\n"; // for loading tests
OBConversion obConversion;
obConversion.SetInAndOutFormats("smi", "mdl");
cout << "ok 2\n";
OBFormat *inFormat = obConversion.GetInFormat();
if (inFormat)
cout << "ok 3\n";
else
cout << "not ok 3\n";
OBFormat *outFormat = obConversion.GetOutFormat();
if (outFormat)
cout << "ok 4\n";
else
cout << "not ok 4\n";
return(0);
}
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);
}
///////////////////////////////////////////////////////////////////////////////
//! \brief Set a tortional bond to a given angle
int main(int argc,char **argv)
{
const char *Pattern=NULL;
unsigned int i, t, errflg = 0;
int c;
char flags[255];
string err;
bool graphOutput=false;
// parse the command line -- optional -a flag to change all matching torsions
if (argc < 3 || argc > 4) {
errflg++;
} else {
FileIn = argv[1];
Pattern = "[!$(*#*)&!D1]-!@[!$(*#*)&!D1]";
// Read the atom position
c = sscanf(argv[2], "%d", &angleSum);
angle = 360./angleSum;
if (argc == 4)
{
c = sscanf(argv[3], "%s", flags);
int flagid=1;
while (flags[flagid]!=0)
switch (flags[flagid++])
{
case 'g':
graphOutput=true;
case 'e':
forceField=OBForceField::FindForceField("MMFF94");
isEnergyCalcing=true;
break;
}
}
}
if (errflg) {
cerr << "Usage: rkrotate <filename> <angle> [options]" << endl;
exit(-1);
}
// create pattern
OBSmartsPattern sp;
sp.Init(Pattern);
OBFormat* format = conv.FormatFromExt(FileIn);
if(!(format && conv.SetInAndOutFormats(format, format))) { //in and out formats same
cerr << "obrotate: cannot read and/or write this file format!" << endl;
exit (-1);
} //...NF
//Open the molecule file
ifstream ifs;
// Read the file
ifs.open(FileIn);
if (!ifs) {
cerr << "obrotate: cannot read input file!" << endl;
exit (-1);
}
OBMol mol;
vector< vector <int> > maplist; // list of matched atoms
// vector< vector <int> >::iterator m; // and its iterators
// int tindex;
// Set the angles
for (;;) {
mol.Clear();
//NF ifs >> mol; // Read molecule
conv.Read(&mol,&ifs); //NF
if (mol.Empty())
break;
if (sp.Match(mol)) {
// if match perform rotation
maplist = sp.GetUMapList(); // get unique matches
if (maplist.size() > 1)
cerr << "obrotate: Found " << maplist.size() << " matches." << endl;
energySheet=new MultiVector<double>(degrees=maplist.size(),angleSum);
indexSheet=new int[maplist.size()];
for (int EXO=0;EXO<maplist.size();++EXO)
totalSum*=angleSum+EXO;
// look at all the mapping atom but save only the last one.
turnMol(mol,maplist,maplist.size()-1);
if (graphOutput)
{
ofstream ofs("energyGraph.mlog");
int ind[degrees];
for (int i=0;i<degrees;++i)
ind[i]=0;
do
{
for (int i=0;i<degrees;++i)
ofs<<ind[i]<<'\t';
ofs<<energySheet->getVectorValue(ind)<<endl;
}
while(energySheet->incressIndex(ind));
}
if (isEnergyCalcing)
{
std::vector<int*> lowEnergySheet;
totalSum=energySheet->getMinValues(lowEnergySheet);
if (totalSum)
outputMol(lowEnergySheet,mol,maplist,maplist.size()-1);
else
cerr << "rkrotate: No low energy conformation found." << endl;
}
cout << sum;
} else {
cerr << "obrotate: Found 0 matches for the SMARTS pattern." << endl;
exit(-1);
}
//NF cout << mol;
}
return(0);
}
int main(int argc,char **argv)
{
char *program_name= argv[0];
char *FileIn = NULL;
if (argc != 2)
{
cout << "Usage: " << program_name << " <filename>" << endl;
exit(-1);
}
else
{
FileIn = argv[1];
// const char* p = strrchr(FileIn,'.');
}
// Find Input filetype
OBConversion conv;
OBFormat *format = conv.FormatFromExt(FileIn);
if (!format || !conv.SetInAndOutFormats(format, format))
{
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;
OBAtom *atom;
for (int c=1;;++c) // big for loop (replace with do while?)
{
mol.Clear();
conv.Read(&mol, &ifs);
if (mol.Empty())
break;
cout << "Molecule "<< c << ": " << mol.GetTitle() << endl;
//mol.FindChiralCenters(); // labels all chiral atoms
vector<OBAtom*>::iterator i; // iterate over all atoms
for (atom = mol.BeginAtom(i);atom;atom = mol.NextAtom(i))
{
if(!atom->IsChiral())continue; // aborts if atom isn't chiral
cout << "Atom " << atom->GetIdx() << " Is Chiral ";
cout << atom->GetType()<<endl;
OBChiralData* cd = (OBChiralData*)atom->GetData(OBGenericDataType::ChiralData);
if (cd){
vector<unsigned int> x=cd->GetAtom4Refs(input);
size_t n=0;
cout <<"Atom4refs:";
for (n=0;n<x.size();++n)
cout <<" "<<x[n];
cout <<endl;
}
else{cd=new OBChiralData;atom->SetData(cd);}
vector<unsigned int> _output;
unsigned int n;
for(n=1;n<5;++n) _output.push_back(n);
cd->SetAtom4Refs(_output,output);
/* // MOLV3000 uses 1234 unless an H then 123H
if (atom->GetHvyValence()==3)
{
OBAtom *nbr;
int Hid=1000;// max Atom ID +1 should be used here
vector<unsigned int> nbr_atms;
vector<OBBond*>::iterator i;
for (nbr = atom->BeginNbrAtom(i);nbr;nbr = atom->NextNbrAtom(i))
{
if (nbr->IsHydrogen()){Hid=nbr->GetIdx();continue;}
nbr_atms.push_back(nbr->GetIdx());
}
sort(nbr_atms.begin(),nbr_atms.end());
nbr_atms.push_back(Hid);
OBChiralData* cd=(OBChiralData*)atom->GetData(OBGenericDataType::ChiralData);
cd->SetAtom4Refs(nbr_atms,output);
}
else if (atom->GetHvyValence()==4)
{
OBChiralData* cd=(OBChiralData*)atom->GetData(OBGenericDataType::ChiralData);
vector<unsigned int> nbr_atms;
int n;
for(n=1;n<5;++n)nbr_atms.push_back(n);
cd->SetAtom4Refs(nbr_atms,output);
} */
/* FIXME
if (!mol.HasNonZeroCoords())
{
cout << "Calcing 0D chirality "<< CorrectChirality(mol,atom)<<endl;
}
else {
cout << "Volume= "<< CalcSignedVolume(mol,atom) << endl;
OBChiralData* cd=(OBChiralData*)atom->GetData(OBGenericDataType::ChiralData);
size_t n;
vector<unsigned int> refs=cd->GetAtom4Refs(output);
cout<<"Atom refs=";
for(n=0;n<refs.size();++n)cout<<" "<<refs[n];
cout<<endl;
}
cout << "Clockwise? " << atom->IsClockwise() << endl;
*/
} // end iterating over atoms
} // end big for loop
return(0);
} // end main
int main(int argc,char **argv)
{
char *program_name= argv[0];
int c;
int steps = 2500;
double crit = 1e-6;
bool sd = false;
bool cut = false;
bool newton = false;
bool hydrogens = false;
double rvdw = 6.0;
double rele = 10.0;
int freq = 10;
string basename, filename = "", option, option2, ff = "MMFF94";
char *oext;
OBConversion conv;
OBFormat *format_out = conv.FindFormat("pdb"); // default output format
if (argc < 2) {
cout << "Usage: obminimize [options] <filename>" << endl;
cout << endl;
cout << "options: description:" << endl;
cout << endl;
cout << " -c crit set convergence criteria (default=1e-6)" << endl;
cout << endl;
cout << " -cg use conjugate gradients algorithm (default)" << endl;
cout << endl;
cout << " -sd use steepest descent algorithm" << endl;
cout << endl;
cout << " -newton use Newton2Num linesearch (default=Simple)" << endl;
cout << endl;
cout << " -ff ffid select a forcefield:" << endl;
cout << endl;
cout << " -h add hydrogen atoms" << endl;
cout << endl;
cout << " -n steps specify the maximum numer of steps (default=2500)" << endl;
cout << endl;
cout << " -cut use cut-off (default=don't use cut-off)" << endl;
cout << endl;
cout << " -rvdw rvdw specify the VDW cut-off distance (default=6.0)" << endl;
cout << endl;
cout << " -rele rele specify the Electrostatic cut-off distance (default=10.0)" << endl;
cout << endl;
cout << " -pf freq specify the frequency to update the non-bonded pairs (default=10)" << endl;
cout << endl;
OBPlugin::List("forcefields", "verbose");
exit(-1);
} else {
int ifile = 1;
for (int i = 1; i < argc; i++) {
option = argv[i];
// steps
if ((option == "-n") && (argc > (i+1))) {
steps = atoi(argv[i+1]);
ifile += 2;
}
// vdw cut-off
if ((option == "-rvdw") && (argc > (i+1))) {
rvdw = atof(argv[i+1]);
ifile += 2;
}
// ele cut-off
if ((option == "-rele") && (argc > (i+1))) {
rele = atof(argv[i+1]);
ifile += 2;
}
// pair update frequency
if ((option == "-pf") && (argc > (i+1))) {
freq = atoi(argv[i+1]);
ifile += 2;
}
// steepest descent
if (option == "-sd") {
sd = true;
ifile++;
}
// enable cut-off
if (option == "-cut") {
cut = true;
ifile++;
}
// enable Newton2Num
if (option == "-newton") {
newton = true;
ifile++;
}
if (strncmp(option.c_str(), "-o", 2) == 0) {
oext = argv[i] + 2;
if(!*oext) {
oext = argv[++i]; //space left after -o: use next argument
ifile++;
}
format_out = conv.FindFormat(oext);
ifile++;
}
if (option == "-h") {
hydrogens = true;
ifile++;
}
if (option == "-cg") {
sd = false;
ifile++;
}
if ((option == "-c") && (argc > (i+1))) {
crit = atof(argv[i+1]);
ifile += 2;
}
if ((option == "-ff") && (argc > (i+1))) {
ff = argv[i+1];
ifile += 2;
}
}
basename = filename = argv[ifile];
size_t extPos = filename.rfind('.');
if (extPos!= string::npos) {
basename = filename.substr(0, extPos);
}
}
// Find Input filetype
OBFormat *format_in = conv.FormatFromExt(filename.c_str());
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);
}
OBForceField* pFF = OBForceField::FindForceField(ff);
if (!pFF) {
cerr << program_name << ": could not find forcefield '" << ff << "'." <<endl;
exit (-1);
}
// set some force field variables
pFF->SetLogFile(&cerr);
pFF->SetLogLevel(OBFF_LOGLVL_LOW);
pFF->SetVDWCutOff(rvdw);
pFF->SetElectrostaticCutOff(rele);
pFF->SetUpdateFrequency(freq);
pFF->EnableCutOff(cut);
if (newton)
pFF->SetLineSearchType(LineSearchType::Newton2Num);
OBMol mol;
for (c=1;;c++) {
mol.Clear();
if (!conv.Read(&mol, &ifs))
break;
if (mol.Empty())
break;
if (hydrogens)
mol.AddHydrogens();
if (!pFF->Setup(mol)) {
cerr << program_name << ": could not setup force field." << endl;
exit (-1);
}
bool done = true;
OBStopwatch timer;
timer.Start();
if (sd) {
pFF->SteepestDescentInitialize(steps, crit);
} else {
pFF->ConjugateGradientsInitialize(steps, crit);
}
unsigned int totalSteps = 1;
while (done) {
if (sd)
done = pFF->SteepestDescentTakeNSteps(1);
else
done = pFF->ConjugateGradientsTakeNSteps(1);
totalSteps++;
if (pFF->DetectExplosion()) {
cerr << "explosion has occured!" << endl;
conv.Write(&mol, &cout);
return(1);
} else
pFF->GetCoordinates(mol);
}
double timeElapsed = timer.Elapsed();
pFF->GetCoordinates(mol);
conv.Write(&mol, &cout);
cerr << "Time: " << timeElapsed << "seconds. Iterations per second: " << double(totalSteps) / timeElapsed << endl;
} // end for loop
return(0);
}
int main(int argc,char *argv[])
{
// turn off slow sync with C-style output (we don't use it anyway).
std::ios::sync_with_stdio(false);
if (argc != 1)
{
cout << "Usage: conversion" << endl;
cout << " Unit tests for OBConversion " << endl;
return(-1);
}
cout << "# Unit tests for OBConversion \n";
// the number of tests for "prove"
cout << "1..9\n";
cout << "ok 1\n"; // for loading tests
OBMol obMol;
OBConversion obConversion;
obConversion.SetInAndOutFormats("smi", "mdl");
cout << "ok 2\n";
obConversion.ReadString(&obMol, "C1=CC=CS1");
cout << "ok 3\n";
if (obMol.NumAtoms() == 5) {
cout << "ok 4\n";
} else {
cout << "not ok 4\n";
}
obMol.AddHydrogens();
if (obMol.NumAtoms() == 9) {
cout << "ok 5\n";
} else {
cout << "not ok 5\n";
}
if ( (obConversion.WriteString(&obMol)).length() > 0)
cout << "ok 6\n";
else
cout << "not ok 6\n";
// PR#1474265
obConversion.WriteFile(&obMol, "test.mdl");
ifstream ifs("test.mdl");
if (ifs.good())
cout << "ok 7\n";
else
cout << "not ok 7\n";
// PR#143577
obConversion.SetInFormat("mdl");
obConversion.ReadFile(&obMol, "test.mdl");
if ( remove("test.mdl") != -1)
cout << "ok 8\n";
else
cout << "not ok 8\n";
// gzip input
// gzip output
// multi-molecule reading
// PR#1465586
// aromatics.smi
// attype.00.smi
//ReadFile()
//Read()
//WriteString()
// GetOutputIndex()
// IsLast
//ReadString()
//IsFirstInput
//Read()
// splitting
// splitting using gzip-input
// PR#1357705
// size 0 input
// PR#1250900
// RegisterFormat
// FindFormat
// FormatFromExt
// FormatFromMIME
// GetNextFormat
// GetDefaultFormat
// BatchFileName
// IncrementedFileName
// option handling
// AddOption
// IsOption
// RemoveOption
// IsOption
// SetOptions
// IsOption
// RegisterOptionParam
// GetOptionParams
// GetInStream
// GetOutStream
// SetInStream
// SetOutStream
// nasty tests
obConversion.ReadString(&obMol, "");
obConversion.Read(&obMol);
cout << "ok 9\n";
return(0);
}
///////////////////////////////////////////////////////////////////////////////
//! \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);
}
///////////////////////////////////////////////////////////////////////////////
//! \brief compute rms between chemically identical molecules
int main(int argc, char **argv)
{
bool firstOnly = false;
if (argc != 3 && argc != 4)
{
cerr << "Usage: " << argv[0]
<< " [-firstonly] <reference structure(s)> <comparison structure(s)>\n";
cerr << "Computes the heavy-atom RMSD of identical compound structures.\n";
cerr << "Structures in multi-structure files are compared one-by-one unless -firstonly\n"
<< "is passed, in which case only the first structure in the reference file is used.\n";
exit(-1);
}
char *fileRef = argv[1];
char *fileTest = argv[2];
if (argc == 4)
{
//if iterate is passed as first command, try to match structures in first file to strucutres in second
if (strcmp("-firstonly", argv[1]) != 0)
{
cerr << "Usage: " << argv[0]
<< " [-firstonly] <reference structure(s)> <comparison structure(s)>\n";
exit(-1);
}
fileRef = argv[2];
fileTest = argv[3];
firstOnly = true;
}
//open mols
OBConversion refconv;
OBFormat *refFormat = refconv.FormatFromExt(fileRef);
if (!refFormat || !refconv.SetInFormat(refFormat)
|| !refconv.SetOutFormat("SMI"))
{
cerr << "Cannot read reference molecule format!" << endl;
exit(-1);
}
OBConversion testconv;
OBFormat *testFormat = testconv.FormatFromExt(fileTest);
if (!testFormat || !testconv.SetInAndOutFormats(testFormat, testFormat))
{
cerr << "Cannot read reference molecule format!" << endl;
exit(-1);
}
//read reference
ifstream ifsref;
OBMol molref;
ifsref.open(fileRef);
if (!ifsref)
{
cerr << "Cannot read fixed molecule file: " << fileRef << endl;
exit(-1);
}
//check comparison file
ifstream ifstest;
ifstest.open(fileTest);
if (!ifstest)
{
cerr << "Cannot read file: " << fileTest << endl;
exit(-1);
}
while (refconv.Read(&molref, &ifsref))
{
processMol(molref);
Matcher matcher(molref);// create the matcher
OBMol moltest;
while (testconv.Read(&moltest, &ifstest))
{
if (moltest.Empty())
break;
processMol(moltest);
double rmsd = matcher.computeRMSD(moltest);
cout << "RMSD " << moltest.GetTitle() << " " << rmsd << "\n";
if (!firstOnly)
{
break;
}
}
}
return (0);
}