songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

forgot to commit files

This commit is contained in:
Daniel Russel 2009-04-03 19:27:39 +00:00
parent f6ddd6ae06
commit f834735654
10 changed files with 99 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
PDB/src/CGALPDB/Atom.cpp
View File

@ -23,7 +23,7 @@
#include <cstring> #include <cstring>
#include <sstream> #include <sstream>
#include <limits> #include <limits>
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
static double nan__=std::numeric_limits<double>::signaling_NaN(); static double nan__=std::numeric_limits<double>::signaling_NaN();
@ -43,9 +43,9 @@ Atom::Type Atom::string_to_type(const char *cp) {
else { else {
std::ostringstream em; std::ostringstream em;
em << "Couldn't parse atom type of " << cp; em << "Couldn't parse atom type of " << cp;
CGAL_PDB_INTERNAL_NS::error_logger.new_warning(em.str().c_str()); internal::error_logger.new_warning(em.str().c_str());
return INVALID; return INVALID;
} }
} }
CGAL_PDB_END_NAMESPACE }}

37
PDB/src/CGALPDB/Chain.cpp
View File

@ -27,7 +27,7 @@
#include <sstream> #include <sstream>
#include <cstdio> #include <cstdio>
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
//Residue dummy_residue; //Residue dummy_residue;
//Atom dummy_atom; //Atom dummy_atom;
@ -52,11 +52,10 @@ int Chain::write(char chain, int start_index, std::ostream &out) const {
// int anum=1; // int anum=1;
Monomer_key last_resindex; Monomer_key last_resindex;
Monomer::Type last_type= Monomer::INV; Monomer::Type last_type= Monomer::INV;
for (Monomer_const_iterator it = monomers_begin(); it != monomers_end(); ++it) { CGAL_PDB_FOREACH(Monomer_pair r, monomers()) {
const Monomer &res= it->monomer();
//Residue::Label rl = res.label(); //Residue::Label rl = res.label();
//residues_[i]->atoms(); //residues_[i]->atoms();
start_index= res.write(chain, it->key().index(), ' ', start_index, out); start_index= r.monomer().write(chain, r.key().index(), ' ', start_index, out);
/*IR_Map::const_iterator irit= insert_residues_.find(it->key()); /*IR_Map::const_iterator irit= insert_residues_.find(it->key());
if (irit!= insert_residues_.end()) { if (irit!= insert_residues_.end()) {
@ -68,8 +67,8 @@ int Chain::write(char chain, int start_index, std::ostream &out) const {
ir->key().index(), start_index, out); ir->key().index(), start_index, out);
} }
}*/ }*/
last_resindex= it->key(); last_resindex= r.key();
last_type= it->data().type(); last_type= r.data().type();
} }
const char *terformat="TER %5d %3s %c %3d%c"; const char *terformat="TER %5d %3s %c %3d%c";
if (!residues_.empty()) { if (!residues_.empty()) {
@ -89,22 +88,6 @@ std::vector<Monomer::Type> Chain::sequence() const{
return ret; return ret;
} }
unsigned int Chain::number_of_atoms() const {
unsigned int ret=0;
for (Container::const_iterator it= residues_.begin(); it != residues_.end(); ++it){
ret += it->monomer().number_of_atoms();
}
return ret;
}
unsigned int Chain::number_of_bonds() const {
unsigned int ret=0;
for (Container::const_iterator it= residues_.begin(); it != residues_.end(); ++it){
ret += it->monomer().number_of_bonds();
}
return ret;
}
void Chain::swap_with(Chain &o) { void Chain::swap_with(Chain &o) {
std::swap(residues_, o.residues_); std::swap(residues_, o.residues_);
std::swap(header_, o.header_); std::swap(header_, o.header_);
@ -127,19 +110,19 @@ void Chain::set_has_bonds(bool tf) {
} }
} }
Chain::Monomer_iterator Chain::insert_internal(Monomer_key k, const Monomer &m) { Chain::Monomers::iterator Chain::insert_internal(Monomer_key k, const Monomer &m) {
if (residues_.find(k) != residues_.end()){ if (residues_.find(k) != residues_.end()){
std::ostringstream eout; std::ostringstream eout;
eout << "Warning, newly added residue has index "<< k eout << "Warning, newly added residue has index "<< k
<< " which already exists."; << " which already exists.";
CGAL_PDB_INTERNAL_NS::error_logger.new_warning(eout.str().c_str()); internal::error_logger.new_warning(eout.str().c_str());
} }
return residues_.insert(Container::value_type(k,m)); return residues_.insert(Container::value_type(k,m));
} }
bool Chain::has_bonds() const { bool Chain::has_bonds() const {
for (Monomer_const_iterator it= monomers_begin(); for (Monomer_consts::iterator it= monomers().begin(); it != monomers().end();
it != monomers_end(); ++it){ ++it){
if (!it->monomer().has_bonds()) return false; if (!it->monomer().has_bonds()) return false;
} }
return true; return true;
@ -339,4 +322,4 @@ Residue& Chain::residue_containing_atom(Atom::Index atom_index) {
}*/ }*/
CGAL_PDB_END_NAMESPACE }}

