/***************************************************************************
                          fragments_mod.cpp  -  description
                             -------------------
    begin                : Thu May 12 09:02:53 2005
    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 <pdb.h>
#include <zeta/class.h>
#include <zeta/zextclass.h>
#include <zeta/zobj.hpp>
#include <molecules/molecules.h>
#include <moveset/bondrotation.h>
#include <mdb.h>
#include <ff.h>
#include <moveset/bondrotation.h>
#include <forcefield/const/pmf/apmf.h>
#include <forcefield/const/base/bondconst.h>
#include <coormanager/coormanager.h>
#include <metropolis/metropolis.h>
#include <moveset/sidechainmover.h>
#include <kernel/geometry.h>
#include <mdb.h>
#include <ff.h>
#include <kernel/geometry.h>
#include <moveset/bondrotation.h>
#define NHATOMS         43
#include <forcefield/const/shiftconst/rc.h>
#undef NHATOMS
#include <algorithm/sd_fwd.h>
#include <algorithm/molalgo.h>
#include <rose/rosedb.h>
#include <rose/rosetta.h>
using namespace Almost;


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

ALMTOSTRING(Molecules);
ALMTOSTRING(MDB);

static inline vector<string> split(string s,char c=' '){
  string t;
  vector<string> r;
  int i=0;
  while(i<s.size()){
    if(s[i]!=c){ t += s[i]; ++i;}
    else { r.push_back(t);t="";i++;}
  }
  r.push_back(t);
  return r;
}  


extern void mol2pdb(const Molecules & mols, string ofile);

extern void mol2pdb(const Molecules & mols, string ofile);


class CBMC {
  struct ResidueConst {
    ResidueConst(){
      phi = psi = omega = 999;
    }

    double phi;
    double psi;
    double omega;
  };
  vector<int> N,C,CA;
  vector< vector<ResidueConst> > const_seeds;

public:
  CBMC(const Molecules & molecules,string file){
    ifstream in;
    in.open(file.c_str());
    if(!in){
      cout<<"FATAL ERROR: no such file "<<file<<endl;
      exit(1);
    }

    parse(molecules,in);
    for(int i=0;i<molecules.atom_size();i++){
      if(molecules[i].name()=="N") N.push_back(i);
      if(molecules[i].name()=="C") C.push_back(i);
      if(molecules[i].name()=="CA") CA.push_back(i);
    }
  }


  void build(const Molecules & molecules, MDB & mdb){
    //    int b = 0;
    //    int e = molecules.fragment_size();
    vector<string> seq = molecules.protein(0).sequence(1);
    



    vector<string> current_seq;
    vector<double> PHI;
    vector<double> PSI;
    //first 5

    {
      for(int i=0;i<5;i++) current_seq.push_back(seq[i]);
      Protein p("st5");
      PHI.resize(5);
      PSI.resize(5);
      for(int i=0;i<5;i++) getrama(i,PHI[i],PSI[i]);
      p.build_sequ(current_seq,mdb,"DEFAULT","DEFAULT");
      setrama(p,PHI,PSI);  
    
      EnergyOptions<double> opts;
      //      opts.solv = 0;
      {
	Molecules tmp;
	tmp.add_protein(p);
	sd(tmp,opts,mdb,10000,0.001);
	mesurerama(tmp,PHI,PSI);
      }
    }

    for(int i = 5;i<seq.size();i++){
      current_seq.push_back(seq[i]);
      PHI.resize(PHI.size()+1);
      PSI.resize(PHI.size());
      Protein p("st5");
      getrama(i,PHI[i],PSI[i]);
      p.build_sequ(current_seq,mdb,"DEFAULT","DEFAULT");
      setrama(p,PHI,PSI);  
    
      EnergyOptions<double> opts;
      //      opts.solv = 0;
      Molecules tmp;
      tmp.add_protein(p);
      sd(tmp,opts,mdb,10000,0.001);
      mesurerama(tmp,PHI,PSI);
      char buff[25];
      sprintf(buff,"cbmc_%i.pdb",i);
      mol2pdb(tmp, buff);
    }



  }
private:
  void parse(const Molecules & molecules, ifstream & in){
    const_seeds.resize(molecules.fragment_size());
    istream_iterator<string> iter(in),end;
    //Format num phi psi omega
    while(iter!=end){
      int num = atoi((*iter).c_str()); ++iter;
      if((num<1)||(num>molecules.fragment_size())){
	cout<<"FATAL ERROR: invalid fragment number!"<<endl;
	exit(-1);
      }
      --num;
      double phi = atof((*iter).c_str()); ++iter;
      double psi = atof((*iter).c_str()); ++iter;
      double omega = atof((*iter).c_str()); ++iter;
      ResidueConst rc;
      rc.phi = phi;
      rc.psi = psi;
      rc.omega = omega;
      const_seeds[num].push_back(rc);
    }
  }

  void setrama(Protein & p,vector<double> &PHI, vector<double> &PSI){
    BondRotation<double>  bond_rotation(p,1);
    vector<double*> coor;
    for(int i= p.atom_offset();
	i<p.atom_offset()+ p.atom_size();i++)
      coor.push_back(const_cast<double*>(p[i].coor()));
    

    //first
    int prev = -1;
    int curr = 0;
    int next = 1;
    int size = p.fragment_size();
    if(PSI[0]!=999)
      bond_rotation.set_dihedral(coor,N[curr],CA[curr],C[curr],N[next],PSI[0]);

    for(int i=1;i<size-2;i++){
      prev = i-1;
      curr = i;
      next = i+1;

      if(PHI[i]!=999)
	bond_rotation.set_dihedral(coor,C[prev],N[curr],CA[curr],C[curr],PHI[i]);

      if(PSI[i]!=999)
	bond_rotation.set_dihedral(coor,N[curr],CA[curr],C[curr],N[next],PSI[i]);

    }
    //last
    prev = size-2;
    curr = size-1;
    next = -1;
    if(PHI[curr]!=999)
      bond_rotation.set_dihedral(coor,C[prev],N[curr],CA[curr],C[curr],PHI[curr]);
  }

  void getrama(int i, double & phi, double & psi){
    if(const_seeds[i].size()==1){
      ResidueConst &rc = const_seeds[i][0];
      if(rc.phi!=999){
	phi = M_PI/180.0*rc.phi+5.0*(drand48()-0.5);    
      }
      else phi = 999;
      if(rc.psi!=999){
	psi = M_PI/180.0*rc.psi+5.0*(drand48()-0.5);    
      }
      else psi = 999;
    }
    else if(const_seeds[i].size()>1){
      int q = const_seeds[i].size();
      ResidueConst &rc = const_seeds[i][lrand48()%q];
      if(rc.phi!=999){
	phi = M_PI/180.0*rc.phi+5.0*(drand48()-0.5);    
      }
      else phi = 999;
      if(rc.psi!=999){
	psi = M_PI/180.0*rc.psi+5.0*(drand48()-0.5);    
      }
      else psi = 999;
    }
    else { phi =999; psi =999;}
  }


  void mesurerama(const Molecules & m, vector<double> & PHI, 
		  vector<double> & PSI){
    //0
    PSI[0] = Kernel::Geometry::dihedral(m[N[0]].coor(),
					m[CA[0]].coor(),
					m[C[0]].coor(),
					m[N[1]].coor());

    int size = m.fragment_size();
    for(int i=1;i<size-2;i++){
      PHI[i] = Kernel::Geometry::dihedral(m[C[i-1]].coor(),
					  m[N[i]].coor(),
					  m[CA[i]].coor(),
					  m[C[i]].coor());

      PSI[0] = Kernel::Geometry::dihedral(m[N[i]].coor(),
					  m[CA[i]].coor(),
					  m[C[i]].coor(),
					  m[N[i+1]].coor());
      
    }

    //last
    int i = size-1;
    PHI[i] = Kernel::Geometry::dihedral(m[C[i-1]].coor(),
					m[N[i]].coor(),
					m[CA[i]].coor(),
					m[C[i]].coor());

  }
};


class Dihe2ContactMap {
  struct ResidueConst {
    ResidueConst(){
      phi = psi = omega = 999;
    }

    double phi;
    double psi;
    double omega;
  };
  
  vector< vector<ResidueConst> > const_seeds;
  vector<ResidueConst> current_const;
  vector<int> N,CA,C;
  map<pair<int,int>, vector<double> > cm;
public:
  Dihe2ContactMap(const Molecules & molecules, const MDB & mdb, 
		  string file) {

    ifstream in;
    in.open(file.c_str());
    if(!in){
      cout<<"FATAL ERROR: no such file "<<file<<endl;
      exit(1);
    }

    parse(molecules,in);

    for(int i=0;i<molecules.atom_size();i++){
      if(molecules[i].name()=="N") N.push_back(i);
      if(molecules[i].name()=="CA") CA.push_back(i);
      if(molecules[i].name()=="C") C.push_back(i);

    }
  }


  void run(Molecules & molecules, const MDB & mdb, int steps){
    BondRotation<double>  bond_rotation(molecules.protein(0));
    EnergyOptions<double> ene_opts;
    for(int i=0;i<steps;i++){
      setngles(molecules,bond_rotation);
      
      sd<double>(molecules, 
		 ene_opts,
		 mdb,500, 0.001);
      if(steps%100){
	char buffer[256];
	sprintf(buffer,"test_%i.pdb",i);
	mol2pdb(molecules,buffer);
      }
      for(int a=0;a<CA.size();a++){
	for(int b = a+2;b<CA.size();b++){
	  pair<int,int> p(a,b);
	  double d = molecules.distance(CA[a],CA[b]);
	  cm[p].push_back(d);
	}
      }
    }

    ofstream out; out.open("CM.dat");
    map<pair<int,int>, vector<double> >::iterator iter=cm.begin(),end=cm.end();

    while(iter!=end){
      out<<iter->first.first<<" "<<iter->first.second<<" : ";
      for(int i=0;i<iter->second.size();i++)
	out<<iter->second[i]<<" ";
      out<<"\n";
      ++iter;
    }
  }
		  
private:
  void parse(const Molecules & molecules, ifstream & in){
    const_seeds.resize(molecules.fragment_size());
    istream_iterator<string> iter(in),end;
    //Format num phi psi omega
    while(iter!=end){
      int num = atoi((*iter).c_str()); ++iter;
      if((num<1)||(num>molecules.fragment_size())){
	cout<<"FATAL ERROR: invalid fragment number!"<<endl;
	exit(-1);
      }
      --num;
      double phi = atof((*iter).c_str()); ++iter;
      double psi = atof((*iter).c_str()); ++iter;
      double omega = atof((*iter).c_str()); ++iter;
      ResidueConst rc;
      rc.phi = phi;
      rc.psi = psi;
      rc.omega = omega;
      const_seeds[num].push_back(rc);
    }
  }
  
  void setngles(Molecules & molecules,BondRotation<double> &bond_rotation){
    for(int k=0;k<const_seeds.size();k++){
      ResidueConst rc;
      if(const_seeds[k].size()>0){
	int r = lrand48();
	r = r%const_seeds[k].size();
	rc = const_seeds[k][r];
	if(rc.phi!=999){
	  set_torsion2(molecules.protein(0),C[k-1],N[k],CA[k],C[k],
		       rc.phi*(M_PI/180.0),bond_rotation);
	}
	if(rc.psi!=999){
	  set_torsion2(molecules.protein(0),N[k],CA[k],C[k],N[k+1],
		       rc.psi*(M_PI/180.0),bond_rotation);
	}
      }
    }
  }
};










void dump_rdbp(const RoseDBProtein & p){
  cout<<p;
}



#define logistic(x) ((double)1.0 / ((double)1.0 + (double)exp(-(x))))

int one2index(char c){
  if(c == 'A') return 0;
  if(c == 'C') return 1;
  if(c == 'D') return 2;
  if(c == 'E') return 3;
  if(c == 'F') return 4;
  if(c == 'G') return 5;
  if(c == 'H') return 6;
  if(c == 'I') return 7;
  if(c == 'K') return 8;
  if(c == 'L') return 9;
  if(c == 'M') return 10;
  if(c == 'N') return 11;
  if(c == 'P') return 12;
  if(c == 'Q') return 13;
  if(c == 'R') return 14;
  if(c == 'S') return 15;
  if(c == 'T') return 16;
  if(c == 'V') return 17;
  if(c == 'W') return 18;
  if(c == 'Y') return 19;

  return -1;
}


void dump_fann(RoseDB & rose, string out_file){
  ofstream out;
  out.open(out_file.c_str());
  int data = 0;
  for(int i=0;i<rose.db.size();i++){

    RoseDBProtein & p = rose.db[i];

    int s = p.sequ.size();
    int end = s-25;

    for(int k = 0; k<end;k++){
      double r = drand48();
      if(r>0.005) continue;
      ++data;
      for(int q=0;q<25;q++){
	//Print

	//Input for each amino-acid
	// 20 profiles 20 for type 4 chemical-shift 1 termini
	// total (20+20+5)*25 = 1125 (!)
	for(int pos =0;pos<20;pos++){
	  out<<logistic(p.psi_blast[k+q][pos]/100.0)<<" ";
	}

	int idx = one2index(p.sequ[k+q]);
	for(int pos =0;pos<20;pos++){
	  if(pos==idx)
	    out<<1<<" ";
	  else 
	    out<<0<<" ";
	}
	
	//termini
	if(k+q==0){
	  out<<0<<" ";
	}
	else if(k+q==s-1)
	  out<<0<<" ";
	else 
	  out<<1<<" ";

	//ha
	out<<p.ha[k+q]/10.0<<" ";


	//n
	out<<p.n[k+q]/150.0<<" ";

	//ca
	out<<p.ca[k+q]/100.0<<" ";

	//cb
	out<<p.cb[k+q]/100.0<<" ";
      }
      out<<"\n";
      //Output
      for(int q=0;q<25;q++){
	char c = p.ss[k+q];
	if(c=='H'||c=='G'||c=='I')
	  out<<1<<" "<<0<<" "<<0<<" ";
	else if(c=='E'||c=='B')
	  out<<0<<" "<<1<<" "<<0<<" ";
	else 
	  out<<0<<" "<<0<<" "<<1<<" ";
      }
      out<<"\n";
    }

    cerr<<"Number of data sets: "<<data<<endl;

  }

}


void dump_psipred(RoseDB & rose, string out_file){
  ofstream out;
  out.open(out_file.c_str());
  int data = 0;
  for(int i=0;i<rose.db.size();i++){

    RoseDBProtein & p = rose.db[i];

    int s = p.sequ.size();
    int end = s;

    for(int k = 0; k<end;k++){
      double r = drand48();
      if(r>0.2) continue;
      ++data;
      for(int q=-12;q<=12;q++){
	//Print

	//Input for each amino-acid
	// 20 profiles 1 termini
	// total (20+20+5)*25 = 1125 (!)	
	if(k+q>=0&&k+q<end){
	  for(int pos =0;pos<20;pos++){
	    out<<logistic(p.psi_blast[k+q][pos]/100.0)<<" ";
	  }
	}
	else {
	  for(int pos =0;pos<20;pos++) out<<-1<<" ";
	}

	//termini
	if(k+q<0){
	  out<<0<<" ";
	}
	else if(k+q>=end)
	  out<<0<<" ";
	else 
	  out<<1<<" ";

      }
      out<<"\n";
      //Output
      //      for(int q=0;q<25;q++){
      char c = p.ss[k];
      if(c=='H'||c=='G'||c=='I')
	out<<1<<" "<<0<<" "<<0<<" ";
      else if(c=='E'||c=='B')
	out<<0<<" "<<1<<" "<<0<<" ";
      else 
	out<<0<<" "<<0<<" "<<1<<" ";
      //      }
      out<<"\n";
    }

    cerr<<"Number of data sets: "<<data<<endl;

  }

}






void dump_psipred_test(string mtxf,
		       string ss, 
		       string outf){
  vector<vector<double> > mtx;
  Utils::read_mtx(mtxf,mtx);

  
  ofstream out;
  out.open(outf.c_str());
  if(!out) throw "Unable to open file.";
  int s = ss.size();
  int end = s;
  out<<s<<" "<<25*21<<" "<<3<<"\n";
  for(int k=0;k<s;k++){
    for(int q=-12;q<=12;q++){
      if(k+q>=0&&k+q<end){
	for(int pos =0;pos<20;pos++){
	  out<<logistic(mtx[k+q][pos]/100.0)<<" ";
	}
      }
      else {
	for(int pos =0;pos<20;pos++) out<<-1<<" ";
      }
      if(k+q<0){
	out<<0<<" ";
      }
      else if(k+q>=end)
	out<<0<<" ";
      else 
	out<<1<<" ";
    }
    out<<"\n";
    //Output
    //      for(int q=0;q<25;q++){
    char c = ss[k];
    if(c=='H'||c=='G'||c=='I')
      out<<1<<" "<<0<<" "<<0<<" ";
    else if(c=='E'||c=='B')
      out<<0<<" "<<1<<" "<<0<<" ";
    else 
      out<<0<<" "<<0<<" "<<1<<" ";
    //      }
    out<<"\n";
  }
}
  




#undef logistic




//Scoring functions


// class REM {
//   //
// public:
  
//   void run();
// };

void rc_cs(string seq, const RoseDB & rosedb){
  //
  if(seq.size()<3) return;
  vector<int> n;
  vector<double> HA;
  vector<double> N;
  vector<double> CA;
  vector<double> CB;

  vector<int> n_c;
  vector<double> HA_c;
  vector<double> N_c;
  vector<double> CA_c;
  vector<double> CB_c;


  int size = seq.size()-1;
  {
    n.resize(size);
    HA.resize(size);
    N.resize(size);
    CA.resize(size);
    CB.resize(size);

    n_c.resize(size);
    HA_c.resize(size);
    N_c.resize(size);
    CA_c.resize(size);
    CB_c.resize(size);
  }

  for(int p=0;p<rosedb.size();p++){
    int size2 = rosedb.db[p].size(); size2 = size2-1;
    //    cout<<"\r Protein "<<p+1<<" of "<<rosedb.size();
    for(int f2 = 0;f2<size2; f2++){
      string f2_seq = string(rosedb.db[p].sequ.begin()+f2,
			     rosedb.db[p].sequ.begin()+f2+3);
      string f2_ss = string(rosedb.db[p].ss.begin()+f2,rosedb.db[p].ss.begin()+f2+3);
      
      bool is_coil = 1;
      for(int qq=0;qq<3;qq++){
	if(f2_ss[qq]=='E'||
	   f2_ss[qq]=='B'||
	   f2_ss[qq]=='H'||
	   f2_ss[qq]=='G'||
	   f2_ss[qq]=='I')
	  {
	    is_coil = 0;
	    break;
	  }
      }
      for(int f1 = 0;f1<size;f1++){
	string f1_seq = string(seq.begin()+f1,
			       seq.begin()+f1+3);

	if(f1_seq==f2_seq){
	  ++n[f1];
	  HA[f1] = HA[f1] +  rosedb.db[p].ha[f2+1];
	  N[f1] = N[f1] +  rosedb.db[p].n[f2+1];
	  CA[f1] = CA[f1] +  rosedb.db[p].ca[f2+1];
	  CB[f1] = CB[f1] +  rosedb.db[p].cb[f2+1];
	  if(is_coil){
	    ++n_c[f1];
	    HA_c[f1] = HA_c[f1] +  rosedb.db[p].ha[f2+1];
	    N_c[f1] = N_c[f1] +  rosedb.db[p].n[f2+1];
	    CA_c[f1] = CA_c[f1] +  rosedb.db[p].ca[f2+1];
	    CB_c[f1] = CB_c[f1] +  rosedb.db[p].cb[f2+1];	    
	  }
	}
      }
    }
  }
  cout<<"\n";
  char buff[1024];
  sprintf(buff,"%10s | %10s | %10s | %10s | %10s | %10s | %10s | %10s | %10s | %10s | %10s | %10s | %10s | %10s \n","SEQU NUM","AA",
	  "HA RC ALL","HA RC COIL","HA RC DB", 
	  "N RC ALL","N RC COIL","N DB", 
	  "CA RC ALL","CA RC COIL","CA DB", 
	  "C RC ALL","C RC COIL","C DB");
  cout<<buff;
  int len = strlen(buff);
  for(int qq=0;qq<len;qq++)
    cout<<'-';
  cout<<"\n";

  for(int i=0;i<HA.size();i++){
    int jj = Utils::toinda(seq[i+1]);
//     cout<<seq[i+1]<<" "
// 	<<HA[i]/n[i]<<" "<<HA_c[i]/n_c[i]<<" ("<<HARC[jj]<<") "
// 	<<N[i]/n[i]<<" "<<N_c[i]/n_c[i]<<" ("<<N15RC[jj]<<") "
// 	<<CA[i]/n[i]<<" "<<CA_c[i]/n_c[i]<<" ("<<CARC[jj]<<") "
// 	<<CB[i]/n[i]<<" "<<CB_c[i]/n_c[i]<<" ("<<CBRC[jj]<<") "
// 	<<"\n";

  sprintf(buff,"%10i | %10c | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f | %10.2f\n",
	  i+2,
	  seq[i+1],
	  HA[i]/n[i],HA_c[i]/n_c[i],HARC[jj],
	  N[i]/n[i],N_c[i]/n_c[i],N15RC[jj],
	  CA[i]/n[i],CA_c[i]/n_c[i],CARC[jj],
	  CB[i]/n[i],CB_c[i]/n_c[i],CBRC[jj]);
  cout<<buff;
  }

}

template<>
inline string to_string(const CBMC &){
  return "<CBMC>";
}

template<>
inline string to_string(const Dihe2ContactMap &){
  return "<Dihe2ContactMap>";
}

template<>
inline string to_string(const Rosetta &){
  return "<Rosetta>";
}

template<>
inline string to_string(const RoseDBProtein & p){
  return "<RoseDBProtein>";
}

template<>
inline string to_string(const RoseDB& p){
  return "<RoseDB>";
}


extern "C" {
  void init_fragments(){
    //declarations here

    Module mod = Module("fragments","Fragment replacement tools");

    Class<CBMC,ArgList2<const Molecules &, string> >(mod.self(),"cbmc")
      .def_method("build",&CBMC::build)
      ;

    Class<Dihe2ContactMap,ArgList3<const Molecules &, const MDB &,
      string> >(mod.self(),"dihe2cm")
      .def_method("run",&Dihe2ContactMap::run);

    Class<Rosetta,
      ArgList5<string,string,string,int,double>
      >(mod.self(),"rosetta")
      .def_method("stone",&Rosetta::stone) //OK
      .def_method("shx",&Rosetta::shx) //OK (compiles)
      .def_method("shx_talos",&Rosetta::shx_talos) //OK (comp)
      //      .def_method("talos",&Rosetta::talos) todo
      .def_method("prf",&Rosetta::prf) //OK
      .def_method("prf_monitor",&Rosetta::prf_monitor) //OK
      .def_method("best",&Rosetta::best) //OK
      .def_method("shx_prf",&Rosetta::shx_prf)
      .def_method("shx_prf_talos",&Rosetta::shx_prf_talos)
      .def_method("reref_ha",&Rosetta::reref_ha)
      .def_method("reref_h",&Rosetta::reref_h)
      .def_method("reref_n",&Rosetta::reref_n)
      .def_method("reref_ca",&Rosetta::reref_ca)
      .def_method("reref_cb",&Rosetta::reref_cb)
      .def_method("reref_c",&Rosetta::reref_c)
      .def_method("topos_prf",&Rosetta::topos_prf)
      .def_attribute("use_HA",&Rosetta::use_HA,"Undocumented")
      .def_attribute("use_H",&Rosetta::use_H,"Undocumented")
      .def_attribute("use_N",&Rosetta::use_N,"Undocumented")
      .def_attribute("use_CA",&Rosetta::use_CA,"Undocumented")
      .def_attribute("use_CB",&Rosetta::use_CB,"Undocumented")
      .def_attribute("use_C",&Rosetta::use_C,"Undocumented")
      .def_attribute("C_ref",&Rosetta::C_ref,"Undocumented")
      .def_attribute("N_ref",&Rosetta::N_ref,"Undocumented")
      .def_attribute("H_ref",&Rosetta::H_ref,"Undocumented")
      .def_attribute("keep",&Rosetta::keep,"Undocumented")
      ;
      

    Class<RoseDBProtein>(mod.self(),"rosedbprotein");
    Class<RoseDB>(mod.self(),"rosedb")
      .def_method("add_protein",&RoseDB::add_protein)
      .def_method("from_files",&RoseDB::from_files)
      .def_method("from_file",&RoseDB::from_file)
      .def_method("from_file_lists",&RoseDB::from_file_lists)
      .def_method("dump",&RoseDB::dump)
      ;

    mod.def_function("dump","dump",&dump_rdbp);
    mod.def_function("rose_db_protein_from_files","Read roses",&rose_db_protein_from_files);

    mod.def_function("dump_fann","Generates fann trainig file.",&dump_fann);
    mod.def_function("dump_psipred","Generates fann trainig file.",&dump_psipred);
    mod.def_function("dump_psipred_test","Generates fann testing file.",&dump_psipred_test);

    mod.def_function("rc_cs","Computer random coil chemical shifts.",&rc_cs);

    mod
      .def_const("SHORT",(int)Rosetta::SHORT)      
      .def_const("LONG",(int)Rosetta::LONG)
      ;      
  }
}