RDKit::RWMol* MolpherMol::MolpherMolImpl::asRDMol(bool include_locks) const {
RDKit::RWMol* ret = new RDKit::RWMol(*(rd_mol), true, -1);
if (include_locks) {
std::map<std::string, std::vector<int>> locks_map;
auto atoms = getAtoms();
for (int atm_idx = 0; atm_idx != atoms.size(); atm_idx++) {
auto atm = atoms[atm_idx];
if (atm->isLocked()) {
auto atm_locks(MolpherAtom::lockingMaskToString(atm->getLockingMask()));
for (auto lock : atm_locks) {
if (locks_map.find(lock) == locks_map.end()) {
locks_map[lock] = std::vector<int>();
}
locks_map[lock].push_back(atm_idx+1);
}
}
}
for (auto pair : locks_map) {
std::ostringstream oss;
std::copy(pair.second.begin(), pair.second.end()-1,
std::ostream_iterator<int>(oss, ","));
oss << pair.second.back();
ret->setProp("MOLPHER_" + pair.first, oss.str());
}
}
return ret;
}
void Group::align(QList<Vec> const& current)
{
AtomList atoms(getAtoms());
int nAtoms(atoms.size());
if (current.size() != nAtoms) {
QMsgBox::warning(0, "IQmol", "Coordinate mismatch in Group alignment");
return;
}
QList<double> weights;
QList<Vec> reference;
AtomList::iterator atom;
for (atom = atoms.begin(); atom != atoms.end(); ++atom) {
reference.append((*atom)->getTranslation());
weights.append((*atom)->getMass());
}
Util::Align align(reference, current, weights);
if (!align.computeAlignment()) {
QMsgBox::warning(0, "IQmol", "Alignment failed in Group::align");
return;
}
setRotation(align.rotation());
setTranslation(align.translation());
}
/**
* @brief constructor: gets Display vars and registers us
*/
XfitMan::XfitMan()
{
#if 0
getAtoms();
#endif
root = QX11Info::appRootWindow();
#if 0
screencount = ScreenCount(QX11Info::display());
#endif
}
int Surface3D::findZmin(int zBegin) {
for (auto z = m_surfaces2D.cbegin() + zBegin; z != m_surfaces2D.cend(); ++z)
for (auto y = z->cbegin() + 2; y != z->cend() - 1; ++y) {
auto const yEnd = y->cend();
for (auto x = y->cbegin() + 2; x != yEnd - 1; ++x)
for (auto const& atom : x->getAtoms())
if (!atom.deleted) {
return static_cast<int>(z - m_surfaces2D.cbegin());
}
}
return zBegin;
}
void Residue::find_atom_named(string name, Atom * a)
{
// This method assumes that all atoms in a residue has unique names!
vector<Atom*> atoms = getAtoms();
for(vector<Atom*>::iterator atom = atoms.begin(); atom != atoms.end(); atom++)
if((*atom)->name==name)
{
*a = **atom;
return;
}
return;
}
const Ptr<ImageAtom>& ImageMolecule::getAnchor() const throw (std::logic_error)
{
if (atoms_.empty())
{
throw logic_error("The molecule is empty!");
}
//if the anchor has not been set then just return the begining of
//atoms
if (anchor_.empty())
return *getAtoms().begin();
return anchor_;
}
void Soup::set_sybyl_atom_types()
{
// Setup sybyl atom types
sybyl_types.clear();
ifstream in;
char line[256];
string s;
in.open("parameters/sybyl_types.txt");
if(! in.is_open())
{
cout << "Error:File 'parameters/sybyl_types.txt' could not be found\n";
exit(0);
}
while(!in.eof())
{
in.getline(line,256);
//cout<<line<<endl;
s = string(line);
if (s.size()>3)
{
string key = s.substr(0,8);
for(unsigned int i=0; i<key.size(); )
if(string(key,i,1) ==" ")
key = key.erase(i, 1);
else
i++;
string atom_name = s.substr(8,14);
for(unsigned int i=0; i<atom_name.size(); )
if(string(atom_name,i,1) ==" ")
atom_name = atom_name.erase(i, 1);
else
i++;
sybyl_types[key]= atom_name.c_str();
// cout<<"Atom "<<key<<" has the sybyl type "<< sybyl_types[key]<<endl;
}
}
vector<Atom*> atoms = getAtoms();
vector<Atom*>::iterator it = atoms.begin();
while(it != atoms.end())
{
if((*it)->residue == "HIE" || (*it)->residue == "HID" )
(*it)->residue = "HIS";
if((*it)->residue == "CYX")
(*it)->residue = "CYS";
if ((*it)->name=="O''")
(*it)->name="OXT";
if ((*it)->name=="O'")
(*it)->name="O";
string k = (*it)->residue+"-"+(*it)->name;
(*it)->generic_key = k;
if ((*it)->sybyl_type=="" && (*it)->element != "H")
(*it)->sybyl_type = sybyl_types[k];
//cout<<"KEY:"<<k<<" gives: "<<(*it)->sybyl_type << " in"<< name<<endl;
it++;
}
sybyl_types_assigned=true;
return;
}
void ExtLang::build(const Lang &lang,ulen map_atom_count)
{
original_atom_count=lang.getAtomCount();
// atoms
{
ulen len=LenAdd(lang.getAtomCount(),lang.getRuleCount());
auto atoms=createAtoms(len);
ulen index=0;
for(auto &atom : lang.getAtoms() )
{
atoms->index=index++;
atoms->name=pool.dup(atom.name);
atoms->map_index=atom.map_index;
++atoms;
}
for(auto &rule : lang.getRules() )
{
atoms->index=index++;
atoms->name=pool.cat(StrLen("@",1),rule.ret->name,StrLen("::",2),rule.name);
atoms->map_index=rule.map_index+map_atom_count;
++atoms;
}
}
// synts
{
ulen len=lang.getSyntCount();
auto synts=createSynts(len);
for(auto &synt : lang.getSynts() )
{
synts->index=synt.index;
synts->name=pool.dup(synt.name);
synts->is_lang=synt.is_lang;
synts->map_index=synt.map_index;
synts->rules.len=synt.rules.len;
++synts;
}
}
// rules
{
ulen len=lang.getRuleCount();
auto rules=createRules(len);
auto atoms=getAtoms();
auto synts=getSynts();
ulen delta=original_atom_count;
for(auto &rule : lang.getRules() )
{
rules->index=rule.index;
rules->name=pool.dup(rule.name);
rules->map_index=rule.map_index;
rules->ret=&(synts[rule.ret->index]);
auto args=createElements(*rules,LenAdd(rule.args.len,1));
for(auto element : rule.args )
{
element.apply( [=] (const AtomDesc *atom) { args->ptr=&(atoms[atom->index]); } ,
[=] (const SyntDesc *synt) { args->ptr=&(synts[synt->index]); } );
++args;
}
args->ptr=&(atoms[rule.index+delta]);
++rules;
}
}
// synts.rules
{
auto synts=this->synts;
auto *ptr=rules.ptr;
for(; +synts ;++synts)
{
ulen len=synts->rules.len;
synts->rules.ptr=ptr;
ptr+=len;
}
}
pool.shrink_extra();
}
TopLang::TopLang(const CondLang &clang)
{
Collector<RuleRec> collector;
DynArray<ulen> map(DoRaw(clang.getSyntCount()));
// atoms
{
auto range=clang.getAtoms();
auto atoms=createAtoms(range.len);
for(; +atoms ;++atoms,++range)
{
atoms->index=range->index;
atoms->name=pool.dup(range->name);
atoms->map_index=range->index;
}
}
// synts
{
auto range=clang.getSynts();
ulen len=0;
for(auto &synt : range ) len=LenAdd(len, Max<ulen>(synt.kinds.len,1) );
auto synts=createSynts(len);
ulen index=0;
ulen map_index=0;
for(; +range ;++range,++map_index)
if( +range->kinds )
{
map[map_index]=index;
StrLen name=range->name;
bool is_lang=range->is_lang;
ulen desc_map_index=range->index;
for(auto &kind : range->kinds )
{
synts->rules.len=makeRules(collector,*range,kind.index);
synts->index=index++;
synts->name=pool.cat(name,StrLen(".",1),kind.name);
synts->is_lang=is_lang;
synts->map_index=desc_map_index;
synts->kind_index=kind.index;
++synts;
}
}
else
{
map[map_index]=index;
synts->rules.len=makeRules(collector,*range);
synts->index=index++;
synts->name=pool.dup(range->name);
synts->is_lang=range->is_lang;
synts->map_index=range->index;
++synts;
}
}
// rules
{
auto range=collector.flat();
auto rules=createRules(range.len);
auto atoms=getAtoms();
auto synts=getSynts();
ulen index=0;
for(; +rules ;++rules,++range)
{
rules->index=index++;
rules->name=range->name;
rules->map_index=range->map_index;
auto arange=Range_const(range->args);
auto args=createElements(*rules,arange.len);
for(; +args ;++args,++arange)
{
arange->element.apply( [=] (const CondLangBase::AtomDesc *atom) { args->ptr=&(atoms[atom->index]); } ,
[=,&map] (const CondLangBase::SyntDesc *synt) { args->ptr=&(synts[map[synt->index]+arange->kind_index]); } );
}
}
}
// synt.rules rules.ret
{
auto synts=this->synts;
auto *ptr=rules.ptr;
for(; +synts ;++synts)
{
ulen len=synts->rules.len;
synts->rules.ptr=ptr;
for(auto &rule : Range(ptr,len) ) rule.ret=synts.ptr;
ptr+=len;
}
}
pool.shrink_extra();
}
char isCritical(char f[SIZEX][SIZEY], char x, char y) {
if(getAtoms(f, x, y) == getCapacity(x, y)) {
return 1;
}
return 0;
}
BottomLang::BottomLang(const CondLang &clang)
{
// atoms
{
auto range=clang.getAtoms();
auto atoms=createAtoms(range.len);
for(; +atoms ;++atoms,++range)
{
atoms->index=range->index;
atoms->name=pool.dup(range->name);
}
}
// synts
{
auto range=clang.getSynts();
auto synts=createSynts(range.len);
for(; +synts ;++synts,++range)
{
synts->index=range->index;
synts->name=pool.dup(range->name);
synts->is_lang=range->is_lang;
}
}
// rules
{
auto range=clang.getRules();
auto rules=createRules(range.len);
for(; +rules ;++rules,++range)
{
rules->index=range->index;
rules->name=pool.dup(range->name);
}
}
// synts.rules
{
auto range=clang.getSynts();
auto synts=this->synts;
ulen off=0;
auto rules=getRules();
for(; +synts ;++synts,++range)
{
ulen len=range->rules.len;
synts->rules=rules.part(off,len);
off+=len;
}
}
// rules.ret rules.args
{
auto range=clang.getRules();
auto rules=this->rules;
auto atoms=getAtoms();
auto synts=getSynts();
for(; +rules ;++rules,++range)
{
rules->ret=&(synts[range->ret->index]);
auto arange=range->args;
auto args=createElements(*rules,arange.len);
for(; +args ;++args,++arange)
{
arange->apply( [=] (const CondLangBase::AtomDesc *atom) { args->ptr=&(atoms[atom->index]); } ,
[=] (const CondLangBase::SyntDesc *synt) { args->ptr=&(synts[synt->index]); } );
}
}
}
pool.shrink_extra();
}
