/***************************************************************************
                          constraint_mod.cpp  -  description
                             -------------------
    begin                : Wed Nov 17 16:56:21 2004
    copyright            : (C) 2002 by Cavalli Andrea
    email                : cavalli@bioc.unizh.ch
**************************************************************************/
/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <zeta/module.h>
#include <zeta/class.h>
#include <zeta/zextclass.h>
#include <zeta/zobj.hpp>
#include <forcefield/const/constraint.h>
#include <forcefield/const/base/rgyrconst.h>
#include <forcefield/const/misc/qvdw.h>
#include <forcefield/const/misc/sphereconst.h>
#include <forcefield/const/misc/shell.h>
#include <forcefield/const/misc/fix.h>
#include <forcefield/const/base/bondconst.h>
#include <forcefield/const/base/angleconst.h>
#include <forcefield/const/base/dihedralconst.h>
#include <forcefield/const/base/improperconst.h>
#include <forcefield/const/nmr/jcoupling.h>
#include <forcefield/const/misc/posconst.h>
#ifdef BUILD_SHXCONST
#include <forcefield/const/shiftconst.h>
#endif
#ifdef BUILD_PECONST
#include <forcefield/const/rose/peconst.h>
#endif
#include <forcefield/const/misc/nconst.h>
#include <forcefield/const/menoe.h>
#include <forcefield/const/vdwnoe.h>
#include <forcefield/const/nmr/noeconst.h>
#include <forcefield/const/nmr/ambnoeconst.h>
#include <forcefield/const/rose/rosenoe.h>
#include <forcefield/const/rose/rosenoegroup.h>
#include <forcefield/const/nmr/xnoeconst.h>
#include <forcefield/const/nmr/s2.h>
#include <forcefield/const/nmr/s2rmsd.h>
#include <forcefield/const/nmr/s2mrmsd.h>
#include <forcefield/const/nmr/rdc.h>
#include <forcefield/const/misc/hbconst.h>
#include <forcefield/const/pmf/bhb.h>
#include <forcefield/const/pmf/apmf.h>
#include <forcefield/const/pmf/dopeconst.h>
#include <forcefield/const/pmf/dpmf.h>
#include <forcefield/const/pmf/ssdpmf.h>
#include <forcefield/const/rose/envconst.h>
#include <forcefield/const/rose/envpair.h>
#include <forcefield/const/misc/contmap.h>
#include <forcefield/const/camshift.h>
#include <forcefield/const/shiftxconst.h>
#include <forcefield/const/shxconst.h>

using namespace Almost;
//CamShift
const double CamShift::cutOffSmoothingExp = 8.0;

#define ALMTOSTRING(s) \
template<> \
inline string to_string(const s & ){ \
  return "<" #s ">"; \
}

ALMTOSTRING(Coor3D);
ALMTOSTRING(Molecules);
ALMTOSTRING(NameSelection);
ALMTOSTRING(MDB);
ALMTOSTRING(Coor<double>);
ALMTOSTRING(Coor<float>);
// takes a constraint and returns a string
template<>
inline string to_string(const ConstraintCollection & sp){
  return "<Constraint::collection>";
}


template<>
inline string to_string(const RGYRConst & sp){
  return "<Constraint::RGYRConst>";
}

template<>
inline string to_string(const SphereConst & sp){
  return "<Constraint::SphereConst>";
}

template<>
inline string to_string(const Shell<double> & sp){
  return "<Constraint::Shell>";
}

template<>
inline string to_string(const Fix<double>  & sp){
  return "<Constraint::Fix<double> >";
}

template<>
inline string to_string(const BondConst<double> & sp){
  return "<Constraint::BondConst>";
}

template<>
inline string to_string(const AngleConst<double> & sp){
  return "<Constraint::AngleConst>";
}

template<>
inline string to_string(const DihedralConst<double> & sp){
  return "<Constraint::DihedralConst<double>>";
}

template<>
inline string to_string(const DihedralConst<float> & sp){
  return "<Constraint::DihedralConst<float>>";
}


template<>
inline string to_string(const ImproperConst<double> & sp){
  return "<Constraint::ImproperConst>";
}

template<>
inline string to_string(const JCoupling & sp){
  return "<Constraint::JCoupling>";
}

template<>
inline string to_string(const RdcConst & sp){
  return "<Constraint::RdcConst>";
}

template<>
inline string to_string(const XRdcConst & sp){
  return "<Constraint::XRdcConst>";
}

