Skip to content
Snippets Groups Projects
Commit cc7da76f authored by Studer Gabriel's avatar Studer Gabriel
Browse files

mmcif writing: improve automated detection of _entity.type/_entity_poly.type 

Changes in chem_class.hh are a temporary solution for optimization oddities.
constexpr enforces evaluation at compile time. The observed problem were odd linking
problems (undefined reference) to things like ost::mol::ChemClass::XYZ.
parent 9110f77a
Branches
Tags
No related merge requests found
Hide whitespace changes
Inline Side-by-side
modules/io/src/mol/mmcif_writer.cc
+ 214
− 223
View file @ cc7da76f
...@@ -70,11 +70,158 @@ namespace { ...@@ -70,11 +70,158 @@ namespace {
std::vector<int> indices; std::vector<int> indices;
}; };
String GuessEntityPolyType(const ost::mol::ResidueHandleList& res_list) {
// guesses _entity_poly.type based on residue chem classes
// allowed values according to mmcif_pdbx_v50.dic:
// - cyclic-pseudo-peptide
// - other
// - peptide nucleic acid
// - polydeoxyribonucleotide
// - polydeoxyribonucleotide/polyribonucleotide hybrid
// - polypeptide(D)
// - polypeptide(L)
// - polyribonucleotide
// this function won't identify cyclic-pseudo-peptides
std::set<char> chem_classes;
for(auto res: res_list) {
chem_classes.insert(res.GetChemClass());
}
// check for polypeptide(L)
if(chem_classes.size() == 1 &&
chem_classes.find(ost::mol::ChemClass::L_PEPTIDE_LINKING) != chem_classes.end()) {
return "polypeptide(L)";
}
if(chem_classes.size() == 2 &&
chem_classes.find(ost::mol::ChemClass::L_PEPTIDE_LINKING) != chem_classes.end() &&
chem_classes.find(ost::mol::ChemClass::PEPTIDE_LINKING) != chem_classes.end()) {
return "polypeptide(L)";
}
// check for polypeptide(D)
if(chem_classes.size() == 1 &&
chem_classes.find(ost::mol::ChemClass::D_PEPTIDE_LINKING) != chem_classes.end()) {
return "polypeptide(D)";
}
if(chem_classes.size() == 2 &&
chem_classes.find(ost::mol::ChemClass::D_PEPTIDE_LINKING) != chem_classes.end() &&
chem_classes.find(ost::mol::ChemClass::PEPTIDE_LINKING) != chem_classes.end()) {
return "polypeptide(D)";
}
// check for polydeoxyribonucleotide
if(chem_classes.size() == 1 &&
chem_classes.find(ost::mol::ChemClass::DNA_LINKING) != chem_classes.end()) {
return "polydeoxyribonucleotide";
}
// check for polyribonucleotide
if(chem_classes.size() == 1 &&
chem_classes.find(ost::mol::ChemClass::RNA_LINKING) != chem_classes.end()) {
return "polyribonucleotide";
}
// check for polydeoxyribonucleotide/polyribonucleotide hybrid
if(chem_classes.size() == 2 &&
chem_classes.find(ost::mol::ChemClass::RNA_LINKING) != chem_classes.end() &&
chem_classes.find(ost::mol::ChemClass::DNA_LINKING) != chem_classes.end()) {
return "polydeoxyribonucleotide/polyribonucleotide hybrid";
}
// check for peptide nucleic acid
bool peptide_linking = chem_classes.find(ost::mol::ChemClass::L_PEPTIDE_LINKING) != chem_classes.end() ||
chem_classes.find(ost::mol::ChemClass::D_PEPTIDE_LINKING) != chem_classes.end() ||
chem_classes.find(ost::mol::ChemClass::PEPTIDE_LINKING) != chem_classes.end();
bool nucleotide_linking = chem_classes.find(ost::mol::ChemClass::DNA_LINKING) != chem_classes.end() ||
chem_classes.find(ost::mol::ChemClass::RNA_LINKING) != chem_classes.end();
std::set<char> pepnuc_set;
pepnuc_set.insert(ost::mol::ChemClass::L_PEPTIDE_LINKING);
pepnuc_set.insert(ost::mol::ChemClass::D_PEPTIDE_LINKING);
pepnuc_set.insert(ost::mol::ChemClass::PEPTIDE_LINKING);
pepnuc_set.insert(ost::mol::ChemClass::DNA_LINKING);
pepnuc_set.insert(ost::mol::ChemClass::RNA_LINKING);
pepnuc_set.insert(chem_classes.begin(), chem_classes.end());
if(peptide_linking && nucleotide_linking && pepnuc_set.size() == 5) {
return "peptide nucleic acid";
}
return "other";
}
String GuessEntityType(const ost::mol::ResidueHandleList& res_list) {
// guesses _entity.type based on residue chem classes
// allowed values according to mmcif_pdbx_v50.dic:
// - branched
// - macrolide
// - non-polymer
// - polymer
// - water
// this function won't identify macrolid
std::set<char> chem_classes;
for(auto res: res_list) {
chem_classes.insert(res.GetChemClass());
}
// check for water
if(chem_classes.size() == 1 &&
chem_classes.find(ost::mol::ChemClass::WATER) != chem_classes.end()) {
return "water";
}
// check for non-polymer
if(res_list.size() == 1) {
return "non-polymer";
}
// check for branched
std::set<char> sweet_set;
sweet_set.insert(ost::mol::ChemClass::L_SACCHARIDE);
sweet_set.insert(ost::mol::ChemClass::D_SACCHARIDE);
sweet_set.insert(ost::mol::ChemClass::SACCHARIDE);
// if the union of chem_classes and sweet_set has 3 elements, chem_classes
// only has sugars.
sweet_set.insert(chem_classes.begin(), chem_classes.end());
if(sweet_set.size() == 3) {
return "branched";
}
// DISCUSS THIS OVER A BEER...
// when arriving here, we excluded the possibility of branched and single
// residue chains.
// BUT: entities must have at least 3 residues to be considered polymers
// for now, we just set entities with 2 residues as non-polymer
if(res_list.size() == 2) {
return "non-polymer";
}
// If res_list represents a valid mmcif chain, chem_classes should only
// contain peptide- and nucleotide linking items
for(auto it: chem_classes) {
ost::mol::ChemClass chem_class(it);
if(!(chem_class.IsPeptideLinking() || chem_class.IsNucleotideLinking())) {
throw ost::io::IOException("Could not guess entity type");
}
}
return "polymer";
}
// internal object with all info to fill chem_comp_ category // internal object with all info to fill chem_comp_ category
struct CompInfo { struct CompInfo {
String type; String type;
}; };
inline String chem_class_to_chem_comp_type(char chem_class) { inline String chem_class_to_chem_comp_type(char chem_class) {
String type = ""; String type = "";
switch(chem_class) { switch(chem_class) {
...@@ -132,44 +279,6 @@ namespace { ...@@ -132,44 +279,6 @@ namespace {
return type; return type;
} }
inline String chem_class_to_entity_poly_type(char chem_class) {
String type = "";
switch(chem_class) {
case 'P': {
type = "polypeptide(L)";
break;
}
case 'D': {
type = "polypeptide(D)";
break;
}
case 'L': {
type = "polypeptide(L)";
break;
}
case 'R': {
type = "polyribonucleotide";
break;
}
case 'S': {
type = "polydeoxyribonucleotide";
break;
}
case 'X': {
type = "polysaccharide(L)";
break;
}
case 'Y': {
type = "polysaccharide(D)";
break;
}
default: {
type = "other";
}
}
return type;
}
inline String mon_id_to_olc(char chem_class, inline String mon_id_to_olc(char chem_class,
const String& mon_id) { const String& mon_id) {
...@@ -291,9 +400,7 @@ namespace { ...@@ -291,9 +400,7 @@ namespace {
return "Y"; return "Y";
} }
if(mon_id == "TPO") { if(mon_id == "TPO") {
return "(PTO)"; // This is stupid - PTO would be Pseudotropine in return "(TPO)";
// the chem comp dictionary. But hey, thats what the
// mmcif reference demands...
} }
break; break;
} }
...@@ -304,7 +411,6 @@ namespace { ...@@ -304,7 +411,6 @@ namespace {
break; break;
} }
} }
return "(UNK)";
} else if(ost::mol::ChemClass(chem_class).IsNucleotideLinking()) { } else if(ost::mol::ChemClass(chem_class).IsNucleotideLinking()) {
switch(mon_id[0]) { switch(mon_id[0]) {
case 'A': { case 'A': {
...@@ -353,15 +459,11 @@ namespace { ...@@ -353,15 +459,11 @@ namespace {
break; break;
} }
} }
return "N";
} else { } else {
throw ost::io::IOException("Can only get OLCs for peptides/nucleotides"); throw ost::io::IOException("Can only get OLCs for peptides/nucleotides");
} }
return "(" + mon_id + ")";
} }
void Setup_chem_comp_(const ost::mol::ResidueHandleList& res_list, void Setup_chem_comp_(const ost::mol::ResidueHandleList& res_list,
...@@ -386,129 +488,74 @@ namespace { ...@@ -386,129 +488,74 @@ namespace {
// internal object with all info to fill entity_, struct_asym_, // internal object with all info to fill entity_, struct_asym_,
// entity_poly_seq_ categories // entity_poly_seq_ categories
struct EntityInfo { struct EntityInfo {
char chem_class; // all residues of this entity have this ChemClass String type; // relevant for _entity
String poly_type; // relevant for _entity_poly String poly_type; // relevant for _entity_poly
std::vector<String> asym_ids; // relevant for _struct_asym.id std::vector<String> asym_ids; // relevant for _struct_asym.id
std::vector<String> mon_ids; // relevant for _entity_poly_seq.mon_id std::vector<String> mon_ids; // relevant for _entity_poly_seq.mon_id
bool is_poly; // in principle mon_ids.size() > 1 bool is_poly; // in principle type == "polymer"
String seq; // _entity_poly.pdbx_seq_one_letter_code String seq; // _entity_poly.pdbx_seq_one_letter_code
String seq_can; // _entity_poly.pdbx_seq_one_letter_code_can String seq_can; // _entity_poly.pdbx_seq_one_letter_code_can
}; };
int Setup_entity_(const String& asym_chain_name, int Setup_entity_(const String& asym_chain_name,
char chem_class,
const ost::mol::ResidueHandleList& res_list, const ost::mol::ResidueHandleList& res_list,
std::vector<EntityInfo>& entity_infos) { std::vector<EntityInfo>& entity_infos) {
String type = GuessEntityType(res_list);
// deal with water String poly_type = "";
if(chem_class == ost::mol::ChemClass::WATER) { bool is_poly = type == "polymer";
for(size_t i = 0; i < entity_infos.size(); ++i) { if(is_poly) {
if(entity_infos[i].chem_class == ost::mol::ChemClass::WATER) { poly_type = GuessEntityPolyType(res_list);
entity_infos[i].asym_ids.push_back(asym_chain_name);
return i;
}
}
int entity_idx = entity_infos.size();
entity_infos.push_back(EntityInfo());
entity_infos.back().chem_class = ost::mol::ChemClass::WATER;
entity_infos.back().asym_ids.push_back(asym_chain_name);
entity_infos.back().mon_ids.push_back("HOH");
entity_infos.back().poly_type = "";
entity_infos.back().is_poly = false;
return entity_idx;
} }
// deal with NON_POLYMER
if(chem_class == ost::mol::ChemClass::NON_POLYMER) {
for(size_t i = 0; i < entity_infos.size(); ++i) {
if(entity_infos[i].chem_class == ost::mol::ChemClass::NON_POLYMER &&
res_list[0].GetName() == entity_infos[i].mon_ids[0]) {
entity_infos[i].asym_ids.push_back(asym_chain_name);
return i;
}
}
int entity_idx = entity_infos.size();
entity_infos.push_back(EntityInfo());
entity_infos.back().chem_class = ost::mol::ChemClass::NON_POLYMER;
entity_infos.back().asym_ids.push_back(asym_chain_name);
entity_infos.back().mon_ids.push_back(res_list[0].GetName());
entity_infos.back().poly_type = "";
entity_infos.back().is_poly = false;
return entity_idx;
}
// deal with UNKNOWN
if(chem_class == ost::mol::ChemClass::UNKNOWN) {
for(size_t i = 0; i < entity_infos.size(); ++i) {
if(entity_infos[i].chem_class == ost::mol::ChemClass::UNKNOWN &&
res_list[0].GetName() == entity_infos[i].mon_ids[0]) {
entity_infos[i].asym_ids.push_back(asym_chain_name);
return i;
}
}
int entity_idx = entity_infos.size();
entity_infos.push_back(EntityInfo());
entity_infos.back().chem_class = ost::mol::ChemClass::UNKNOWN;
entity_infos.back().asym_ids.push_back(asym_chain_name);
entity_infos.back().mon_ids.push_back(res_list[0].GetName());
entity_infos.back().poly_type = "";
entity_infos.back().is_poly = false;
return entity_idx;
}
// with the current code, the following chem classes are considered
// polymers: PEPTIDE_LINKING, D_PEPTIDE_LINKING, L_PEPTIDE_LINKING
// RNA_LINKING, DNA_LINKING, L_SACCHARIDE, D_SACCHARIDE, SACCHARIDE
// They're also considered polymers even if only one residue is there
// Needs checking...
std::vector<String> mon_ids; std::vector<String> mon_ids;
for(auto res : res_list) { if(type == "water") {
mon_ids.push_back(res.GetName()); mon_ids.push_back("HOH");
} else {
for(auto res : res_list) {
mon_ids.push_back(res.GetName());
}
} }
// check whether we already have that entity // check if entity is already there
// right now we're just looking for exact matches in chem_class and
// mon_ids (i.e. sequence).
int entity_idx = -1;
for(size_t i = 0; i < entity_infos.size(); ++i) { for(size_t i = 0; i < entity_infos.size(); ++i) {
if(entity_infos[i].chem_class == chem_class && if(entity_infos[i].type == type &&
entity_infos[i].mon_ids == mon_ids) { entity_infos[i].poly_type == poly_type &&
entity_idx = i; entity_infos[i].mon_ids == mon_ids) {
break; entity_infos[i].asym_ids.push_back(asym_chain_name);
return i;
} }
} }
if(entity_idx != -1) { // need to create new entity
entity_infos[entity_idx].asym_ids.push_back(asym_chain_name); int entity_idx = entity_infos.size();
} else { entity_infos.push_back(EntityInfo());
entity_idx = entity_infos.size(); entity_infos.back().type = type;
entity_infos.push_back(EntityInfo()); entity_infos.back().poly_type = poly_type;
entity_infos.back().chem_class = chem_class; entity_infos.back().asym_ids.push_back(asym_chain_name);
entity_infos.back().asym_ids.push_back(asym_chain_name); entity_infos.back().mon_ids = mon_ids;
entity_infos.back().mon_ids = mon_ids; entity_infos.back().is_poly = is_poly;
entity_infos.back().poly_type = chem_class_to_entity_poly_type(chem_class); if(is_poly) {
entity_infos.back().is_poly = entity_infos.back().mon_ids.size() > 1; std::stringstream seq;
std::stringstream seq_can;
// seqres basically follows a hardcoded table from the mmcif reference
std::stringstream ss;
for(auto mon_id: mon_ids) {
ss << mon_id_to_olc(chem_class, mon_id);
}
entity_infos.back().seq = ss.str();
ss.clear();
// canonical seqres maps one letter codes of parent residues
// OpenStructure does the same when setting up the entity in
// the processor. There still might be '?' or similar which
// should be treated separately... but hey, I'm in a rush for
// now
for(auto res: res_list) { for(auto res: res_list) {
ss << res.GetOneLetterCode(); // seqres basically follows a hardcoded table from the mmcif reference
seq << mon_id_to_olc(res.GetChemClass(), res.GetName());
// canonical seqres maps one letter codes of parent residues
// OpenStructure does the same when setting up the entity in the
// processor. We just trust OpenStructure to do the right thing but set
// olc to 'X' in case of invalid olc outside [A-Z] (example is '?')
char olc = res.GetOneLetterCode();
if(olc < 'A' || olc > 'Z') {
seq_can << 'X';
} else {
seq_can << res.GetOneLetterCode();
}
} }
entity_infos.back().seq_can = ss.str(); entity_infos.back().seq = seq.str();
entity_infos.back().seq_can = seq_can.str();
} }
return entity_idx; return entity_idx;
} }
...@@ -723,25 +770,8 @@ namespace { ...@@ -723,25 +770,8 @@ namespace {
const std::vector<EntityInfo>& entity_info) { const std::vector<EntityInfo>& entity_info) {
for(size_t entity_idx = 0; entity_idx < entity_info.size(); ++entity_idx) { for(size_t entity_idx = 0; entity_idx < entity_info.size(); ++entity_idx) {
std::vector<ost::io::StarLoopDataItemDO> ent_data; std::vector<ost::io::StarLoopDataItemDO> ent_data;
// id
ent_data.push_back(ost::io::StarLoopDataItemDO(entity_idx)); ent_data.push_back(ost::io::StarLoopDataItemDO(entity_idx));
// type ent_data.push_back(ost::io::StarLoopDataItemDO(entity_info[entity_idx].type));
ost::mol::ChemClass chem_class(entity_info[entity_idx].chem_class);
if(chem_class.IsPeptideLinking() || chem_class.IsNucleotideLinking()) {
ent_data.push_back(ost::io::StarLoopDataItemDO("polymer"));
} else if(chem_class.IsWater()) {
ent_data.push_back(ost::io::StarLoopDataItemDO("water"));
} else if(chem_class == ost::mol::ChemClass::NON_POLYMER) {
ent_data.push_back(ost::io::StarLoopDataItemDO("non-polymer"));
} else if(chem_class.IsSaccharide()) {
// NOT SURE WHETHER THIS MAKES ANY SENSE!
ent_data.push_back(ost::io::StarLoopDataItemDO("branched"));
} else if(chem_class == ost::mol::ChemClass::UNKNOWN) {
// NOT SURE WHETHER THIS MAKES ANY SENSE!
ent_data.push_back(ost::io::StarLoopDataItemDO("non-polymer"));
} else {
throw ost::io::IOException("Entity type issue");
}
entity_ptr->AddData(ent_data); entity_ptr->AddData(ent_data);
} }
} }
...@@ -894,11 +924,10 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -894,11 +924,10 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
std::vector<std::vector<ost::mol::ResidueHandle> > P_chains; // PEPTIDE_LINKING std::vector<std::vector<ost::mol::ResidueHandle> > P_chains; // PEPTIDE_LINKING
std::vector<std::vector<ost::mol::ResidueHandle> > R_chains; // RNA_LINKING std::vector<std::vector<ost::mol::ResidueHandle> > R_chains; // RNA_LINKING
std::vector<std::vector<ost::mol::ResidueHandle> > S_chains; // DNA_LINKING std::vector<std::vector<ost::mol::ResidueHandle> > S_chains; // DNA_LINKING
std::vector<std::vector<ost::mol::ResidueHandle> > X_chains; // L_SACCHARIDE // all Saccharides go into the same chain
std::vector<std::vector<ost::mol::ResidueHandle> > Y_chains; // D_SACCHARIDE std::vector<std::vector<ost::mol::ResidueHandle> > Z_chains; // SACCHARIDE
std::vector<std::vector<ost::mol::ResidueHandle> > W_chains; // WATER std::vector<std::vector<ost::mol::ResidueHandle> > W_chains; // WATER
std::vector<ost::mol::ResidueHandle> N_chains; // NON_POLYMER (1 res per chain) std::vector<ost::mol::ResidueHandle> N_chains; // NON_POLYMER (1 res per chain)
std::vector<ost::mol::ResidueHandle> U_chains; // UNKNOWN (1 res per chain)
std::map<String, CompInfo> comp_infos; std::map<String, CompInfo> comp_infos;
ost::mol::ChainHandleList chain_list = ent.GetChainList(); ost::mol::ChainHandleList chain_list = ent.GetChainList();
...@@ -916,8 +945,7 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -916,8 +945,7 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
bool has_peptide_linking = false; bool has_peptide_linking = false;
bool has_rna_linking = false; bool has_rna_linking = false;
bool has_dna_linking = false; bool has_dna_linking = false;
bool has_l_saccharide = false; bool has_saccharide = false;
bool has_d_saccharide = false;
bool has_water = false; bool has_water = false;
for(auto res: res_list) { for(auto res: res_list) {
...@@ -950,11 +978,15 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -950,11 +978,15 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
} }
if(res.GetChemClass() == ost::mol::ChemClass::L_SACCHARIDE) { if(res.GetChemClass() == ost::mol::ChemClass::L_SACCHARIDE) {
has_l_saccharide = true; has_saccharide = true;
} }
if(res.GetChemClass() == ost::mol::ChemClass::D_SACCHARIDE) { if(res.GetChemClass() == ost::mol::ChemClass::D_SACCHARIDE) {
has_d_saccharide = true; has_saccharide = true;
}
if(res.GetChemClass() == ost::mol::ChemClass::SACCHARIDE) {
has_saccharide = true;
} }
if(res.GetChemClass() == ost::mol::ChemClass::WATER) { if(res.GetChemClass() == ost::mol::ChemClass::WATER) {
...@@ -988,12 +1020,8 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -988,12 +1020,8 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
S_chains.push_back(ost::mol::ResidueHandleList()); S_chains.push_back(ost::mol::ResidueHandleList());
} }
if(has_l_saccharide) { if(has_saccharide) {
X_chains.push_back(ost::mol::ResidueHandleList()); Z_chains.push_back(ost::mol::ResidueHandleList());
}
if(has_d_saccharide) {
Y_chains.push_back(ost::mol::ResidueHandleList());
} }
if(has_water) { if(has_water) {
...@@ -1014,15 +1042,18 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1014,15 +1042,18 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
} else if(res.GetChemClass() == ost::mol::ChemClass::DNA_LINKING) { } else if(res.GetChemClass() == ost::mol::ChemClass::DNA_LINKING) {
S_chains.back().push_back(res); S_chains.back().push_back(res);
} else if(res.GetChemClass() == ost::mol::ChemClass::L_SACCHARIDE) { } else if(res.GetChemClass() == ost::mol::ChemClass::L_SACCHARIDE) {
X_chains.back().push_back(res); Z_chains.back().push_back(res);
} else if(res.GetChemClass() == ost::mol::ChemClass::D_SACCHARIDE) { } else if(res.GetChemClass() == ost::mol::ChemClass::D_SACCHARIDE) {
Y_chains.back().push_back(res); Z_chains.back().push_back(res);
} else if(res.GetChemClass() == ost::mol::ChemClass::SACCHARIDE) {
Z_chains.back().push_back(res);
} else if(res.GetChemClass() == ost::mol::ChemClass::WATER) { } else if(res.GetChemClass() == ost::mol::ChemClass::WATER) {
W_chains.back().push_back(res); W_chains.back().push_back(res);
} else if(res.GetChemClass() == ost::mol::ChemClass::NON_POLYMER) { } else if(res.GetChemClass() == ost::mol::ChemClass::NON_POLYMER) {
N_chains.push_back(res); N_chains.push_back(res);
} else if(res.GetChemClass() == ost::mol::ChemClass::UNKNOWN) { } else if(res.GetChemClass() == ost::mol::ChemClass::UNKNOWN) {
U_chains.push_back(res); // unknown is just treated as non-poly
N_chains.push_back(res);
} else { } else {
// TODO: make error message more insightful... // TODO: make error message more insightful...
throw ost::io::IOException("Unsupported chem class..."); throw ost::io::IOException("Unsupported chem class...");
...@@ -1037,7 +1068,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1037,7 +1068,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
for(auto res_list: L_chains) { for(auto res_list: L_chains) {
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::L_PEPTIDE_LINKING,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
...@@ -1052,7 +1082,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1052,7 +1082,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
for(auto res_list: D_chains) { for(auto res_list: D_chains) {
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::D_PEPTIDE_LINKING,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
...@@ -1067,7 +1096,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1067,7 +1096,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
for(auto res_list: P_chains) { for(auto res_list: P_chains) {
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::PEPTIDE_LINKING,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
...@@ -1082,7 +1110,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1082,7 +1110,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
for(auto res_list: R_chains) { for(auto res_list: R_chains) {
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::RNA_LINKING,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
...@@ -1097,7 +1124,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1097,7 +1124,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
for(auto res_list: S_chains) { for(auto res_list: S_chains) {
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::DNA_LINKING,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
...@@ -1108,26 +1134,10 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1108,26 +1134,10 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
} }
} }
// process L_SACHARIDE // process SACHARIDE
for(auto res_list: X_chains) { for(auto res_list: Z_chains) {
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::L_SACCHARIDE,
res_list,
entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
entity_info[entity_id].is_poly);
if(entity_info[entity_id].is_poly) {
Feed_pdbx_poly_seq_scheme(pdbx_poly_seq_scheme_, chain_name,
entity_id, res_list);
}
}
// process D_SACHARIDE
for(auto res_list: Y_chains) {
String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::D_SACCHARIDE,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
...@@ -1142,7 +1152,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1142,7 +1152,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
for(auto res_list: W_chains) { for(auto res_list: W_chains) {
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::WATER,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
...@@ -1159,24 +1168,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) { ...@@ -1159,24 +1168,6 @@ void MMCifWriter::SetEntity(const ost::mol::EntityHandle& ent) {
res_list.push_back(res); res_list.push_back(res);
String chain_name = chain_name_gen.Get(); String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name, int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::NON_POLYMER,
res_list,
entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
entity_info[entity_id].is_poly);
if(entity_info[entity_id].is_poly) {
Feed_pdbx_poly_seq_scheme(pdbx_poly_seq_scheme_, chain_name,
entity_id, res_list);
}
}
// process UNKNOWN
for(auto res: U_chains) {
ost::mol::ResidueHandleList res_list;
res_list.push_back(res);
String chain_name = chain_name_gen.Get();
int entity_id = Setup_entity_(chain_name,
ost::mol::ChemClass::UNKNOWN,
res_list, res_list,
entity_info); entity_info);
Feed_atom_site_(atom_site_, chain_name, entity_id, res_list, Feed_atom_site_(atom_site_, chain_name, entity_id, res_list,
......
modules/mol/base/src/chem_class.hh
+ 22
− 22
View file @ cc7da76f
...@@ -26,30 +26,30 @@ namespace ost { namespace mol { ...@@ -26,30 +26,30 @@ namespace ost { namespace mol {
struct DLLEXPORT ChemClass { struct DLLEXPORT ChemClass {
const static char PEPTIDE_LINKING ='P'; static constexpr char PEPTIDE_LINKING ='P';
const static char D_PEPTIDE_LINKING ='D'; static constexpr char D_PEPTIDE_LINKING ='D';
const static char L_PEPTIDE_LINKING ='L'; static constexpr char L_PEPTIDE_LINKING ='L';
const static char RNA_LINKING ='R'; static constexpr char RNA_LINKING ='R';
const static char DNA_LINKING ='S'; static constexpr char DNA_LINKING ='S';
const static char NON_POLYMER ='N'; static constexpr char NON_POLYMER ='N';
const static char L_SACCHARIDE ='X'; static constexpr char L_SACCHARIDE ='X';
const static char D_SACCHARIDE ='Y'; static constexpr char D_SACCHARIDE ='Y';
const static char SACCHARIDE ='Z'; static constexpr char SACCHARIDE ='Z';
const static char WATER ='W'; static constexpr char WATER ='W';
const static char UNKNOWN ='U'; static constexpr char UNKNOWN ='U';
// for backward compatibility to 1.1 and earlier // for backward compatibility to 1.1 and earlier
const static char PeptideLinking =PEPTIDE_LINKING; static constexpr char PeptideLinking =PEPTIDE_LINKING;
const static char DPeptideLinking =D_PEPTIDE_LINKING; static constexpr char DPeptideLinking =D_PEPTIDE_LINKING;
const static char LPeptideLinking =L_PEPTIDE_LINKING; static constexpr char LPeptideLinking =L_PEPTIDE_LINKING;
const static char RNALinking =RNA_LINKING; static constexpr char RNALinking =RNA_LINKING;
const static char DNALinking =DNA_LINKING; static constexpr char DNALinking =DNA_LINKING;
const static char NonPolymer =NON_POLYMER; static constexpr char NonPolymer =NON_POLYMER;
const static char LSaccharide =L_SACCHARIDE; static constexpr char LSaccharide =L_SACCHARIDE;
const static char DSaccharide =D_SACCHARIDE; static constexpr char DSaccharide =D_SACCHARIDE;
const static char Saccharide =SACCHARIDE; static constexpr char Saccharide =SACCHARIDE;
const static char Water =WATER; static constexpr char Water =WATER;
const static char Unknown =UNKNOWN; static constexpr char Unknown =UNKNOWN;
explicit ChemClass(char chem_class) explicit ChemClass(char chem_class)
: chem_class_(chem_class) { : chem_class_(chem_class) {
} }
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment