export_loop_closure.cc

#include <boost/python.hpp>
#include <boost/python/iterator.hpp>
#include <boost/python/register_ptr_to_python.hpp>
#include <promod3/core/export_helper.hh>

#include <promod3/modelling/ccd.hh>
#include <promod3/modelling/kic.hh>
#include <promod3/modelling/backbone_relaxer.hh>

using namespace promod3;
using namespace promod3::modelling;
using namespace boost::python;

namespace {

// CCD wrappers

CCDPtr ccd_constructor_one(const String& sequence,
                           const ost::mol::ResidueHandle& before,
                           const ost::mol::ResidueHandle& after, 
                           loop::TorsionSamplerPtr torsion_sampler,
                           uint max_steps, Real rmsd_cutoff, int seed) {
  CCDPtr p(new CCD(sequence, before, after, torsion_sampler, max_steps,
                   rmsd_cutoff, seed));
  return p;
}

CCDPtr ccd_constructor_two(const String& sequence,
                           const ost::mol::ResidueHandle& before,
                           const ost::mol::ResidueHandle& after,
                           const boost::python::list& torsion_sampler,
                           uint max_steps, Real rmsd_cutoff, int seed) {
  loop::TorsionSamplerList v_samplers;
  core::ConvertListToVector(torsion_sampler, v_samplers);
  CCDPtr p(new CCD(sequence, before, after, v_samplers, max_steps, rmsd_cutoff,
                   seed));
  return p;
}

CCDPtr ccd_constructor_three(const ost::mol::ResidueHandle& before, 
                             const ost::mol::ResidueHandle& after, 
                             uint max_steps, Real rmsd_cutoff) {
  CCDPtr p(new CCD(before, after, max_steps, rmsd_cutoff));
  return p;
}

// KIC wrappers

boost::python::list WrapKICClose(const KIC& closer,
                                 const loop::BackboneList& bb_list, 
                                 uint pivot_one, uint pivot_two, uint pivot_three){
  std::vector<loop::BackboneList> closed_loops;
  closer.Close(bb_list, pivot_one,pivot_two,pivot_three,closed_loops);
  boost::python::list return_list;
  core::AppendVectorToList(closed_loops, return_list);
  return return_list;
}

//BackboneRelaxer constructors
BackboneRelaxerPtr plain_bb_relaxer_constructor(
                            const loop::BackboneList& bb, bool fix_nterm, 
                            bool fix_cterm) {
  BackboneRelaxerPtr p(new BackboneRelaxer(bb,fix_nterm,fix_cterm));
  return p;
}

BackboneRelaxerPtr bb_relaxer_constructor_with_density(
                            const loop::BackboneList& bb,
                            const ost::img::ImageHandle& density,
                            Real density_resolution, bool fix_nterm,
                            bool fix_cterm) {
  BackboneRelaxerPtr p(new BackboneRelaxer(bb, 
                                           density, 
                                           density_resolution,
                                           fix_nterm,
                                           fix_cterm));
  return p;
}

}

void export_loop_closure(){

  
  class_<CCD>("CCD",no_init)
    .def("__init__",make_constructor(&ccd_constructor_one))
    .def("__init__",make_constructor(&ccd_constructor_two))
    .def("__init__",make_constructor(&ccd_constructor_three))
    .def("Close",&CCD::Close,(arg("bb_list")))
  ;

  register_ptr_to_python<CCDPtr>();

  class_<KIC>("KIC",init<const ost::mol::ResidueHandle&, const ost::mol::ResidueHandle>())
    .def("Close",&WrapKICClose,(arg("bb_list"),arg("pivot_one"),arg("pivot_two"),arg("pivot_three")))
  ;

  register_ptr_to_python<KICPtr>();

  class_<BackboneRelaxer> ("BackboneRelaxer", no_init)
    .def("__init__",make_constructor(&plain_bb_relaxer_constructor,default_call_policies(),(arg("bb_list"),arg("fix_nterm")=true,arg("fix_cterm")=true)))
    .def("__init__",make_constructor(&bb_relaxer_constructor_with_density,default_call_policies(),(arg("bb_list"),arg("density"),arg("density_resolution"),arg("fix_nterm")=true,arg("fix_cterm")=true)))
    .def("AddNRestraint",&BackboneRelaxer::AddNRestraint,(arg("idx"),arg("pos"),arg("force_constaint") = 100000.0))
    .def("AddCARestraint",&BackboneRelaxer::AddCARestraint,(arg("idx"),arg("pos"),arg("force_constaint") = 100000.0))
    .def("AddCBRestraint",&BackboneRelaxer::AddCBRestraint,(arg("idx"),arg("pos"),arg("force_constaint") = 100000.0))
    .def("AddCRestraint",&BackboneRelaxer::AddCRestraint,(arg("idx"),arg("pos"),arg("force_constaint") = 100000.0))
    .def("AddORestraint",&BackboneRelaxer::AddORestraint,(arg("idx"),arg("pos"),arg("force_constaint") = 100000.0))
    .def("Run",&BackboneRelaxer::Run,(arg("bb_list"),arg("steps")=100,arg("stop_criterion")=0.01))
  ;

  register_ptr_to_python<BackboneRelaxerPtr>(); 
}