template<>
inline string to_string(const RdcOpts & sp){
  return "<Constraint::RdcOpts>";
}

#ifdef BUILD_SHXCONST
template<>
inline string to_string(const ShiftConst & sp){
  return "<Constraint::ShiftConst>";
}


template<>
inline string to_string(const ShiftOpts & sp){
  return "<Constraint::ShiftOpts>";
}
#endif

#ifdef BUILD_PECONST
template<>
inline string to_string(const PEConst & sp){
  return "<Constraint::PEConst>";
}
#endif

template<>
inline string to_string(const NConst & sp){
  return "<Constraint::NConst>";
}

template<>
inline string to_string(const NOEConst & sp){
  return "<Constraint::NOEConst>";
}

template<>
inline string to_string(const MENoe<double> & sp){
  return "<Constraint::MENoe>";
}

template<>
inline string to_string(const VdWNoe<double> & sp){
  return "<Constraint::VdWNoe>";
}

template<>
inline string to_string(const QVdW<double> & sp){
  return "<Constraint::QVdW>";
}

template<>
inline string to_string(const AmbNOEConst<double> & sp){
  return "<Constraint::AmbNOEConst>";
}

template<>
inline string to_string(const AmbNOEConstDyn<double> & sp){
  return "<Constraint::AmbNOEConstDyn>";
}

template<>
inline string to_string(const RoseNOEConst<double> & sp){
  return "<Constraint::RoseNOEConst>";
}

template<>
inline string to_string(const RoseNOEGroupConst<double> & sp){
  return "<Constraint::RoseNOEGroupConst>";
}

template<>
inline string to_string(const HBConst<double> & sp){
  return "<Constraint::HBConst>";
}

template<>
inline string to_string(const BHB<double> & sp){
  return "<Constraint::BHB>";
}

template<>
inline string to_string(const XNOEConst & sp){
  return "<Constraint::XNOEConst>";
}

template<>
inline string to_string(const S2Const & sp){
  return "<Constraint::S2Const>";
}


template<>
inline string to_string(const S2RMSDConst<double> & sp){
  return "<Constraint::S2RMSDConst>";
}

template<>
inline string to_string(const S2MRMSDConst<double> & sp){
  return "<Constraint::S2MRMSDConst>";
}


template<>
inline string to_string(const APMF<double> & sp){
  return "<Constraint::APMF>";
}

template<>
inline string to_string(const DOPE<double> & sp){
  return "<Constraint::DOPE>";
}

template<>
inline string to_string(const DPMF<double> & sp){
  return "<Constraint::DPMF>";
}

template<>
inline string to_string(const SSDPMF<double> & sp){
  return "<Constraint::SSDPMF>";
}

template<>
inline string to_string(const EnvConst<double> & sp){
  return "<Constraint::EnvConst>";
}

template<>
inline string to_string(const EnvPairConst<double> & sp){
  return "<Constraint::EnvPairConst>";
}

template<>
inline string to_string(const PosConst & sp){
  return "<Constraint::PosConst>";
}

template<>
inline string to_string(const ContMap<double> & sp){
  return "<Constraint::ContMap>";
}

template<>
inline string to_string(const CamShift & sp){
  return "<Constraint::CamShiftMap>";
}

template<>
inline string to_string(const ShiftXConst & sp){
  return "<Constraint::ShiftXConst>";
}

template<>
inline string to_string(const ShxConst & sp){
  return "<Constraint::ShxConst>";
}

// template function: the parameter is the constraint type, the arguments are the constraint
// collector and the actual constraint: this is therefore a function that adds a constraint to 
// the constraint collection
template<typename ConstType>
void add_const( ConstraintCollection & c, ConstType & cg){
  c.add(cg);
}


APMF<double> mkapmf(const Molecules & m, string db, int k ,double l){
  return APMF<double>(m,db,k,l);
}

