/***************************************************************************
                          mcf_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 <module.h>
#include <class.h>
#include <zextclass.h>
#include <zobj.hpp>

#include <almost.h>
#include <coor.h>
#include <mdb.h>
#include <molecules.h>
#include <sstream>
#include <forcefield/go/defgoforcefield.h>
#include <forcefield/go/defigoforcefield.h>
//#include <forcefield/c19.h>
#include <mcf/mcfoptions.h>
#include <kernel/rgyr.h>
#include <mcf/mcf.h>
#include <metropolis/metropolis.h>

using namespace Almost;


typedef DynaImpl<double,MCFOptions<double> > * 
(MCF<double>::*mcf_factory_19)(const Molecules & molecules,
			       const MCFOptions<double> & options,
			       const MDB & mdb);


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



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



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





template<typename FF, int i>
struct OperatorHelperMCFSolv;

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

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

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

template<int i>
struct OperatorHelperMCFUb;

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

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

template<typename FF, int i>
struct OperatorHelperMCFElec;

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

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



template<class FF, class MCFOptionsType,  int TEMP>
DynaLogStream & operator<<(DynaLogStream &log,  
			  const MCFData<FF,MCFOptionsType,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,
	  OperatorHelperMCFElec<FF,FF::ELEC>::helper(data),
	  data.ff_data.vdw_energy,
	  OperatorHelperMCFSolv<FF,FF::SOLV>::helper(data),
	  OperatorHelperMCFUb<FF::UB>::helper(data));
  log.stream()<<buff;
  return log;
}




template<class FF, class MCFOptionsType,  int TEMP>
DynaDataStream & operator<<(DynaDataStream & dat, 
			   const MCFData<FF,MCFOptionsType,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<<" "
	      <<OperatorHelperMCFSolv<FF,FF::SOLV>::helper(data)<<" "
	      <<data.ff_data.vdw_energy<<" "
	      <<OperatorHelperMCFSolv<FF,FF::SOLV>::helper(data)<<" "
	      <<OperatorHelperMCFUb<FF::UB>::helper(data)<<" "
	      <<endl;
  return dat;
}



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

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

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

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


  return opts;
}

MCFOptions<double> c19_options_mcf(){
  return MCFOptions<double>(MCFOptions<double>::C19);
}

MCFOptions<double> c22_options_mcf(){
  return MCFOptions<double>(MCFOptions<double>::C22);
}

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

    Module mod = Module("mcf");






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

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

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

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


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

  }
}