4
PDB/src/CGALPDB/Error_logger.cpp
View File

@ -1,7 +1,7 @@
#include <CGAL/PDB/internal/Error_logger.h> #include <CGAL/PDB/internal/Error_logger.h>
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
CGAL_PDB_BEGIN_INTERNAL_NAMESPACE namespace CGAL { namespace PDB { namespace internal {
Error_logger error_logger; Error_logger error_logger;
@ -48,4 +48,4 @@ CGAL_PDB_BEGIN_INTERNAL_NAMESPACE
} }
warnings_.clear(); warnings_.clear();
} }
CGAL_PDB_END_INTERNAL_NAMESPACE }}}

28
PDB/src/CGALPDB/Heterogen.cpp
View File

@ -30,7 +30,7 @@
#include <sstream> #include <sstream>
#include <cstdio> #include <cstdio>
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
void Heterogen::copy_from(const Heterogen &o) { void Heterogen::copy_from(const Heterogen &o) {
@ -40,10 +40,10 @@ void Heterogen::copy_from(const Heterogen &o) {
for (unsigned int i=0; i< o.bonds_.size(); ++i) { for (unsigned int i=0; i< o.bonds_.size(); ++i) {
std::string nma=o.bonds_[i].first.key(); std::string nma=o.bonds_[i].first.key();
std::string nmb=o.bonds_[i].second.key(); std::string nmb=o.bonds_[i].second.key();
Atom_const_iterator ita=find(nma); Atom_consts::iterator ita=find(nma);
Atom_const_iterator itb=find(nmb); Atom_consts::iterator itb=find(nmb);
CGAL_assertion(ita != atoms_end()); CGAL_assertion(ita != atoms().end());
CGAL_assertion(itb != atoms_end()); CGAL_assertion(itb != atoms().end());
// needed due to idiotic C++ syntax // needed due to idiotic C++ syntax
Bond_endpoint bea(ita); Bond_endpoint bea(ita);
Bond_endpoint beb(itb); Bond_endpoint beb(itb);
@ -55,9 +55,9 @@ void Heterogen::copy_from(const Heterogen &o) {
bool Heterogen::connect(Atom::Index a, Atom::Index b) { bool Heterogen::connect(Atom::Index a, Atom::Index b) {
Atom_iterator ita=atoms_end(), itb= atoms_end(); Atoms::iterator ita=atoms().end(), itb= atoms().end();
if (b < a) std::swap(a,b); if (b < a) std::swap(a,b);
for (Atom_iterator it= atoms_begin(); it != atoms_end(); ++it) { for (Atoms::iterator it= atoms().begin(); it != atoms().end(); ++it) {
if (it->atom().index() == a) { if (it->atom().index() == a) {
ita= it; ita= it;
} }
@ -65,8 +65,8 @@ bool Heterogen::connect(Atom::Index a, Atom::Index b) {
itb= it; itb= it;
} }
} }
if (ita == atoms_end()) return false; if (ita == atoms().end()) return false;
if (itb == atoms_end()) return false; if (itb == atoms().end()) return false;
for (unsigned int i=0; i< bonds_.size(); ++i) { for (unsigned int i=0; i< bonds_.size(); ++i) {
if (bonds_[i].first.key() == ita->key() if (bonds_[i].first.key() == ita->key()
&& bonds_[i].second.key() == itb->key()){ && bonds_[i].second.key() == itb->key()){
@ -94,16 +94,16 @@ void Heterogen::dump(std::ostream & /* out */ ) const {
int Heterogen::write(std::string name, int num, int Heterogen::write(std::string name, int num,
int start_index, std::ostream &out) const { int start_index, std::ostream &out) const {
for (Atoms::const_iterator it= atoms_.begin(); it != atoms_.end(); ++it) { CGAL_PDB_FOREACH(const Atom_pair &aa, atoms()) {
Atom_key al= it->key(); Atom_key al= aa.key();
//Point pt= res->cartesian_coords(al); //Point pt= res->cartesian_coords(al);
const Atom &a= it->atom(); const Atom &a= aa.atom();
a.set_index(Atom::Index(start_index)); a.set_index(Atom::Index(start_index));
Point pt = a.point(); Point pt = a.point();
//char chain=' '; //char chain=' ';
//"HETATM%5d %4s %3s %4d %8.3f%8.3f%8.3f%6.2f%6.2f %4s%2s%2s"; //"HETATM%5d %4s %3s %4d %8.3f%8.3f%8.3f%6.2f%6.2f %4s%2s%2s";
out << boost::format(CGAL_PDB_INTERNAL_NS::hetatom_line_oformat_) out << boost::format(internal::hetatom_line_oformat_)
% (start_index++) % al.c_str() % (start_index++) % al.c_str()
% name.c_str() % num % name.c_str() % num
% pt.x() % pt.y() % pt.z() % a.occupancy() % a.temperature_factor() % pt.x() % pt.y() % pt.z() % a.occupancy() % a.temperature_factor()
@ -138,4 +138,4 @@ Heterogen::Heterogen(std::string name): atoms_(20), type_(name){
CGAL_PDB_END_NAMESPACE }}

42
PDB/src/CGALPDB/Model.cpp
View File

@ -29,7 +29,7 @@
using std::sscanf; using std::sscanf;
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
/*static unsigned int getSequenceNumber (const char* line) /*static unsigned int getSequenceNumber (const char* line)
{ {
@ -66,7 +66,7 @@ void Model::process_hetatom(const char *line) {
char element[3]={'\0','\0','\0'}; char element[3]={'\0','\0','\0'};
char charge[3]={'\0','\0','\0'}; char charge[3]={'\0','\0','\0'};
// What field is missing? // What field is missing?
int numscan= sscanf(line, CGAL_PDB_INTERNAL_NS::hetatom_line_iformat_, int numscan= sscanf(line, internal::hetatom_line_iformat_,
//"ATOM %5d%4s%1c%3s%1c%4d%1c%8f%8f%8f%6f%6f%4s%2s%2s", //"ATOM %5d%4s%1c%3s%1c%4d%1c%8f%8f%8f%6f%6f%4s%2s%2s",
&snum, name, &alt, resname, &chain, &resnum, &insertion_residue_code, &snum, name, &alt, resname, &chain, &resnum, &insertion_residue_code,
&x,&y,&z, &occupancy, &tempFactor, segID, element, charge); &x,&y,&z, &occupancy, &tempFactor, segID, element, charge);
@ -101,7 +101,7 @@ void Model::add_hetatom(int numscan, int snum, char name[], char /* alt */,
std::string rname(resname); std::string rname(resname);
Heterogen_key hk(resname, resnum); Heterogen_key hk(resname, resnum);
if (heterogens_[hk].find(name) != heterogens_[hk].atoms_end()) { if (heterogens_[hk].contains(name)) {
CGAL_LOG(Log::LOTS, "Duplicate atom in heterogen " << name << std::endl); CGAL_LOG(Log::LOTS, "Duplicate atom in heterogen " << name << std::endl);
} else { } else {
heterogens_[hk].insert(name, a); heterogens_[hk].insert(name, a);
@ -126,7 +126,7 @@ void Model::process_atom(const char *line) {
char segID[5]={'\0','\0','\0','\0','\0'}; char segID[5]={'\0','\0','\0','\0','\0'};
char element[3]={'\0','\0','\0'}; char element[3]={'\0','\0','\0'};
char charge[3]={'\0','\0','\0'}; char charge[3]={'\0','\0','\0'};
int numscan= sscanf(line, CGAL_PDB_INTERNAL_NS::atom_line_iformat_, int numscan= sscanf(line, internal::atom_line_iformat_,
//"ATOM %5d%4s%1c%3s%1c%4d%1c%8f%8f%8f%6f%6f%4s%2s%2s", //"ATOM %5d%4s%1c%3s%1c%4d%1c%8f%8f%8f%6f%6f%4s%2s%2s",
&snum, name, &alt, resname, &chain, &resnum, &snum, name, &alt, resname, &chain, &resnum,
&insertion_residue_code, &insertion_residue_code,
@ -159,7 +159,7 @@ void Model::process_atom(const char *line) {
if (resnum < 0) { if (resnum < 0) {
std::ostringstream oss; std::ostringstream oss;
oss << "Got negative residue index on line " << line; oss << "Got negative residue index on line " << line;
CGAL_PDB_INTERNAL_NS::error_logger.new_warning(oss.str().c_str()); internal::error_logger.new_warning(oss.str().c_str());
return; return;
} }
@ -185,7 +185,7 @@ void Model::process_atom(const char *line) {
std::string nm(line, 17, 3); std::string nm(line, 17, 3);
Monomer::Type rl= Monomer::type(resname); Monomer::Type rl= Monomer::type(resname);
Monomer m(rl); Monomer m(rl);
Chain::Monomer_iterator mit= curchain.residues_.insert(Chain::Container::value_type(resindex, m)); Chain::Monomers::iterator mit= curchain.residues_.insert(Chain::Container::value_type(resindex, m));
cur_residue= &mit->monomer(); cur_residue= &mit->monomer();
CGAL_assertion(mit->key()== resindex); CGAL_assertion(mit->key()== resindex);
//residues_[resindex]=m; //residues_[resindex]=m;
@ -227,15 +227,10 @@ void Model::process_atom(const char *line) {
<< Monomer::type_string(cur_residue->type()) << Monomer::type_string(cur_residue->type())
<< " got " << Monomer::type_string(Monomer::type(resname)) << " got " << Monomer::type_string(Monomer::type(resname))
<< " on line:\n" << line << std::endl; << " on line:\n" << line << std::endl;
CGAL_PDB_INTERNAL_NS::error_logger.new_fatal_error(oss.str().c_str()); internal::error_logger.new_fatal_error(oss.str().c_str());
} }
//assert(cur_residue->type() == Residue::type(resname)); //assert(cur_residue->type() == Residue::type(resname));
Monomer::Atom_iterator rit= cur_residue->insert(al, a); cur_residue->insert(al, a);
if (rit == cur_residue->atoms_end()) {
std::ostringstream oss;
oss << "Error adding atom to residue " << resindex << std::endl;
CGAL_PDB_INTERNAL_NS::error_logger.new_warning(oss.str().c_str());
}
//residue(resnum-1)->set_coords (al, Point(x,y,z)); //residue(resnum-1)->set_coords (al, Point(x,y,z));
//residue(resnum-1)->set_index(al, snum); //residue(resnum-1)->set_index(al, snum);
@ -249,16 +244,16 @@ void Model::process_atom(const char *line) {
} }
void Model::process_line(const char *line) { void Model::process_line(const char *line) {
CGAL_PDB_INTERNAL_NS::Line_type lt= CGAL_PDB_INTERNAL_NS::line_type(line); internal::Line_type lt= internal::line_type(line);
if (lt== CGAL_PDB_INTERNAL_NS::ATOM) { if (lt== internal::ATOM) {
process_atom(line); process_atom(line);
} else if (lt == CGAL_PDB_INTERNAL_NS::TER) { } else if (lt == internal::TER) {
//CGAL_assertion(!chains_.empty()); //CGAL_assertion(!chains_.empty());
//chains_.back().process_line(line); //chains_.back().process_line(line);
} else if (lt== CGAL_PDB_INTERNAL_NS::HETATM){ } else if (lt== internal::HETATM){
process_hetatom(line); process_hetatom(line);
} else if (lt== CGAL_PDB_INTERNAL_NS::ENDMDL){ } else if (lt== internal::ENDMDL){
} }
} }
@ -267,18 +262,17 @@ void Model::write(int model_index, std::ostream &out) const {
out << boost::format("MODEL %8d ") % model_index << std::endl; out << boost::format("MODEL %8d ") % model_index << std::endl;
int index=1; int index=1;
for (Chain_const_iterator it= chains_.begin(); it != chains_.end(); ++it){ CGAL_PDB_FOREACH(const Chain_pair& c, chains()) {
index= it->chain().write(it->key().index(), index, out); index= c.chain().write(c.key().index(), index, out);
} }
for (unsigned int i=0; i< extra_.size(); ++i){ for (unsigned int i=0; i< extra_.size(); ++i){
out << extra_[i] << std::endl; out << extra_[i] << std::endl;
} }
for (Heterogen_const_iterator it= heterogens_begin(); it != heterogens_end(); CGAL_PDB_FOREACH(const Heterogen_pair& h, heterogens()) {
++it){ index= h.heterogen().write(h.key().name(), h.key().number(),
index= it->heterogen().write(it->key().name(), it->key().number(),
index, out); index, out);
} }
out << "ENDMDL " << std::endl; out << "ENDMDL " << std::endl;
} }
CGAL_PDB_END_NAMESPACE }}

39
PDB/src/CGALPDB/Monomer.cpp
View File

@ -32,7 +32,7 @@
using std::sscanf; using std::sscanf;
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
void Monomer::set_has_bonds(bool tf) { void Monomer::set_has_bonds(bool tf) {
typedef Monomer_data::Possible_bond Possible_bond; typedef Monomer_data::Possible_bond Possible_bond;
@ -42,8 +42,8 @@ void Monomer::set_has_bonds(bool tf) {
} else { } else {
const std::vector<Possible_bond >& bonds= Monomer_data::amino_acid_data_[type()].bonds; const std::vector<Possible_bond >& bonds= Monomer_data::amino_acid_data_[type()].bonds;
for (unsigned int i=0; i< bonds.size(); ++i){ for (unsigned int i=0; i< bonds.size(); ++i){
Atom_const_iterator itf= find(bonds[i].first); Atoms::iterator itf= find(bonds[i].first);
Atom_const_iterator its= find(bonds[i].second); Atoms::iterator its= find(bonds[i].second);
if ( itf != atoms_.end() && its != atoms_.end()){ if ( itf != atoms_.end() && its != atoms_.end()){
bonds_.push_back(Bond(Bond_endpoint(itf), bonds_.push_back(Bond(Bond_endpoint(itf),
Bond_endpoint(its))); Bond_endpoint(its)));
@ -99,29 +99,29 @@ void Monomer::erase_atom(Monomer::Atom_key al) {
Monomer::Atom_iterator Monomer::insert_internal(Atom_key ial, const Atom &a) { Monomer::Atoms::iterator Monomer::insert_internal(Atom_key ial, const Atom &a) {
Monomer::Atom_key al= Monomer_data::fix_atom_label(label_, ial); Monomer::Atom_key al= Monomer_data::fix_atom_label(label_, ial);
if (!can_have_atom(al)){ if (!can_have_atom(al)){
CGAL_PDB_INTERNAL_NS::error_logger.new_warning((std::string("Trying to set invalid atom ") internal::error_logger.new_warning((std::string("Trying to set invalid atom ")
+ atom_key_string(ial) + atom_key_string(ial)
+ " on a residue of type " + " on a residue of type "
+ type_string(label_)).c_str()); + type_string(label_)).c_str());
return atoms_end(); return atoms().end();
} }
if (al == AL_INVALID) { if (al == AL_INVALID) {
return atoms_end(); return atoms().end();
} }
if (atoms_.find(al) != atoms_.end()) { if (atoms_.find(al) != atoms_.end()) {
CGAL_PDB_INTERNAL_NS::error_logger.new_warning((std::string("Duplicate atoms ") internal::error_logger.new_warning((std::string("Duplicate atoms ")
+ atom_key_string(ial) + atom_key_string(ial)
+ " on a residue of type " + " on a residue of type "
+ type_string(label_)).c_str()); + type_string(label_)).c_str());
return atoms_end(); return atoms().end();
} }
//assert(atoms_.find(al)== atoms_.end()); //assert(atoms_.find(al)== atoms_.end());
//bonds_.clear(); //bonds_.clear();
Atom_iterator ret= atoms_.insert(Atoms::value_type(al,a)); Atoms::iterator ret= atoms_.insert(Atoms::value_type(al,a));
// This is a bit evil, I haven't figured out a better way though. // This is a bit evil, I haven't figured out a better way though.
ret->atom().set_type(element(al)); ret->atom().set_type(element(al));
if (has_bonds()){ if (has_bonds()){
@ -150,7 +150,7 @@ void Monomer::dump(std::ostream &out) const {
for (unsigned int i=0; i< valid_atoms.size(); ++i){ for (unsigned int i=0; i< valid_atoms.size(); ++i){
Monomer::Atom_key al= valid_atoms[i]; Monomer::Atom_key al= valid_atoms[i];
out << Monomer::atom_key_string(al); //Monomer::write_atom_label(al, out); out << Monomer::atom_key_string(al); //Monomer::write_atom_label(al, out);
if (find(al) != atoms_end()){ if (contains(al)){
out << " (" << find(al)->atom().point().x() << ", " out << " (" << find(al)->atom().point().x() << ", "
<< find(al)->atom().point().y() << ", " << find(al)->atom().point().y() << ", "
<< find(al)->atom().point().z() << ") " << std::endl; << find(al)->atom().point().z() << ") " << std::endl;
@ -163,15 +163,14 @@ void Monomer::dump(std::ostream &out) const {
int Monomer::write(char chain, int monomer_index, int Monomer::write(char chain, int monomer_index,
char insertion_residue_code, int start_index, std::ostream &out) const { char insertion_residue_code, int start_index, std::ostream &out) const {
CGAL_PDB_FOREACH(const Atom_pair &aa, atoms()) {
for (Atoms::const_iterator it= atoms_.begin(); it != atoms_.end(); ++it) { Atom_key al= aa.key();
Atom_key al= it->key();
//Point pt= res->cartesian_coords(al); //Point pt= res->cartesian_coords(al);
const Atom &a= it->atom(); const Atom &a= aa.atom();
Point pt = a.point(); Point pt = a.point();
char alt=' '; char alt=' ';
//char chain=' '; //char chain=' ';
out << boost::format(CGAL_PDB_INTERNAL_NS::atom_line_oformat_) out << boost::format(internal::atom_line_oformat_)
% (start_index++) % Monomer::atom_key_string(al).c_str() % alt % (start_index++) % Monomer::atom_key_string(al).c_str() % alt
% Monomer::type_string(type()).c_str() % chain % monomer_index % insertion_residue_code % Monomer::type_string(type()).c_str() % chain % monomer_index % insertion_residue_code
% pt.x() % pt.y() % pt.z() % a.occupancy() % a.temperature_factor() % a.segment_id().c_str() % pt.x() % pt.y() % pt.z() % a.occupancy() % a.temperature_factor() % a.segment_id().c_str()
@ -231,7 +230,7 @@ Monomer::Atom_key Monomer::atom_key(const char *nm) {
return Monomer_data::clean_atom_name_data_[i].l; return Monomer_data::clean_atom_name_data_[i].l;
} }
} }
CGAL_PDB_INTERNAL_NS::error_logger.new_warning(std::string(s + " is not a known atom type.").c_str());; internal::error_logger.new_warning(std::string(s + " is not a known atom type.").c_str());;
return Monomer::AL_OTHER; return Monomer::AL_OTHER;
} }
@ -246,7 +245,7 @@ Atom::Type Monomer::element(Atom_key al){
return Monomer_data::atom_name_data_[i].t; return Monomer_data::atom_name_data_[i].t;
} }
} }
CGAL_PDB_INTERNAL_NS::error_logger.new_internal_error("Unknown element label "); internal::error_logger.new_internal_error("Unknown element label ");
return Atom::INVALID; return Atom::INVALID;
} }
@ -264,7 +263,7 @@ std::string Monomer::atom_key_string(Atom_key al) {
std::ostringstream oss; std::ostringstream oss;
oss << "Unknown atom label: " << al << " returning UNKN"; oss << "Unknown atom label: " << al << " returning UNKN";
CGAL_PDB_INTERNAL_NS::error_logger.new_warning(oss.str().c_str()); internal::error_logger.new_warning(oss.str().c_str());
return "UNKN"; return "UNKN";
} }
@ -354,4 +353,4 @@ std::string Monomer::type_string(Monomer::Type rl){
} }
} }
CGAL_PDB_END_NAMESPACE }}

4
PDB/src/CGALPDB/Monomer_data.cpp
View File

@ -22,7 +22,7 @@
#include <CGAL/PDB/internal/Monomer_data.h> #include <CGAL/PDB/internal/Monomer_data.h>
#include <cassert> #include <cassert>
#include <cstdio> #include <cstdio>
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
namespace Monomer_data { namespace Monomer_data {
bool amino_acid_initialized_=false; bool amino_acid_initialized_=false;
@ -890,4 +890,4 @@ namespace Monomer_data {
} }
CGAL_PDB_END_NAMESPACE }}

56
PDB/src/CGALPDB/PDB.cpp
View File

@ -25,7 +25,7 @@
#include <cctype> #include <cctype>
#include <cstdio> #include <cstdio>
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
PDB::PDB(std::istream &in, bool print_errors) { PDB::PDB(std::istream &in, bool print_errors) {
load(in, print_errors); load(in, print_errors);
@ -36,7 +36,7 @@ PDB::~PDB(){}
void PDB::load(std::istream &in, bool print_errors){ void PDB::load(std::istream &in, bool print_errors){
char line[600]; char line[600];
CGAL_PDB_INTERNAL_NS::error_logger.set_is_output(print_errors); internal::error_logger.set_is_output(print_errors);
std::map<char, std::string> names; std::map<char, std::string> names;
std::string last_name; std::string last_name;
Model_key cur_model(1); Model_key cur_model(1);
@ -44,10 +44,10 @@ void PDB::load(std::istream &in, bool print_errors){
char dummy_char; char dummy_char;
while (in.getline (line, 600)) { while (in.getline (line, 600)) {
CGAL_PDB_INTERNAL_NS::Line_type lt= CGAL_PDB_INTERNAL_NS::line_type(line); internal::Line_type lt= internal::line_type(line);
if (lt== CGAL_PDB_INTERNAL_NS::HEADER) { if (lt== internal::HEADER) {
header_.push_back(std::string(line)); header_.push_back(std::string(line));
} if (lt == CGAL_PDB_INTERNAL_NS::CONECT) { } if (lt == internal::CONECT) {
// do something // do something
std::istringstream iss(line+6); std::istringstream iss(line+6);
int base; int base;
@ -66,7 +66,7 @@ void PDB::load(std::istream &in, bool print_errors){
connections_.push_back(std::make_pair(base, o)); connections_.push_back(std::make_pair(base, o));
} }
} while (true); } while (true);
} else if (lt == CGAL_PDB_INTERNAL_NS::COMPND) { } else if (lt == internal::COMPND) {
header_.push_back(std::string(line)); header_.push_back(std::string(line));
int ti; int ti;
char dummychain; char dummychain;
@ -103,47 +103,47 @@ void PDB::load(std::istream &in, bool print_errors){
} }
last_name= std::string(line+offset); last_name= std::string(line+offset);
} }
} else if (lt== CGAL_PDB_INTERNAL_NS::DBREF){ } else if (lt== internal::DBREF){
header_.push_back(std::string(line)); header_.push_back(std::string(line));
} else if (lt== CGAL_PDB_INTERNAL_NS::SEQRES){ } else if (lt== internal::SEQRES){
header_.push_back(std::string(line)); header_.push_back(std::string(line));
} else if (lt== CGAL_PDB_INTERNAL_NS::MODEL) { } else if (lt== internal::MODEL) {
int mnum=0; int mnum=0;
char buf[81]; char buf[81];
std::sscanf(line, "%s %d", buf, &mnum); std::sscanf(line, "%s %d", buf, &mnum);
//new_model(Model_key(mnum), Model()); //new_model(Model_key(mnum), Model());
cur_model= Model_key(mnum); cur_model= Model_key(mnum);
done_with_model=false; done_with_model=false;
} else if ( lt== CGAL_PDB_INTERNAL_NS::HETATM } else if ( lt== internal::HETATM
|| lt== CGAL_PDB_INTERNAL_NS::ATOM ) { || lt== internal::ATOM ) {
if (done_with_model) { if (done_with_model) {
// charlie carter hack // charlie carter hack
cur_model= Model_key(cur_model.index()+1); cur_model= Model_key(cur_model.index()+1);
done_with_model=false; done_with_model=false;
} }
models_[cur_model].process_line(line); models_[cur_model].process_line(line);
} else if (lt== CGAL_PDB_INTERNAL_NS::TER){ } else if (lt== internal::TER){
models_[cur_model].process_line(line); models_[cur_model].process_line(line);
} else if (lt== CGAL_PDB_INTERNAL_NS::ENDMDL){ } else if (lt== internal::ENDMDL){
done_with_model=true; done_with_model=true;
models_[cur_model].process_line(line); models_[cur_model].process_line(line);
} else if (lt== CGAL_PDB_INTERNAL_NS::MASTER){ } else if (lt== internal::MASTER){
} else if (lt == CGAL_PDB_INTERNAL_NS::END){ } else if (lt == internal::END){
} }
} }
for (Model_iterator it= models_begin(); it != models_end(); ++it){ CGAL_PDB_FOREACH(Model_pair &m, models()) {
for (Model::Chain_iterator cit = it->model().chains_begin(); cit != it->model().chains_end(); ++cit){ CGAL_PDB_FOREACH(Model::Chain_pair &c, m.model().chains()) {
cit->chain().set_has_bonds(true); c.chain().set_has_bonds(true);
if (names.find(cit->key().index()) != names.end()) { if (names.find(c.key().index()) != names.end()) {
cit->chain().set_name(names[cit->key().index()]); c.chain().set_name(names[c.key().index()]);
} }
} }
} }
build_heterogens(); build_heterogens();
CGAL_PDB_INTERNAL_NS::error_logger.dump(); internal::error_logger.dump();
} }
@ -160,12 +160,10 @@ void PDB::build_heterogens() {
for (unsigned int i=0; i< connections_.size(); ++i) { for (unsigned int i=0; i< connections_.size(); ++i) {
int a= connections_[i].first; int a= connections_[i].first;
int b= connections_[i].second; int b= connections_[i].second;
for (Model_iterator it= models_begin(); it != models_end(); ++it) { CGAL_PDB_FOREACH(Model_pair &m, models()) {
bool found=false; bool found=false;
for (Model::Heterogen_iterator hit CGAL_PDB_FOREACH(Model::Heterogen_pair &h, m.model().heterogens()) {
= it->model().heterogens_begin(); if (h.heterogen().connect(Atom::Index(a), Atom::Index(b))) {
hit != it->model().heterogens_end(); ++hit) {
if (hit->heterogen().connect(Atom::Index(a), Atom::Index(b))) {
found=true; found=true;
break; break;
} }
@ -183,8 +181,8 @@ std::ostream& PDB::write(std::ostream &out) const {
for (unsigned int i=0; i< header_.size(); ++i){ for (unsigned int i=0; i< header_.size(); ++i){
out << header_[i] << std::endl; out << header_[i] << std::endl;
} }
for (Model_const_iterator it = models_begin(); it != models_end(); ++it){ CGAL_PDB_FOREACH(const Model_pair &m, models()) {
it->model().write(it->key().index(), out); m.model().write(m.key().index(), out);
} }
out << "END \n"; out << "END \n";
return out; return out;
@ -198,4 +196,4 @@ PDB::Model_key PDB::push_back(const Model &m) {
return k; return k;
} }
CGAL_PDB_END_NAMESPACE }}

4
PDB/src/CGALPDB/Quaternion.cpp
View File

@ -1,6 +1,6 @@
#include <CGAL/PDB/Quaternion.h> #include <CGAL/PDB/Quaternion.h>
#include <CGAL/PDB/Transform.h> #include <CGAL/PDB/Transform.h>
CGAL_PDB_BEGIN_NAMESPACE namespace CGAL { namespace PDB {
/*Quaternion::Quaternion(const double m[3][3]){ /*Quaternion::Quaternion(const double m[3][3]){
@ -105,4 +105,4 @@ Transform Quaternion::transform(Vector translation) const {
return ret; return ret;
} }
CGAL_PDB_END_NAMESPACE }}

4
PDB/src/CGALPDB/pdb_utils.cpp
View File

@ -24,7 +24,7 @@ MA 02110-1301, USA. */
#include <iostream> #include <iostream>
#include <set> #include <set>
#include <CGAL/PDB/internal/Error_logger.h> #include <CGAL/PDB/internal/Error_logger.h>
CGAL_PDB_BEGIN_INTERNAL_NAMESPACE namespace CGAL { namespace PDB { namespace internal {
//ATOM 812 OG ASER 106 -.072 22.447 10.384 .50 11.73 1ECD 918 //ATOM 812 OG ASER 106 -.072 22.447 10.384 .50 11.73 1ECD 918
//ATOM 60 O SER L 9 -26.231 10.210 -4.537 1.00 26.25 7FAB 160 //ATOM 60 O SER L 9 -26.231 10.210 -4.537 1.00 26.25 7FAB 160
@ -68,4 +68,4 @@ CGAL_PDB_BEGIN_INTERNAL_NAMESPACE
return OTHER; return OTHER;
} }
} }
CGAL_PDB_END_INTERNAL_NAMESPACE }}}