extern "C" {
  void init_constraint(){ // function that is called when the constraints are initialized
    //constraint declarations here

    Module mod = Module("const","Molecular Dynamics and Monte Carlo Restraints"); // a object of class Module is constructed

    Class<SphereConst,ArgList5<const Coor3D &,
      double,double,
      int,double> >(mod.self(),"sphere");

    Class<Shell<double>,ArgList5<const Molecules &,
      const NameSelection &,
      const NameSelection &,
      double,const MDB &> >(mod.self(),"shell")
      .def_method("set_timestep", &Shell<double>::set_timestep)
      ;

    Class <HBConst<double>, ArgList1<const Molecules &> >
      (mod.self(),"hb")
      .def_method("set_lambda",&HBConst<double>::set_lambda)
      .def_method("lambda",&HBConst<double>::lambda)
      ;


    Class <BHB<double>, ArgList4<const Molecules &,  string , double, bool> >(mod.self(),"bhb")
      .def_method("energy",&BHB<double>::energy)
      .def_method("hblist",&BHB<double>::hblist)
      .def_attribute("W_bb_bb",
		     &BHB<double>::W_bb_bb,
		     "Weight of the backbone-backbone h-bond energy term")
      .def_attribute("W_sc_sc_sp2",
		     &BHB<double>::W_sc_sc_sp2,
		     "Weight of the sidechain-sidechain-sp2 h-bond energy term")
      .def_attribute("W_bb_sc_sp2",&BHB<double>::W_bb_sc_sp2,
		     "Weight of the backbone-sidechain-sp2 h-bond energy term")
      .def_attribute("W_sc_sc_sp3",&BHB<double>::W_sc_sc_sp3,
		     "Weight of the sidechain-sidechain-sp3 h-bond energy term")
      .def_attribute("W_bb_sc_sp3",&BHB<double>::W_bb_sc_sp3,
		     "Weight of the backbone-sidechain-sp2 h-bond energy term")
      .def_attribute("sc_hb",&BHB<double>::sc_hb,
		     "If different from 0, compute sidechain contributions.")
      ;
    
    Class <APMF<double>, ArgList5<const Molecules &, string, string,int,
      double> >
      (mod.self(),"apmf")
      .def_method("pmf",&APMF<double>::pmf)
      .def_method("energy",&APMF<double>::energy)
      .def_method("dump_type_map",&APMF<double>::dump_type_map);

    Class<DOPE<double>, ArgList3<const Molecules &, string, 
      double> >(mod.self(),"dope")
      .def_method("energy",&DOPE<double>::energy)
      ;
								      

    Class <DPMF<double>, ArgList3<const Molecules &, string, 
      double> >
      (mod.self(),"dpmf")
      .def_method("energy",&DPMF<double>::energy)
      ;

    Class <SSDPMF<double>, ArgList2<const Molecules &, 
      double> >
      (mod.self(),"ssdpmf")
      .def_method("energy",&SSDPMF<double>::energy)
      ;


    Class<EnvConst<double>, ArgList2<const Molecules &,double>
      >(mod.self(),"env")
      .def_method("energy",&EnvConst<double>::energy)
      .def_method("site_energy",&EnvConst<double>::site_energy)
      ;

    Class<EnvPairConst<double>, ArgList2<const Molecules &,double>
      >(mod.self(),"envpair")
      .def_method("energy",&EnvPairConst<double>::energy)
      .def_method("site_energy",&EnvPairConst<double>::site_energy)
      ;

    Class<Fix<double> ,ArgList4<const Molecules &,
      const NameSelection &,double , double> >(mod.self(),"fix");

    Class<RGYRConst,ArgList4<const Molecules &,
      const NameSelection &,
      double,double> >(mod.self(),"rgyr")
      .def_method<double (RGYRConst::*)(const Coor<double>&)>("energy",&RGYRConst::energy)
      .def_method("energy2",&RGYRConst::energy2)
      ;

    Class<BondConst<double>,ArgList1<const Molecules & > >(mod.self(),"bond")
      .def_method("assign",&BondConst<double>::assign)
      .def_method("add",&BondConst<double>::add)
      .def_method("clear",&BondConst<double>::clear);

    Class<AngleConst<double>,ArgList1<const Molecules & > >(mod.self(),"angle")
      .def_method("assign",&AngleConst<double>::assign)
      .def_method("clear",&AngleConst<double>::clear);

    Class<DihedralConst<double>,
      ArgList1<const Molecules & > >(mod.self(),"dihedral")
      .def_method("assign",&DihedralConst<double>::assign)
      .def_method("clear",&DihedralConst<double>::clear)
      .def_method<double (DihedralConst<double>::*)(const Coor<double>&)>("energy",&DihedralConst<double>::energy)
      ;

    Class<DihedralConst<float>,
      ArgList1<const Molecules & > >(mod.self(),"fdihedral")
      .def_method("assign",&DihedralConst<float>::assign)
      .def_method("clear",&DihedralConst<float>::clear)
      .def_method<float (DihedralConst<float>::*)(const Coor<float>&)>("energy",&DihedralConst<float>::energy)
      ;

    Class<ImproperConst<double>,ArgList1<const Molecules & > >(mod.self(),"improper")
      .def_method("assign",&ImproperConst<double>::assign)
      .def_method("clear",&ImproperConst<double>::clear)
      ;


    Class<JCoupling,ArgList1<const Molecules & > >(mod.self(),"jcoupling")
      .def_method("set_coefficients",&JCoupling::set_coefficients)
      .def_method("add_const",&JCoupling::add_const)
      .def_method("assign",&JCoupling::assign)
      .def_method("check",&JCoupling::check)
      .def_method("clear",&JCoupling::clear);

#ifdef BUILD_SHXCONST
    Class<ShiftOpts>(mod.self(),"shift_options")
      .def_attribute("weight",&ShiftOpts::weight)
      .def_attribute("tol",&ShiftOpts::tol)
      .def_attribute("logfile",&ShiftOpts::logfile)
      .def_attribute("logfile_zero",&ShiftOpts::logfile_zero)
      .def_attribute("nprint",&ShiftOpts::nprint)
      .def_attribute("flag_h",&ShiftOpts::flag_h)
      .def_attribute("flag_ha",&ShiftOpts::flag_ha)
      .def_attribute("flag_n",&ShiftOpts::flag_n)
      .def_attribute("flag_ca",&ShiftOpts::flag_ca)
      .def_attribute("flag_cb",&ShiftOpts::flag_cb)
      .def_attribute("flag_c",&ShiftOpts::flag_c)
      ;

    Class<ShiftConst,ArgList2<const Molecules &,
      const ShiftOpts &> >(mod.self(),"shiftconst")
      .def_method("add_const",&ShiftConst::add_const)
      .def_method("score",&ShiftConst::score)
      ;
#endif

    Class<ShiftXConst,ArgList2<const Molecules &, string> >(mod.self(),
							    "shifx")
      .def_method("use_ha",&ShiftXConst::use_ha)
      .def_method("use_h",&ShiftXConst::use_h)
      .def_method("use_n",&ShiftXConst::use_n)
      .def_method("use_ca",&ShiftXConst::use_ca)
      .def_method("use_cb",&ShiftXConst::use_cb)
      .def_method("use_c",&ShiftXConst::use_c)
      .def_method("ha_tol",&ShiftXConst::ha_tol)
      .def_method("h_tol",&ShiftXConst::h_tol)
      .def_method("n_tol",&ShiftXConst::n_tol)
      .def_method("ca_tol",&ShiftXConst::ca_tol)
      .def_method("cb_tol",&ShiftXConst::cb_tol)
      .def_method("c_tol",&ShiftXConst::c_tol)
      .def_method("tol_cutoff",&ShiftXConst::tol_cutoff)
      .def_method("ha_tol_cutoff",&ShiftXConst::ha_tol_cutoff)
      .def_method("weight",&ShiftXConst::weight)
      .def_method("linearslope",&ShiftXConst::linearslope)
      .def_method("energy",&ShiftXConst::energy)
      .def_method("cheshire_energy",&ShiftXConst::cheshire_energy)
      .def_method("set_log",&ShiftXConst::set_log)
      ;
#ifdef BUILD_PECONST
    Class<PEConst,ArgList4<const Molecules &,
      double, double, const GSLVector & > >(mod.self(),"peconst");
#endif

    Class<NConst,ArgList4<const Molecules &,
      double, double, const vector<double> & > >(mod.self(),"nconst");

    Class<MENoe<double>,ArgList1<const Molecules & > >(mod.self(),"menoe")
      .def_method("assign",&MENoe<double>::assign)
      .def_method("add",&MENoe<double>::add)
      .def_method("clear",&MENoe<double>::clear)
      ;

    Class<VdWNoe<double>,ArgList1<const Molecules & > >(mod.self(),"vdwnoe")
      .def_method("assign",&VdWNoe<double>::assign)
      .def_method("add",&VdWNoe<double>::add)
      .def_method("clear",&VdWNoe<double>::clear)
      .def_method("set_tol",&VdWNoe<double>::set_tol)
      .def_method("set_update",&VdWNoe<double>::set_update)

      ;

    Class<QVdW<double>,ArgList2<const Molecules &, const MDB & > >(mod.self(),"qvdw")
      ;


    Class<NOEConst,ArgList1<const Molecules & > >(mod.self(),"noe")
      .def_method("assign",&NOEConst::assign)
      .def_method("clear",&NOEConst::clear)
      .def_method("set",&NOEConst::set_const)
      .def_method("scale",&NOEConst::scale)
      ;

    Class<AmbNOEConst<double>,
      ArgList3<const Molecules &, double, double > >(mod.self(),"ambnoe")
      //      .def_method("assign",&AmbNOEConst<double>::assign)
      .def_method("clear",&AmbNOEConst<double>::clear)
      //      .def_method("set",&AmbNOEConst<double>::set_const)
      .def_method("scale",&AmbNOEConst<double>::scale)
      .def_method("set_omega",&AmbNOEConst<double>::set_omega)
      .def_method("from_file",&AmbNOEConst<double>::from_file)
      .def_method("assign",&AmbNOEConst<double>::assign)
      .def_method("energy",&AmbNOEConst<double>::energy)
      .def_method("set",&AmbNOEConst<double>::set_const)
      .def_method("check",&AmbNOEConst<double>::check)
      ;

    Class<AmbNOEConstDyn<double>,
      ArgList3<const Molecules &, double, double > >(mod.self(),"dynambnoe")
      //      .def_method("assign",&AmbNOEConstDyn<double>::assign)
      .def_method("clear",&AmbNOEConstDyn<double>::clear)
      //      .def_method("set",&AmbNOEConstDyn<double>::set_const)
      .def_method("scale",&AmbNOEConstDyn<double>::scale)
      .def_method("set_omega",&AmbNOEConstDyn<double>::set_omega)
      .def_method("set_mult",&AmbNOEConstDyn<double>::set_mult)
      .def_method("set_safe",&AmbNOEConstDyn<double>::set_safe)
      .def_method("set_tol",&AmbNOEConstDyn<double>::set_tol)
      .def_method("set_update",&AmbNOEConstDyn<double>::set_update)
      .def_method("from_file",&AmbNOEConstDyn<double>::from_file)
      .def_method("assign",&AmbNOEConstDyn<double>::assign)
      .def_method("energy",&AmbNOEConstDyn<double>::energy)
      .def_method("set",&AmbNOEConstDyn<double>::set_const)
      .def_method("check",&AmbNOEConstDyn<double>::check)
      .def_method("active",&AmbNOEConstDyn<double>::active)
      ;


    Class<RoseNOEConst<double>,
      ArgList1<const Molecules & > >(mod.self(),"rosenoe")
	.def_method("from_file",&RoseNOEConst<double>::from_file)
	.def_method("name_from_file",&RoseNOEConst<double>::name_from_file)
	.def_method("energy",&RoseNOEConst<double>::energy)
	.def_method("violation",&RoseNOEConst<double>::violation)
      ;

    Class<RoseNOEGroupConst<double>,
      ArgList1<const Molecules & > >(mod.self(),"rosenoegroup")
	.def_method("from_file",&RoseNOEGroupConst<double>::from_file)
	.def_method("to_file",&RoseNOEGroupConst<double>::to_file)
	.def_method("name_from_file",&RoseNOEGroupConst<double>::name_from_file)
	.def_method("energy",&RoseNOEGroupConst<double>::energy)
	.def_method("violation",&RoseNOEGroupConst<double>::violation)
      ;

    // Rdc constraints
    // options
    Class<RdcOpts>(mod.self(),"rdc_options")
      .def_attribute("weight",&RdcOpts::weight,"Undocumented")
      .def_attribute("tol",&RdcOpts::tol,"Undocumented")
      .def_attribute("n1",&RdcOpts::n1,"Undocumented")
      .def_attribute("n2",&RdcOpts::n2,"Undocumented")
      .def_attribute("nprint",&RdcOpts::nprint,"Undocumented")
      .def_attribute("S_align",&RdcOpts::S_align,"Undocumented")
      .def_attribute("vf",&RdcOpts::vf,"Undocumented")
      .def_attribute("res",&RdcOpts::res,"Undocumented")
      .def_attribute("only_ca",&RdcOpts::only_ca,"Undocumented")
      .def_attribute("r_ca",&RdcOpts::r_ca,"Undocumented")
      .def_attribute("bw",&RdcOpts::bw,"Undocumented");


    // actual constraints
    typedef double (RdcConst::*ene)(const Coor<double> &);
    Class<RdcConst,ArgList2<const Molecules &,
      const RdcOpts &> >(mod.self(),"rdcconst")
      .def_method("add_const",&RdcConst::add_const)
      .def_method<ene>("energy",&RdcConst::energy)
      .def_method("print_saupe",&RdcConst::print_saupe)
      .def_method("print_rdc",&RdcConst::print_rdc)
      ;

    Class<XRdcConst,ArgList2<const Molecules &,
      const RdcOpts &> >(mod.self(),"xrdcconst")
      .def_method("add_const",&XRdcConst::add_const)
      ;



    //X Constrains
    Class<XNOEConst,ArgList1<const Molecules & > >(mod.self(),"xnoe")
      .def_method("assign",&XNOEConst::assign)
      .def_method("clear",&XNOEConst::clear);

    Class<S2Const,ArgList1<const Molecules & > >(mod.self(),"s2")
      .def_method("assign",&S2Const::assign)
      .def_method("clear",&S2Const::clear);

    Class<S2RMSDConst<double>,ArgList2<const Molecules &, const NameSelection& > >(mod.self(),"s2rmsd")
      .def_method("assign",&S2RMSDConst<double>::assign)
      .def_method("clear",&S2RMSDConst<double>::clear);

    Class<S2MRMSDConst<double>,ArgList3<const Molecules &, 
      const NameSelection&,
      const MDB &> >(mod.self(),"s2rmsd")
      .def_method("assign",&S2MRMSDConst<double>::assign)
      .def_method("clear",&S2MRMSDConst<double>::clear);

    {
      typedef double (PosConst::*ene)(const Coor<double> &);
      Class<PosConst,ArgList3<const Molecules & ,const NameSelection & ,
	double> >(mod.self(),"pos")
	  .def_method<ene>("energy",&PosConst::energy);


  
    }
 
    Class<ContMap<double>,ArgList5<const Molecules &,double,double,int,double> >(mod.self(),
										 "contmap")
      .def_method("build_cm",&ContMap<double>::build_cm)
      .def_method("add",&ContMap<double>::add)
      .def_method("energy",&ContMap<double>::energy)
      ;

    Class<CamShift, ArgList3<const Molecules &, const vector<string> &,
      const vector<string> &> >(mod.self(),
			      "camshift")
      .def_method("energy",&CamShift::energy)
      .def_method("force",&CamShift::force)
      .def_method("energy_force",&CamShift::energy_force)
//    .def_method("shifts",&CamShift::shifts)
      .def_method("set_lambda",&CamShift::set_lambda)
      .def_method("lambda",&CamShift::lambda)
      .def_method("set_flatBottomConst",&CamShift::set_flatBottomConst)
      .def_method("get_flatBottomConst",&CamShift::get_flatBottomConst)
      .def_method("set_shiftcutoff",&CamShift::set_shiftcutoff)
      .def_method("get_shiftcutoff",&CamShift::get_shiftcutoff)
      .def_method("set_debugatoms",&CamShift::set_debugatoms)
      .def_method("get_debugatom1",&CamShift::get_debugatom1)
      .def_method("get_debugatom2",&CamShift::get_debugatom2)
      .def_method("set_forcecutoff",&CamShift::set_forcecutoff)
      .def_method("get_forcecutoff",&CamShift::get_forcecutoff)
      .def_method("set_distcutoff",&CamShift::set_distcutoff)
      .def_method("get_distcutoff",&CamShift::get_distcutoff)
      .def_method("print_force",&CamShift::print_force)
      .def_method("printChemicalShifts",&CamShift::printChemicalShifts)
      ;

    Class<ShxConst,ArgList3<const Molecules &, string , double> >(mod.self(),
								  "shx");
  Class<ConstraintCollection>(mod.self(),"collection");

    mod.def_function("add_rgyr",
		     "Add RGYR restraint to contraints collection",
		     add_const<RGYRConst>);

    mod.def_function("add_sphere",
		     "Add spherical restraint to contraints collection",
		     add_const<SphereConst>);

    mod.def_function("add_shell",
		     "Add shell restraint to contraints collection",
		     add_const<Shell<double> >);

    mod.def_function("add_fix",
		     "Add fix restraint to contraints collection",
		     add_const<Fix<double> >);

    mod.def_function("add_hb",
		     "Add hb restraint to contraints collection",
		     add_const<HBConst<double> >);

    mod.def_function("add_apmf",
		     "Add APMF restraint to contraints collection",
		     add_const<APMF<double> >);

    mod.def_function("add_dope",
		     "Add DOPE restraint to contraints collection",
		     add_const<DOPE<double> >);

    mod.def_function("add_dpmf",
		     "Add DPMF restraint to contraints collection",
		     add_const<DPMF<double> >);

    mod.def_function("add_ssdpmf",
		     "Add SSDPMF restraint to contraints collection",
		     add_const<SSDPMF<double> >);

    mod.def_function("add_bond",
		     "Add bond restraint to contraints collection",
		     add_const<BondConst<double> >);

    mod.def_function("add_angle",
		     "Add angle restraint to contraints collection",
		     add_const<AngleConst<double> >);

    mod.def_function("add_dihedral",
		     "Add dihedral restraint to contraints collection",
		     add_const<DihedralConst<double> >);

    mod.def_function("add_improper",
		     "Add improper restraint to contraints collection",
		     add_const<ImproperConst<double> >);

    mod.def_function("add_jcoupling","Add J-Coupling restraints to contraints collection",
		     add_const<JCoupling>);

#ifdef BUILD_SHXCONST
    mod.def_function("add_shift","Add ShiftX restraints to contraints collection",
		     add_const<ShiftConst>);
#endif
#ifdef BUILD_PECONST
    mod.def_function("add_pe","Add PE restraints to contraints collection",
		     add_const<PEConst>);
#endif
    mod.def_function("add_n","Add N restraints to contraints collection",
		     add_const<NConst>);

    mod.def_function("add_noe","Add NOE restraints to contraints collection",
		     add_const<NOEConst>);

    mod.def_function("add_menoe","Add ME NOE restraints to contraints collection",
		     add_const<MENoe<double> >);

    mod.def_function("add_vdwnoe","Add VdW NOE restraints to contraints collection",
		     add_const<VdWNoe<double> >);

    mod.def_function("add_qvdw","Add qVdW restraints to contraints collection",
		     add_const<QVdW<double> >);

    mod.def_function("add_ambnoe","Add AmbNOE restraints to contraints collection",
		     add_const<AmbNOEConst<double> >);

   mod.def_function("add_dynambnoe","Add AmbNOEDyn restraints to contraints collection",
		     add_const<AmbNOEConstDyn<double> >);

    mod.def_function("add_rosenoe","Add RoseNOE restraints to contraints collection",
		     add_const<RoseNOEConst<double> >);

    mod.def_function("add_rosenoegroup","Add RoseNOEGroup restraints to contraints collection",
		     add_const<RoseNOEGroupConst<double> >);

    mod.def_function("add_xnoe","Add XNOE restraints to contraints collection",
		     add_const<XNOEConst>);

    mod.def_function("add_s2","Add S2 restraints to contraints collection",
		     add_const<S2Const>);

    mod.def_function("add_s2rmsd","Add S2RMSD restraints to contraints collection",
		     add_const<S2RMSDConst<double> >);

    mod.def_function("add_s2mrmsd","Add S2RMSD restraints to contraints collection",
		     add_const<S2MRMSDConst<double> >);

    // adding the rdc constraints
    mod.def_function("add_rdc","Add RDC restraints to contraints collection",
		     add_const<RdcConst>);

    mod.def_function("add_xrdc","Add XRDC restraints to contraints collection",
		     add_const<XRdcConst>);

    mod.def_function("add_pos","Add position restraints to contraints collection",
		     add_const<PosConst>);


    mod.def_function("add_conymap","Add contact  map restraints to contraints collection",
		     add_const<ContMap<double> >);

    mod.def_function("add_env","Add env restraints to contraints collection",
		     add_const<EnvConst<double> >);

    mod.def_function("add_envpair","Add envpair restraints to contraints collection",
		     add_const<EnvPairConst<double> >);

    mod.def_function("add_camshift","Add CamShift restraints to contraints collection",
 		     add_const<CamShift>);

    mod.def_function("add_shiftx","Add sihftx restraints to contraints collection",
 		     add_const<ShiftXConst>);

    mod.def_function("mkapmf","",mkapmf);
    mod
      .def_const("ALL",(int)APMF<double>::ALL)
      .def_const("BB",(int)APMF<double>::BB)
      .def_const("HBOND",(int)APMF<double>::HBOND);
 

    mod.def_function("add_shx","",add_const<ShxConst>);
  }
}