/***************************************************************************
                          dyna_mod.cpp  -  description
                             -------------------
    begin                : Mon Jan 12 05:20:12 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 <almost.h>
#include <coor.h>
#include <mdb.h>
#include <molecules/molecules.h>
#include <sstream>
#include <forcefield/go/defgoforcefield.h>
#include <forcefield/go/defigoforcefield.h>
//#include <forcefield/c19.h>
#include <dyna/dynaoptions.h>
#include <kernel/rgyr.h>
#include <dyna/dyna.h>
#include <metropolis/metropolis.h>

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

ALMTOSTRING(MoveSet<double>);
ALMTOSTRING(ConstraintCollection);
// struct DynaTraits { 
//   typedef floattype       float_type;  
//   typedef coorman         CoorManagerType;
//   typedef coormanopts     CoorManOpts;
//   typedef forcefield      ForceFieldType;
//   typedef forcefieldopts  FFOptions;
//   typedef movesettype     MoveSetType;
//   typedef metropolistype  MetropolisType;
//   typedef datatype        DataType;
//   typedef options         Options;
// };



typedef DynaData<DefGoForceField<double>, 
		 DynaGoOptions<double>, 
		 ENERGY> GoData;

typedef DynaTraits<double,
		   CoorManager<double>,
		   CoorManagerOptions<double>,
		   DefGoForceField<double>,
		   DefGoOptions<double>,
		   MoveSet<double>,
		   Metropolis<double>,
		   GoData,
		   DynaGoOptions<double> > GoTraits;

//spec for go
namespace Almost {
  template<>
  void ForceFieldFactory::create(DefGoForceField<double> ** force_field,
				 const Molecules & molecules,
				 const DynaGoOptions<double> &options,
				 const MDB & mdb,
				 ConstraintCollection & constraints,
				 const string & ff_pr){
    logMsg(ff_pr,
	   "Initializing "+ DefGoOptions<double>::ff_name()+" force field");
  
    *force_field = 
      new DefGoForceField<double>(molecules,
				  options.ff_options(),
				  mdb,
				  constraints);
    logMsg(ff_pr,"Done\n");
  }

}
typedef DynaData<DefIGoForceField<double>,
		 DynaIGoOptions<double>, 
		 ENERGY> IGoData;

typedef DynaTraits<double,
		   CoorManager<double>,
		   CoorManagerOptions<double>,
		   DefIGoForceField<double>,
		   DefIGoOptions<double>,
		   MoveSet<double>,
		   Metropolis<double>,
		   IGoData,
		   DynaIGoOptions<double> > IGoTraits;

namespace Almost {
  template<>
  void ForceFieldFactory::create(DefIGoForceField<double> ** force_field,
				 const Molecules & molecules,
				 const DynaIGoOptions<double> &options,
				 const MDB & mdb,
				 ConstraintCollection & constraints,
				 const string & ff_pr){
    logMsg(ff_pr,
	   "Initializing "+ DefIGoOptions<double>::ff_name()+" force field");
  
    *force_field = 
      new DefIGoForceField<double>(molecules,
				   options.ff_options(),
				   mdb,
				   constraints);
    logMsg(ff_pr,"Done\n");
  }

}		 
  
template<>
inline string to_string(const DynaGoOptions<double> & opt){
  stringstream s;
  s<<opt;
  return s.str();
}

template<>
inline string to_string(const DynaIGoOptions<double> & opt){
  stringstream s;
  s<<opt;
  return s.str();
}


typedef DynaImpl<double,DynaOptions<double> > * 
(Dyna<double>::*mc_factory_19)(const Molecules & molecules,
			       const DynaOptions<double> & options,
			       const MDB & mdb);



#if (__GNUC__ >= 3)
template<>
#endif
map<int,mc_factory_19> Dyna<double>::factory
#if (__GNUC__ >= 3)
= map<int,mc_factory_19>();
#endif
;



template<>
inline string to_string(const DynaOptions<double> & opt){
  stringstream s;
  s<<opt;
  return s.str();
}


template<>
inline string to_string(const DynaImplementation<GoTraits,GoTraits::Options> &){
  return "<DynaGo>";
}

template<>
inline string to_string(const DynaImplementation<IGoTraits,IGoTraits::Options> &){
  return "<DynaIGo>";
}

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


//operators for GO

template<typename float_type>
DynaLogStream & operator<<(DynaLogStream &log, 
			   const DynaData<DefGoForceField<float_type>, 
			   DynaGoOptions<float_type>, 
			   ENERGY> &data){
  char buff[256];
  string prmpt=Almost::DynaStatPr;
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s | %-10s\n","step","energy","rmsd","rgyr","const");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"---------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10i   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  data.step,
	  data.current_energy,
	  data.rmsd,
	  data.rgyr,
	  data.ff_data.const_energy
	  );
  log.stream()<<buff;
  prmpt=Almost::EnerStatPr; 
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s\n","step","native","non native","Q");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"----------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10i   %-10i   %-10i   %-10.2f\n\n",
	  data.step,
	  data.ff_data.n_native,data.ff_data.n_non_native,
	  (float_type)(data.ff_data.n_native)/(float_type)data.ff_data.n_cont_max);
  log.stream()<<buff;
  return log;
}  

template<typename float_type>
DynaDataStream & operator<<(DynaDataStream &dat, 
			    const DynaData<DefGoForceField<float_type>, 
			    DynaGoOptions<float_type>, 
			    ENERGY> &data){
  dat.stream()<<data.step<<" "<<data.current_energy<<" "
	      <<data.rmsd<<" "<<data.rgyr<<" "<<data.ff_data.const_energy
	      <<" "<<data.ff_data.n_native<<" "
	      <<data.ff_data.n_non_native<<" "
	      <<(float_type)(data.ff_data.n_native)/(float_type)data.ff_data.n_cont_max<<"\n";
  return dat;
}  




template<typename FF, int i>
struct OperatorHelperDynaSolv;

template<typename FF>
struct OperatorHelperDynaSolv<FF , 0> {
  template<class DynaOptionsType>
  static typename FF::FloatType helper(const DynaOptionsType  & data){
    //    cout<<"NO SOLV"<<endl;
    return 0;
  }
};

template<class FF>
struct OperatorHelperDynaSolv<FF, 1> {
  template<typename DynaDataType>
  static typename FF::FloatType helper(const DynaDataType & data){
    //    cout<<"SOLV"<<endl;
    return data.ff_data.solv_energy;
  }
};

template<class FF>
struct OperatorHelperDynaSolv<FF, 2> {
  template<typename DynaDataType>
  static typename FF::FloatType helper(const DynaDataType & data){
    //    cout<<"SOLV"<<endl;
    return data.ff_data.solv_energy;
  }
};

template<int i>
struct OperatorHelperDynaUb;

template<>
struct OperatorHelperDynaUb<0> {
  template<class FF, class DynaOptionsType,  int TEMP>
  static typename FF::FloatType helper(const DynaData<FF,DynaOptionsType,TEMP>  & data){
    //    cout<<"NO UB"<<endl;
    return 0;
  }
};

template<>
struct OperatorHelperDynaUb<1> {
  template<class FF, class DynaOptionsType,  int TEMP>
  static typename FF::FloatType helper(const DynaData<FF,DynaOptionsType,TEMP>  & data){
    //    cout<<"UB"<<endl;
    return data.ff_data.ub_energy;
  }
};
 

template<typename FF, int i>
struct OperatorHelperDynaElec;

template<typename FF>
struct OperatorHelperDynaElec<FF , 0> {
  template<class DynaOptionsType>
  static typename FF::FloatType helper(const DynaOptionsType  & data){
    //    cout<<"NO ELEC"<<endl;
    return 0;
  }
};

template<class FF>
struct OperatorHelperDynaElec<FF, 1> {
  template<typename DynaDataType>
  static typename FF::FloatType helper(const DynaDataType & data){
    //    cout<<"ELEC"<<endl;
    return data.ff_data.elec_energy;
  }
};



template<class FF, class DynaOptionsType,  int TEMP>
DynaLogStream & operator<<(DynaLogStream &log,  
			   const DynaData<FF,DynaOptionsType,TEMP> & data){

  char buff[256];
  string prmpt=Almost::DynaStatPr;
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s | %-10s\n","step","energy","rmsd","rgyr","const");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"---------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10i   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  data.step,
	  data.current_energy,
	  data.rmsd, 
	  data.rgyr,
	  data.ff_data.const_energy
	  );
  log.stream()<<buff;
  prmpt=Almost::InternalPr;
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s | %-10s\n","step",
	  "bond","angle","dihe","imph");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"--------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10i   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  data.step,
	  data.ff_data.bond_energy,
	  data.ff_data.angle_energy,
	  data.ff_data.dihe_energy,
	  data.ff_data.imph_energy);
  log.stream()<<buff;
  prmpt=Almost::NonBondPr;
  log.stream()<<prmpt; 
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s | %-10s\n","step",
	  "elec","vdw","solv","ub");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"--------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10i   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  data.step,
	  OperatorHelperDynaElec<FF,FF::ELEC>::helper(data),
	  data.ff_data.vdw_energy,
	  OperatorHelperDynaSolv<FF,FF::SOLV>::helper(data),
	  OperatorHelperDynaUb<FF::UB>::helper(data));
  log.stream()<<buff;
  return log;
}




template<class FF, class DynaOptionsType,  int TEMP>
DynaDataStream & operator<<(DynaDataStream & dat, 
			    const DynaData<FF,DynaOptionsType,TEMP> & data){
  dat.stream()<<data.step<<"  "
	      <<data.current_energy<<" "
	      <<data.rmsd<<" "
	      <<data.rgyr<<" "
	      <<data.ff_data.const_energy<<" "
	      <<data.ff_data.bond_energy<<" "
	      <<data.ff_data.angle_energy<<" "
	      <<data.ff_data.dihe_energy<<" "
	      <<data.ff_data.imph_energy<<" "
	      <<OperatorHelperDynaElec<FF,FF::ELEC>::helper(data)<<" "
	      <<data.ff_data.vdw_energy<<" "
	      <<OperatorHelperDynaSolv<FF,FF::SOLV>::helper(data)<<" "
	      <<OperatorHelperDynaUb<FF::UB>::helper(data)<<" "
	      <<endl;
  return dat;
}


//template<typename float_type>
template<>
DynaLogStream & operator<< <DefIGoForceField<double>,
			    DynaIGoOptions<double>,
			    ENERGY> 
(DynaLogStream &log, 
 const DynaData<DefIGoForceField<double>, 
 DynaIGoOptions<double>, 
 ENERGY> &data){
  char buff[256];
  string prmpt=Almost::DynaStatPr;
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s | %-10s\n","step","energy","rmsd","rgyr","const");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"---------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10i   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  data.step,
	  data.current_energy,
	  data.rmsd,
	  data.rgyr,
	  data.ff_data.const_energy
	  );
  log.stream()<<buff;
  prmpt=Almost::EnerStatPr; 
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s\n","step","native","non native","Q");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"----------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10i   %-10i   %-10i   %-10.2f\n\n",
	  data.step,
	  data.ff_data.n_native,data.ff_data.n_non_native,
	  (double)(data.ff_data.n_native)/(double)data.ff_data.n_cont_max);
  log.stream()<<buff;
  return log;
}  

//template<typename float_type>
template<>
DynaDataStream & operator<<(DynaDataStream &dat, 
			    const DynaData<DefIGoForceField<double>, 
			    DynaIGoOptions<double>, 
			    ENERGY> &data){
  dat.stream()<<data.step<<" "<<data.current_energy<<" "
	      <<data.rmsd<<" "<<data.rgyr<<" "<<data.ff_data.const_energy
	      <<" "<<data.ff_data.n_native<<" "
	      <<data.ff_data.n_non_native<<" "
	      <<(double)(data.ff_data.n_native)/(double)data.ff_data.n_cont_max<<"\n";
  return dat;
}  


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

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

template<typename DynaType>
DynaType const_dyna(MoveSet<double> & ms, ConstraintCollection & cc){
  return DynaType(ms,cc);
}

DynaOptions<double> c19_defaults__(int FF){
  DynaOptions<double> opts(DynaOptions<double>::C19);
  if(FF==DynaOptions<double>::EEF1){
    opts.elec = DynaOptions<double>::RDIE;
    opts. elec_cutoff = DynaOptions<double>::SWITCH;
    opts.vdw = DynaOptions<double>::LJ;
    opts.vdw_cutoff = DynaOptions<double>::SWITCH;
    opts.eps = 1.0;
    opts.solv = DynaOptions<double>::EEF1;
    opts.cut_on = 7.0;
    opts.cut_off = 9.0;
    opts.cut_nb = 10.0;
  }
  else if(FF!=DynaOptions<double>::SASA)
    opts.solv = DynaOptions<double>::NONE;


  return opts;
}

DynaOptions<double> c19_options(){
  return DynaOptions<double>(DynaOptions<double>::C19);
}

DynaOptions<double> c22_options(){
  return DynaOptions<double>(DynaOptions<double>::C22);
}

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

    Module mod = Module("dyna","Monte Carlo simulations");


    Class<DynaGoOptions<double> >(mod.self(),"go_options")
      .def_attribute("e_native",&DynaGoOptions<double>::e_native,
		     "Undocumented")
      .def_attribute("e_non_native",&DynaGoOptions<double>::e_non_native,
		     "Undocumented")
      .def_attribute("alpha",&DynaGoOptions<double>::alpha,
		     "Undocumented")
      .def_attribute("lambda",&DynaGoOptions<double>::lambda,"Undocumented")
      .def_attribute("ignore_mode",&DynaGoOptions<double>::ignore_mode,"Undocumented")
      .def_attribute("native_map",&DynaGoOptions<double>::native_map,"Undocumented")
      .def_attribute("trj",&DynaGoOptions<double>::trj,"Undocumented")
      .def_attribute("rst",&DynaGoOptions<double>::rst,"Undocumented")
      .def_attribute("log",&DynaGoOptions<double>::log,"Undocumented")
      .def_attribute("dat",&DynaGoOptions<double>::dat,"Undocumented")
      .def_attribute("steps",&DynaGoOptions<double>::steps,"Undocumented")
      .def_attribute("nprint",&DynaGoOptions<double>::nprint,"Undocumented")
      .def_attribute("nsave",&DynaGoOptions<double>::nsave,"Undocumented")
      .def_attribute("temp",&DynaGoOptions<double>::temp,"Undocumented")
      .def_attribute("seed",&DynaGoOptions<double>::seed,"Undocumented")
      .def_attribute("selection",&DynaGoOptions<double>::selection,"Undocumented")
      .def_attribute("save_fitted",&DynaGoOptions<double>::save_fitted,"Undocumented");


    Class<DynaIGoOptions<double> >(mod.self(),"vdw_go_options")
      .def_attribute("nn_factor",&DynaIGoOptions<double>::nn_factor,"Undocumented")
      .def_attribute("alpha",&DynaIGoOptions<double>::alpha,"Undocumented")
      .def_attribute("lambda",&DynaIGoOptions<double>::lambda,"Undocumented")
      .def_attribute("ignore_mode",&DynaIGoOptions<double>::ignore_mode,"Undocumented")
      .def_attribute("native_map",&DynaIGoOptions<double>::native_map,"Undocumented")
      .def_attribute("trj",&DynaIGoOptions<double>::trj,"Undocumented")
      .def_attribute("rst",&DynaIGoOptions<double>::rst,"Undocumented")
      .def_attribute("log",&DynaIGoOptions<double>::log,"Undocumented")
      .def_attribute("dat",&DynaIGoOptions<double>::dat,"Undocumented")
      .def_attribute("steps",&DynaIGoOptions<double>::steps,"Undocumented")
      .def_attribute("nprint",&DynaIGoOptions<double>::nprint,"Undocumented")
      .def_attribute("nsave",&DynaIGoOptions<double>::nsave,"Undocumented")
      .def_attribute("temp",&DynaIGoOptions<double>::temp,"Undocumented")
      .def_attribute("seed",&DynaIGoOptions<double>::seed,"Undocumented")
      .def_attribute("selection",&DynaIGoOptions<double>::selection,"Undocumented")
      .def_attribute("save_fitted",&DynaIGoOptions<double>::save_fitted,"Undocumented");



    Class<DynaImplementation<GoTraits,
      GoTraits::Options> >(mod.self(),"dyna_go")
      .def_method("run",
		  &DynaImplementation<GoTraits,GoTraits::Options>::run)
      .def_method("run_from_mol",
		  &DynaImplementation<GoTraits,GoTraits::Options>::run_from_mol)
      .def_method("cont",&DynaImplementation<GoTraits,GoTraits::Options>::cont)
      .def_method("restart",
		  &DynaImplementation<GoTraits,GoTraits::Options>::restart)
      ;


    Class<DynaImplementation<IGoTraits,
      IGoTraits::Options> >(mod.self(),"dyna_vdw_go")
      .def_method("run",
		  &DynaImplementation<IGoTraits,IGoTraits::Options>::run)
      .def_method("run_from_mol",
		  &DynaImplementation<IGoTraits,IGoTraits::Options>::run_from_mol)
      .def_method("cont",&DynaImplementation<IGoTraits,IGoTraits::Options>::cont)
      .def_method("restart",
		  &DynaImplementation<IGoTraits,IGoTraits::Options>::restart)
      ;


    Class<DynaOptions<double> >(mod.self(),"options")
      .def_attribute("kind",&DynaOptions<double>::kind,"Undocumented")
      .def_attribute("elec",&DynaOptions<double>::elec,"Undocumented")
      .def_attribute("elec_cutoff",&DynaOptions<double>::elec_cutoff,"Undocumented")
      .def_attribute("vdw",&DynaOptions<double>::vdw,"Undocumented")
      .def_attribute("vdw_cutoff",&DynaOptions<double>::vdw_cutoff,"Undocumented")
      .def_attribute("solv",&DynaOptions<double>::solv,"Undocumented")
      .def_attribute("solv_ignore_h",&DynaOptions<double>::solv_ignore_h,"Undocumented")
      .def_attribute("cut_on",&DynaOptions<double>::cut_on,"Undocumented")
      .def_attribute("cut_off",&DynaOptions<double>::cut_off,"Undocumented")
      .def_attribute("e_zero",&DynaOptions<double>::e_zero,"Undocumented")
      .def_attribute("e_14",&DynaOptions<double>::e_14,"Undocumented")
      .def_attribute("eps",&DynaOptions<double>::eps,"Undocumented")
      .def_attribute("r_water",&DynaOptions<double>::r_water,"Undocumented")
      .def_attribute("vect",&DynaOptions<double>::vect,"Undocumented")
      .def_attribute("trj",&DynaOptions<double>::trj,"Undocumented")
      .def_attribute("rst",&DynaOptions<double>::rst,"Undocumented")
      .def_attribute("log",&DynaOptions<double>::log,"Undocumented")
      .def_attribute("dat",&DynaOptions<double>::dat,"Undocumented")
      .def_attribute("steps",&DynaOptions<double>::steps,"Undocumented")
      .def_attribute("nprint",&DynaOptions<double>::nprint,"Undocumented")
      .def_attribute("nsave",&DynaOptions<double>::nsave,"Undocumented")
      .def_attribute("temp",&DynaOptions<double>::temp,"Undocumented")
      .def_attribute("seed",&DynaOptions<double>::seed,"Undocumented")
      .def_attribute("selection",&DynaOptions<double>::selection,"Undocumented")
      .def_attribute("save_fitted",&DynaOptions<double>::save_fitted,"Undocumented");
      

    Class<Dyna<double>,ArgList1<MoveSet<double> & > >(mod.self(),"dyna")
      .def_method("run",
		  &Dyna<double>::run)
      .def_method("run_from_mol",
		  &Dyna<double>::run_from_mol)
      .def_method("cont",&Dyna<double>::cont)
      .def_method("restart",
		  &Dyna<double>::restart)
      ;

    mod.def_function("const_dyna","Run a constrained MC simulation",
		     const_dyna<Dyna<double> >);

    mod
      .def_const("C19",(int)DynaOptions<double>::C19)
      .def_const("C22",(int)DynaOptions<double>::C22)
      .def_const("NONE",(int)DynaOptions<double>::NONE)
      .def_const("SASA",(int)DynaOptions<double>::SASA)
      .def_const("EEF1",(int)DynaOptions<double>::EEF1)
      ;


    mod
      .def_function("c19_defaults","Return options with right defaults",c19_defaults__)
      .def_function("c19_options","Return options with right defaults",c19_options)
      .def_function("c22_options","Return options with right defaults",c22_options);

  }
}