diff --git a/modules/mol/mm/pymod/export_simulation.cc b/modules/mol/mm/pymod/export_simulation.cc
index 92b96b0839eb245830f2db1e636d697ffa498b63..2a8f4436245dd7015bb928814ad740af8f7fa3a8 100644
--- a/modules/mol/mm/pymod/export_simulation.cc
+++ b/modules/mol/mm/pymod/export_simulation.cc
@@ -57,7 +57,6 @@ void export_Simulation()
.def("SetPositions",&ost::mol::mm::Simulation::SetPositions,(arg("positions"),arg("in_angstrom")=true))
.def("SetVelocities",&ost::mol::mm::Simulation::SetVelocities)
.def("GetEntity",&ost::mol::mm::Simulation::GetEntity)
- .def("GetEntityStandardNaming",&ost::mol::mm::Simulation::GetEntityStandardNaming)
.def("MinimizeEnergy",&ost::mol::mm::Simulation::MinimizeEnergy, (arg("type")="steep",arg("tolerance")=1.0,arg("max_iterations")=1000))
.def("GetEnergy",&ost::mol::mm::Simulation::GetEnergy)
.def("GetPotentialEnergy",&ost::mol::mm::Simulation::GetPotentialEnergy)
diff --git a/modules/mol/mm/pymod/export_topology.cc b/modules/mol/mm/pymod/export_topology.cc
index e95deb1ee812b33016c647851189593ed0b0c477..1307ad6816cd02437c0c232c957ecb37643e4f37 100644
--- a/modules/mol/mm/pymod/export_topology.cc
+++ b/modules/mol/mm/pymod/export_topology.cc
@@ -314,10 +314,10 @@ void export_Topology()
;
class_<ost::mol::mm::Topology>("Topology",no_init)
-// .def(init<ost::mol::EntityHandle&,ost::mol::mm::MMSettingsPtr>())
-// .def(init<ost::mol::EntityHandle&, std::vector<Real>&>())
.def("__init__",make_constructor(&WrapTopologyConstructor))
+ .def("Save",&ost::mol::mm::Topology::Save)
+ .def("Load",&ost::mol::mm::Topology::Load).staticmethod("Load")
.def("GetEntity",&ost::mol::mm::Topology::GetEntity)
//interaction adding functions
.def("AddHarmonicBond",&ost::mol::mm::Topology::AddHarmonicBond)
diff --git a/modules/mol/mm/src/index.hh b/modules/mol/mm/src/index.hh
index 055ad73a23ca22b4f53b02cf78ccefd2aa7421d4..403634a74997c0372315f618e40e3aa617e1bb72 100644
--- a/modules/mol/mm/src/index.hh
+++ b/modules/mol/mm/src/index.hh
@@ -64,6 +64,10 @@ public:
Index(uint a) {
(*this)[0]=a;
}
+ template <typename DS>
+ void Serialize(DS& ds){
+ ds & (*this)[0];
+ }
};
template <>
class Index<2> : public impl::IndexBase<2> {
@@ -73,6 +77,11 @@ public:
(*this)[0]=a;
(*this)[1]=b;
}
+ template <typename DS>
+ void Serialize(DS& ds){
+ ds & (*this)[0];
+ ds & (*this)[1];
+ }
};
template <>
class Index<3> : public impl::IndexBase<3> {
@@ -83,6 +92,12 @@ public:
(*this)[1]=b;
(*this)[2]=c;
}
+ template <typename DS>
+ void Serialize(DS& ds){
+ ds & (*this)[0];
+ ds & (*this)[1];
+ ds & (*this)[2];
+ }
};
template <>
class Index<4> : public impl::IndexBase<4> {
@@ -94,6 +109,13 @@ public:
(*this)[2]=c;
(*this)[3]=d;
}
+ template <typename DS>
+ void Serialize(DS& ds){
+ ds & (*this)[0];
+ ds & (*this)[1];
+ ds & (*this)[2];
+ ds & (*this)[3];
+ }
};
template <>
class Index<5> : public impl::IndexBase<5> {
@@ -106,6 +128,14 @@ public:
(*this)[3]=d;
(*this)[4]=e;
}
+ template <typename DS>
+ void Serialize(DS& ds){
+ ds & (*this)[0];
+ ds & (*this)[1];
+ ds & (*this)[2];
+ ds & (*this)[3];
+ ds & (*this)[4];
+ }
};
template <>
class Index<6> : public impl::IndexBase<6> {
@@ -119,6 +149,15 @@ public:
(*this)[4]=e;
(*this)[5]=f;
}
+ template <typename DS>
+ void Serialize(DS& ds){
+ ds & (*this)[0];
+ ds & (*this)[1];
+ ds & (*this)[2];
+ ds & (*this)[3];
+ ds & (*this)[4];
+ ds & (*this)[5];
+ }
};
template <>
class Index<7> : public impl::IndexBase<7> {
@@ -133,6 +172,16 @@ public:
(*this)[5]=f;
(*this)[6]=g;
}
+ template <typename DS>
+ void Serialize(DS& ds){
+ ds & (*this)[0];
+ ds & (*this)[1];
+ ds & (*this)[2];
+ ds & (*this)[3];
+ ds & (*this)[4];
+ ds & (*this)[5];
+ ds & (*this)[6];
+ }
};
template<uint D>
class IndexIterator {
diff --git a/modules/mol/mm/src/simulation.cc b/modules/mol/mm/src/simulation.cc
index 6a0d2762f460489e4b3eb2e6d073effd05590c95..213bd4385a5439c0704ab72fcdb82f91945f5790 100644
--- a/modules/mol/mm/src/simulation.cc
+++ b/modules/mol/mm/src/simulation.cc
@@ -9,34 +9,35 @@ Simulation::Simulation(const ost::mol::EntityHandle& handle,
//(hydrogens and shit)
TopologyPtr top = TopologyCreator::Create(handle,settings);
- this->Init(top);
+ this->Init(top, settings);
}
Simulation::Simulation(const TopologyPtr top,
const MMSettingsPtr settings){
- this->Init(top);
+ this->Init(top, settings);
}
-void Simulation::Init(const TopologyPtr top){
+void Simulation::Init(const TopologyPtr top,
+ const MMSettingsPtr settings){
top_ = top;
- integrator_ = settings_->integrator;
+ integrator_ = settings->integrator;
if(!integrator_){
throw ost::Error("Settings must have a valid integrator attached to set up a simulation!");
}
- system_ = SystemCreator::Create(top_,settings_,system_force_mapper_);
+ system_ = SystemCreator::Create(top_,settings,system_force_mapper_);
ost::mol::EntityHandle ent = top_->GetEntity();
original_masses_ = top_->GetMasses();
//setting up the context, which combines the system with an integrator
//to proceed in time, but first we have to load the proper platform
- OpenMM::Platform::loadPluginsFromDirectory (settings_->openmm_plugin_directory);
+ OpenMM::Platform::loadPluginsFromDirectory (settings->openmm_plugin_directory);
OpenMM::Platform* platform;
- switch(settings_->platform){
+ switch(settings->platform){
case Reference:{
platform = &OpenMM::Platform::getPlatformByName("Reference");
break;
@@ -74,8 +75,8 @@ void Simulation::Init(const TopologyPtr top){
//make sure the context satisfies the distance constraints
context_->applyConstraints(0.00001);
- if(settings_->init_temperature > 0.0){
- context_->setVelocitiesToTemperature(settings_->init_temperature);
+ if(settings->init_temperature > 0.0){
+ context_->setVelocitiesToTemperature(settings->init_temperature);
}
}
diff --git a/modules/mol/mm/src/simulation.hh b/modules/mol/mm/src/simulation.hh
index 627e6193481d5479ec59437c60dd2b2dbefc1dc9..a935c63badc5c6ba2b011cdf311dc3cf4c8d88d8 100644
--- a/modules/mol/mm/src/simulation.hh
+++ b/modules/mol/mm/src/simulation.hh
@@ -116,7 +116,8 @@ public:
void SetPeriodicBoxExtents(geom::Vec3& vec);
private:
- void Init(const ost::mol::mm::TopologyPtr top);
+ void Init(const ost::mol::mm::TopologyPtr top,
+ const MMSettingsPtr settings);
int TimeToNextNotification();
diff --git a/modules/mol/mm/src/topology.cc b/modules/mol/mm/src/topology.cc
index e31859803ef132227832f869c1d3c79083dd67f4..2ed6edad2866c580ab0246aba779438389105ddb 100644
--- a/modules/mol/mm/src/topology.cc
+++ b/modules/mol/mm/src/topology.cc
@@ -20,25 +20,29 @@ Topology::Topology(const ost::mol::EntityHandle& ent, const std::vector<Real>& m
fudge_lj_ = 1.0;
fudge_qq_ = 1.0;
- for(uint i = 0; i < atom_list_.size(); ++i){
- atom_index_mapper_[atom_list_[i].GetHashCode()] = i;
- }
+ this->InitMappers();
+}
- for(uint i = 0; i < res_list_.size(); ++i){
- residue_index_mapper_[res_list_[i].GetHashCode()] = i;
- }
+TopologyPtr Topology::Load(const String& filename){
- std::map<String,uint> per_residue_mapper;
- ost::mol::AtomHandleList residue_atom_list;
- for(uint i = 0; i < num_residues_; ++i){
- per_residue_mapper.clear();
- residue_atom_list = res_list_[i].GetAtomList();
- for(ost::mol::AtomHandleList::iterator j = residue_atom_list.begin();
- j != residue_atom_list.end(); ++j){
- per_residue_mapper[j->GetName()] = atom_index_mapper_[j->GetHashCode()];
- }
- atom_name_mapper_.push_back(per_residue_mapper);
+ if (!boost::filesystem::exists(filename)) {
+ std::stringstream ss;
+ ss << "Could not open topology. File '"
+ << filename << "' does not exist";
+ throw ost::io::IOException(ss.str());
}
+
+ std::ifstream stream(filename.c_str(), std::ios_base::binary);
+ io::BinaryDataSource ds(stream);
+ TopologyPtr top_p(new Topology);
+ ds >> *top_p;
+ return top_p;
+}
+
+void Topology::Save(const String& filename){
+ std::ofstream stream(filename.c_str(), std::ios_base::binary);
+ io::BinaryDataSink ds(stream);
+ ds << *this;
}
uint Topology::AddHarmonicBond(uint index_one,
@@ -1332,5 +1336,27 @@ void Topology::Merge(TopologyPtr p){
}
+void Topology::InitMappers(){
+ for(uint i = 0; i < atom_list_.size(); ++i){
+ atom_index_mapper_[atom_list_[i].GetHashCode()] = i;
+ }
+
+ for(uint i = 0; i < res_list_.size(); ++i){
+ residue_index_mapper_[res_list_[i].GetHashCode()] = i;
+ }
+
+ std::map<String,uint> per_residue_mapper;
+ ost::mol::AtomHandleList residue_atom_list;
+ for(uint i = 0; i < num_residues_; ++i){
+ per_residue_mapper.clear();
+ residue_atom_list = res_list_[i].GetAtomList();
+ for(ost::mol::AtomHandleList::iterator j = residue_atom_list.begin();
+ j != residue_atom_list.end(); ++j){
+ per_residue_mapper[j->GetName()] = atom_index_mapper_[j->GetHashCode()];
+ }
+ atom_name_mapper_.push_back(per_residue_mapper);
+ }
+}
+
}}}//ns
diff --git a/modules/mol/mm/src/topology.hh b/modules/mol/mm/src/topology.hh
index dbe67e60d48f07cb918d3145e8f7f852da9e3c5d..16984c7db7c7c15080137ddaca1c8a5c65bc4637 100644
--- a/modules/mol/mm/src/topology.hh
+++ b/modules/mol/mm/src/topology.hh
@@ -20,6 +20,7 @@
#include <ost/mol/mm/mm_interaction.hh>
#include <ost/mol/xcs_editor.hh>
#include <ost/mol/bond_handle.hh>
+#include <ost/mol/residue_prop.hh>
#include <time.h>
@@ -37,6 +38,10 @@ public:
Topology(const ost::mol::EntityHandle& ent, const std::vector<Real>& masses);
+ static TopologyPtr Load(const String& filename);
+
+ void Save(const String& filename);
+
uint AddHarmonicBond(uint index_one,
uint index_two,
Real bond_length,
@@ -360,8 +365,433 @@ public:
void SetEntityPositions(const geom::Vec3List& positions);
+ template <typename DS>
+ void Serialize(DS& ds){
+
+ ds & num_atoms_;
+ ds & num_residues_;
+
+ uint num_chains = 0;
+ uint num_residues = 0;
+ uint num_atoms = 0;
+ uint num_bonded_atoms = 0;
+ Real x_pos = 0.0;
+ Real y_pos = 0.0;
+ Real z_pos = 0.0;
+ Real bfac = 0.0;
+ Real occ = 0.0;
+ bool is_hetatm = false;
+ String chain_name = "X";
+ String res_name = "XXX";
+ int resnum_num = 0;
+ char resnum_code = '\0';
+ String atom_name = "X";
+ String atom_element = "X";
+ uint atom_index = 0;
+ uint num_items = 0;
+ Index<2> actual_index;
+
+ if(ds.IsSource()){
+ ost::mol::EntityHandle ent = ost::mol::CreateEntity();
+ ost::mol::XCSEditor ed = ent.EditXCS();
+ ds & num_chains;
+ for(uint i = 0; i < num_chains; ++i){
+ ds & chain_name;
+ ds & num_residues;
+ ost::mol::ChainHandle chain = ed.InsertChain(chain_name);
+ for(uint j = 0; j < num_residues; ++j){
+ ds & res_name;
+ ds & resnum_num;
+ ds & resnum_code;
+ ds & num_atoms;
+ ost::mol::ResNum num(resnum_num,resnum_code);
+ ost::mol::ResidueHandle res = ed.AppendResidue(chain,res_name,num);
+ for(uint k = 0; k < num_atoms; ++k){
+ ds & atom_name;
+ ds & atom_element;
+ ds & x_pos;
+ ds & y_pos;
+ ds & z_pos;
+ ds & bfac;
+ ds & occ;
+ ds & is_hetatm;
+ geom::Vec3 pos(x_pos,y_pos,z_pos);
+ ed.InsertAtom(res,atom_name,pos,atom_element,occ,bfac,is_hetatm);
+ }
+ }
+ }
+ ent_ = ent;
+ atom_list_ = ent_.GetAtomList();
+ res_list_ = ent_.GetResidueList();
+ for(uint i = 0; i < atom_list_.size(); ++i){
+ ds & num_bonded_atoms;
+ for(uint j = 0; j < num_bonded_atoms; ++j){
+ ds & atom_index;
+ ed.Connect(atom_list_[i],atom_list_[atom_index]);
+ }
+ }
+ InitMappers();
+ }
+ else{
+ num_chains = ent_.GetChainCount();
+ ds & num_chains;
+ ost::mol::ChainHandleList chain_list = ent_.GetChainList();
+ for(ost::mol::ChainHandleList::iterator i = chain_list.begin();
+ i != chain_list.end(); ++i){
+ chain_name = i->GetName();
+ num_residues = i->GetResidueCount();
+ ds & chain_name;
+ ds & num_residues;
+ ost::mol::ResidueHandleList res_list = i->GetResidueList();
+ for(ost::mol::ResidueHandleList::iterator j = res_list.begin();
+ j != res_list.end(); ++j){
+ res_name = j->GetKey();
+ resnum_num = j->GetNumber().GetNum();
+ resnum_code = j->GetNumber().GetInsCode();
+ num_atoms = j->GetAtomCount();
+ ds & res_name;
+ ds & resnum_num;
+ ds & resnum_code;
+ ds & num_atoms;
+ ost::mol::AtomHandleList atom_list = j->GetAtomList();
+ for(ost::mol::AtomHandleList::iterator k = atom_list.begin();
+ k != atom_list.end(); ++k){
+ atom_name = k->GetName();
+ atom_element = k->GetElement();
+ geom::Vec3 pos = k->GetPos();
+ bfac = k->GetBFactor();
+ occ = k->GetOccupancy();
+ is_hetatm = k->IsHetAtom();
+ ds & atom_name;
+ ds & atom_element;
+ ds & pos[0];
+ ds & pos[1];
+ ds & pos[2];
+ ds & bfac;
+ ds & occ;
+ ds & is_hetatm;
+ }
+ }
+ }
+ ost::mol::AtomHandleList bonded_atoms;
+ for(ost::mol::AtomHandleList::iterator i = atom_list_.begin();
+ i != atom_list_.end(); ++i){
+ bonded_atoms = i->GetBondPartners();
+ num_bonded_atoms = bonded_atoms.size();
+ ds & num_bonded_atoms;
+ for(ost::mol::AtomHandleList::iterator j = bonded_atoms.begin();
+ j != bonded_atoms.end(); ++j){
+ atom_index = this->GetAtomIndex(*j);
+ ds & atom_index;
+ }
+ }
+ }
+
+ ds & fudge_qq_;
+ ds & fudge_lj_;
+
+ if(ds.IsSource()){
+ ds & num_items;
+ atom_masses_ = std::vector<Real>(num_items);
+ ds & num_items;
+ sigmas_ = std::vector<Real>(num_items);
+ ds & num_items;
+ epsilons_ = std::vector<Real>(num_items);
+ ds & num_items;
+ gbsa_radii_ = std::vector<Real>(num_items);
+ ds & num_items;
+ obc_scaling_ = std::vector<Real>(num_items);
+ ds & num_items;
+ charges_ = std::vector<Real>(num_items);
+ ds & num_items;
+ position_constraints_ = std::vector<uint>(num_items);
+ }
+ else{
+ num_items = atom_masses_.size();
+ ds & num_items;
+ num_items = sigmas_.size();
+ ds & num_items;
+ num_items = epsilons_.size();
+ ds & num_items;
+ num_items = gbsa_radii_.size();
+ ds & num_items;
+ num_items = obc_scaling_.size();
+ ds & num_items;
+ num_items = charges_.size();
+ ds & num_items;
+ num_items = position_constraints_.size();
+ ds & num_items;
+ }
+
+ for(std::vector<Real>::iterator i = atom_masses_.begin();
+ i != atom_masses_.end(); ++i){
+ ds & *i;
+ }
+
+ for(std::vector<Real>::iterator i = sigmas_.begin();
+ i != sigmas_.end(); ++i){
+ ds & *i;
+ }
+
+ for(std::vector<Real>::iterator i = epsilons_.begin();
+ i != epsilons_.end(); ++i){
+ ds & *i;
+ }
+
+ for(std::vector<Real>::iterator i = gbsa_radii_.begin();
+ i != gbsa_radii_.end(); ++i){
+ ds & *i;
+ }
+
+ for(std::vector<Real>::iterator i = obc_scaling_.begin();
+ i != obc_scaling_.end(); ++i){
+ ds & *i;
+ }
+
+ for(std::vector<Real>::iterator i = charges_.begin();
+ i != charges_.end(); ++i){
+ ds & *i;
+ }
+
+ for(std::vector<uint>::iterator i = position_constraints_.begin();
+ i != position_constraints_.end(); ++i){
+ ds & *i;
+ }
+
+ if(ds.IsSource()){
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ harmonic_bonds_.push_back(std::make_pair(Index<2>(),std::vector<Real>(2)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ harmonic_angles_.push_back(std::make_pair(Index<3>(),std::vector<Real>(2)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ urey_bradley_angles_.push_back(std::make_pair(Index<3>(),std::vector<Real>(4)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ periodic_dihedrals_.push_back(std::make_pair(Index<4>(),std::vector<Real>(3)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ periodic_impropers_.push_back(std::make_pair(Index<4>(),std::vector<Real>(3)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ harmonic_impropers_.push_back(std::make_pair(Index<4>(),std::vector<Real>(2)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ uint num_values = 0;
+ ds & num_values;
+ cmaps_.push_back(std::make_pair(Index<5>(),std::vector<Real>(num_values)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ lj_pairs_.push_back(std::make_pair(Index<2>(),std::vector<Real>(2)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ distance_constraints_.push_back(std::make_pair(Index<2>(),std::vector<Real>(1)));
+ }
+
+ ds & num_items;
+ exclusions_ = std::vector<Index<2> >(num_items);
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ harmonic_position_restraints_.push_back(std::make_pair(Index<1>(),std::vector<Real>(7)));
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ harmonic_distance_restraints_.push_back(std::make_pair(Index<2>(),std::vector<Real>(2)));
+ }
+ }
+ else{
+ num_items = harmonic_bonds_.size();
+ ds & num_items;
+ num_items = harmonic_angles_.size();
+ ds & num_items;
+ num_items = urey_bradley_angles_.size();
+ ds & num_items;
+ num_items = periodic_dihedrals_.size();
+ ds & num_items;
+ num_items = periodic_impropers_.size();
+ ds & num_items;
+ num_items = harmonic_impropers_.size();
+ ds & num_items;
+ num_items = cmaps_.size();
+ ds & num_items;
+ for(uint i = 0; i < cmaps_.size(); ++i){
+ num_items = cmaps_[i].second.size();
+ ds & num_items;
+ }
+ num_items = lj_pairs_.size();
+ ds & num_items;
+ num_items = distance_constraints_.size();
+ ds & num_items;
+ num_items = exclusions_.size();
+ ds & num_items;
+ num_items = harmonic_position_restraints_.size();
+ ds & num_items;
+ num_items = harmonic_distance_restraints_.size();
+ ds & num_items;
+ }
+
+ for(std::vector<std::pair<Index<2>,std::vector<Real> > >::iterator i = harmonic_bonds_.begin();
+ i != harmonic_bonds_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ }
+
+ for(std::vector<std::pair<Index<3>,std::vector<Real> > >::iterator i = harmonic_angles_.begin();
+ i != harmonic_angles_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ }
+
+ for(std::vector<std::pair<Index<3>,std::vector<Real> > >::iterator i = urey_bradley_angles_.begin();
+ i != urey_bradley_angles_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ ds & i->second[2];
+ ds & i->second[3];
+ }
+
+ for(std::vector<std::pair<Index<4>,std::vector<Real> > >::iterator i = periodic_dihedrals_.begin();
+ i != periodic_dihedrals_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ ds & i->second[2];
+ }
+
+ for(std::vector<std::pair<Index<4>,std::vector<Real> > >::iterator i = periodic_impropers_.begin();
+ i != periodic_impropers_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ ds & i->second[2];
+ }
+
+ for(std::vector<std::pair<Index<4>,std::vector<Real> > >::iterator i = harmonic_impropers_.begin();
+ i != harmonic_impropers_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ }
+
+ for(std::vector<std::pair<Index<5>,std::vector<Real> > >::iterator i = cmaps_.begin();
+ i != cmaps_.end(); ++i){
+ ds & i->first;
+ for(std::vector<Real>::iterator j = i->second.begin();
+ j != i->second.end(); ++j){
+ ds & (*j);
+ }
+ }
+
+ for(std::vector<std::pair<Index<2>,std::vector<Real> > >::iterator i = lj_pairs_.begin();
+ i != lj_pairs_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ }
+
+ for(std::vector<std::pair<Index<2>,std::vector<Real> > >::iterator i = distance_constraints_.begin();
+ i != distance_constraints_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ }
+
+ for(std::vector<Index<2> >::iterator i = exclusions_.begin();
+ i != exclusions_.end(); ++i){
+ ds & (*i);
+ }
+
+ for(std::vector<std::pair<Index<1>,std::vector<Real> > >::iterator i = harmonic_position_restraints_.begin();
+ i != harmonic_position_restraints_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ ds & i->second[2];
+ ds & i->second[3];
+ ds & i->second[4];
+ ds & i->second[5];
+ ds & i->second[6];
+ }
+
+ for(std::vector<std::pair<Index<2>,std::vector<Real> > >::iterator i = harmonic_distance_restraints_.begin();
+ i != harmonic_distance_restraints_.end(); ++i){
+ ds & i->first;
+ ds & i->second[0];
+ ds & i->second[1];
+ }
+
+ if(ds.IsSource()){
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ ds & actual_index;
+ added_lj_pairs_.insert(actual_index);
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ ds & actual_index;
+ added_distance_constraints_.insert(actual_index);
+ }
+
+ ds & num_items;
+ for(uint i = 0; i < num_items; ++i){
+ ds & actual_index;
+ added_exclusions_.insert(actual_index);
+ }
+ }
+ else{
+ num_items = added_lj_pairs_.size();
+ ds & num_items;
+ for(std::set<Index<2> >::iterator i = added_lj_pairs_.begin();
+ i != added_lj_pairs_.end(); ++i){
+ actual_index = *i;
+ ds & actual_index;
+ }
+ num_items = added_distance_constraints_.size();
+ ds & num_items;
+ for(std::set<Index<2> >::iterator i = added_distance_constraints_.begin();
+ i != added_distance_constraints_.end(); ++i){
+ actual_index = *i;
+ ds & actual_index;
+ }
+ num_items = added_exclusions_.size();
+ ds & num_items;
+ for(std::set<Index<2> >::iterator i = added_exclusions_.begin();
+ i != added_exclusions_.end(); ++i){
+ actual_index = *i;
+ ds & actual_index;
+ }
+ }
+ }
+
private:
+ Topology() { } //hidden constructor without parameters
+
+ void InitMappers();
+
ost::mol::EntityHandle ent_;
ost::mol::AtomHandleList atom_list_;
ost::mol::ResidueHandleList res_list_;