/***************************************************************************
                          mbmd_common.h  -  description
                             -------------------
    begin                : Sun Mar 12 22:54:23 2006
    copyright            : (C) 2004 by Cavalli Andrea
    author               : $Author$
    date                 : $Date$
    id                   : $Id$
    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.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef __MBMD_COMMON__
#define __MBMD_COMMON__

#include <almost.h>
#include <coor.h>
#include <mdb.h>
#include <molecules.h>
#include <kernel/rgyr.h>
#include <mbmd/mbmd.h>
#include <sstream>
#include <ffdoc.h>
#include <rundoc.h>
using namespace Almost;

template<typename float_type>
inline string to_string(const MBMDOptions<float_type> & c19md_opt){
  stringstream s;
  s<<c19md_opt;
  return s.str();
}


template<typename float_type>
inline string to_string(const MBMD<float_type> &){
  return "<MBMD>";
}


template<typename float_type> 
MBMDOptions<float_type> c19_md_options(){
  return MBMDOptions<float_type>(MBMDOptions<float_type>::C19);
}

template<typename float_type> 
MBMDOptions<float_type> c22_md_options(){
  return MBMDOptions<float_type>(MBMDOptions<float_type>::C22);
}


template<typename float_type> 
MBMDOptions<float_type> c19_defaults(int FF, int algo){
  MBMDOptions<float_type> opts;
  if(FF==MBMDOptions<float_type>::EEF1){
    opts.elec = MBMDOptions<float_type>::RDIE;
    opts. elec_cutoff = MBMDOptions<float_type>::SWITCH;
    opts.vdw = MBMDOptions<float_type>::LJ;
    opts.vdw_cutoff = MBMDOptions<float_type>::SWITCH;
    opts.eps = 1.0;
    opts.solv = MBMDOptions<float_type>::EEF1;
    opts.cut_on = 7.0;
    opts.cut_off = 9.0;
    opts.cut_nb = 10.0;
  }
  else if(FF!=MBMDOptions<float_type>::SASA)
    opts.solv = MBMDOptions<float_type>::NONE;

  if(algo==MBMDOptions<float_type>::LANGEVIN){
    opts.algorithm = MBMDOptions<float_type>::LANGEVIN;
  }
  else
    opts.algorithm = MBMDOptions<float_type>::BERENDSEN;

  return opts;
}

template<typename DynaType>
DynaType const_mbmd(ConstraintCollection & cc){
  return DynaType(cc);
}


template<int i>
struct OperatorHelperElec;

template<>
struct OperatorHelperElec<0> {
  template<typename FF, typename MBMDOptionsType>
  static typename FF::FloatType helper(MDImplData<FF,MBMDOptionsType>  & data){
    //    cout<<"NO ELEC"<<endl;
    return 0;
  }

//   template<typename FF, typename SMBMDOptionsType>
//   static typename FF::FloatType helper(SMDImplData<FF,SMBMDOptionsType>  & data){
//     //    cout<<"NO ELEC"<<endl;
//     return 0;
//   }

};

template<>
struct OperatorHelperElec<1> {
  template<typename FF, typename MBMDOptionsType>
  static typename FF::FloatType helper(MDImplData<FF, MBMDOptionsType>  & data){
    //    cout<<"ELEC"<<endl;
    return data.ff_data.elec_energy;
  }
//   template<typename FF, typename SMBMDOptionsType>
//   static typename FF::FloatType helper(SMDImplData<FF, SMBMDOptionsType>  & data){
//     //    cout<<"ELEC"<<endl;
//     return data.ff_data.elec_energy;
//   }

};

template<int i>
struct OperatorHelperSolv;

template<>
struct OperatorHelperSolv<0> {
  template<typename FF, typename MBMDOptionsType>
  static typename FF::FloatType helper(MDImplData<FF,MBMDOptionsType>  & data){
    //    cout<<"NO SOLV"<<endl;
    return 0;
  }

//   template<typename FF, typename SMBMDOptionsType>
//   static typename FF::FloatType helper(SMDImplData<FF,SMBMDOptionsType>  & data){
//     //    cout<<"NO SOLV"<<endl;
//     return 0;
//   }

};

template<>
struct OperatorHelperSolv<1> {
  template<typename FF, typename MBMDOptionsType>
  static typename FF::FloatType helper(MDImplData<FF, MBMDOptionsType>  & data){
    //    cout<<"SOLV"<<endl;
    return data.ff_data.solv_energy;
  }
//   template<typename FF, typename SMBMDOptionsType>
//   static typename FF::FloatType helper(SMDImplData<FF, SMBMDOptionsType>  & data){
//     //    cout<<"SOLV"<<endl;
//     return data.ff_data.solv_energy;
//   }

};

template<>
struct OperatorHelperSolv<2> {
  template<typename FF, typename MBMDOptionsType>
  static typename FF::FloatType helper(MDImplData<FF, MBMDOptionsType>  & data){
    //    cout<<"SOLV"<<endl;
    return data.ff_data.solv_energy;
  }
//   template<typename FF, typename SMBMDOptionsType>
//   static typename FF::FloatType helper(SMBMDImplData<FF, SMBMDOptionsType>  & data){
//     //    cout<<"SOLV"<<endl;
//     return data.ff_data.solv_energy;
//   }

};

template<int i>
struct OperatorHelperUb;

template<>
struct OperatorHelperUb<0> {
  template<typename FF, typename MBMDOptionsType>
  static typename FF::FloatType helper(MDImplData<FF, MBMDOptionsType>  & data){
    //    cout<<"NO UB"<<endl;
    return 0;
  }

//   template<typename FF, typename SMBMDOptionsType>
//   static typename FF::FloatType helper(SMDImplData<FF, SMBMDOptionsType>  & data){
//     //    cout<<"NO UB"<<endl;
//     return 0;
//   }
};

template<>
struct OperatorHelperUb<1> {
  template<typename FF, typename MBMDOptionsType>
  static typename FF::FloatType helper(MDImplData<FF, MBMDOptionsType>  & data){
    //    cout<<"UB"<<endl;
    return data.ff_data.ub_energy;
  }

//   template<typename FF, typename SMBMDOptionsType>
//   static typename FF::FloatType helper(SMDImplData<FF, SMBMDOptionsType>  & data){
//     //    cout<<"UB"<<endl;
//     return data.ff_data.ub_energy;
//   }
};


template<typename FF, typename MBMDOptionsType>
DynaLogStream & operator<<(DynaLogStream &log,  
			   MDImplData<FF, MBMDOptionsType>  & data){
  char buff[256];
  typename FF::FloatType time = ((typename FF::FloatType)data.step)*data.time_step;
  string prmpt=Almost::DynaStatPr;
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s | %-10s\n","time","energy","rmsd","rgyr","const");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"---------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  time,
	  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","time",
	  "bond","angle","dihe","imph");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"--------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  time,
	  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","time",
	  "elec","vdw","solv","ub");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"--------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  time,
	  OperatorHelperElec<FF::ELEC>::helper(data),
	  data.ff_data.vdw_energy,
	  OperatorHelperSolv<FF::SOLV>::helper(data),
	  OperatorHelperUb<FF::UB>::helper(data));
  log.stream()<<buff;
  prmpt=Almost::MDStatPr;
  log.stream()<<prmpt;
  sprintf(buff,"%-10s | %-10s | %-10s | %-10s\n",
	  "time","ekin","temp","etot");
  log.stream()<<buff;
  log.stream()<<prmpt;
  log.stream()<<"--------------------------------------------------------\n";
  log.stream()<<prmpt;
  sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
	  time,
	  data.kinetic_energy,
	  data.current_temp,
	  data.kinetic_energy+data.current_energy);
  log.stream()<<buff;
  return log;
}




template<typename FF, typename MBMDOptionsType>
DynaDataStream & operator<<(DynaDataStream & dat, 
			    MDImplData<FF, MBMDOptionsType> & data){
  typename FF::FloatType time = ((typename FF::FloatType)data.step)*data.time_step;
  dat.stream()<<time<<"  "
	      <<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<<" "
	      <<OperatorHelperElec<FF::ELEC>::helper(data)<<" "
	      <<data.ff_data.vdw_energy<<" "
	      <<OperatorHelperSolv<FF::SOLV>::helper(data)<<" "
	      <<OperatorHelperUb<FF::UB>::helper(data)<<" "
	      <<data.kinetic_energy<<" "
	      <<data.current_temp<<" "
	      <<data.kinetic_energy+data.current_energy<<endl;
  return dat;
}

// template<typename FF, typename SMBMDOptionsType>
// DynaLogStream & operator<<(DynaLogStream &log,  
// 			   SMDImplData<FF, SMBMDOptionsType>  & data){
//   char buff[256];
//   typename FF::FloatType time = ((typename FF::FloatType)data.step)*data.time_step;
//   string prmpt=Almost::DynaStatPr;
//   log.stream()<<prmpt;
//   sprintf(buff,"%-10s | %-10s | %-10s | %-10s | %-10s\n","time","energy","rmsd","rgyr","const");
//   log.stream()<<buff;
//   log.stream()<<prmpt;
//   log.stream()<<"---------------------------------------------------------\n";
//   log.stream()<<prmpt;
//   sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
// 	  time,
// 	  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","time",
// 	  "bond","angle","dihe","imph");
//   log.stream()<<buff;
//   log.stream()<<prmpt;
//   log.stream()<<"--------------------------------------------------------\n";
//   log.stream()<<prmpt;
//   sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
// 	  time,
// 	  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","time",
// 	  "elec","vdw","solv","ub");
//   log.stream()<<buff;
//   log.stream()<<prmpt;
//   log.stream()<<"--------------------------------------------------------\n";
//   log.stream()<<prmpt;
//   sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
// 	  time,
// 	  OperatorHelperElec<FF::ELEC>::helper(data),
// 	  data.ff_data.vdw_energy,
// 	  OperatorHelperSolv<FF::SOLV>::helper(data),
// 	  OperatorHelperUb<FF::UB>::helper(data));
//   log.stream()<<buff;
//   prmpt=Almost::MBMDStatPr;
//   log.stream()<<prmpt;
//   sprintf(buff,"%-10s | %-10s | %-10s | %-10s\n",
// 	  "time","ekin","temp","etot");
//   log.stream()<<buff;
//   log.stream()<<prmpt;
//   log.stream()<<"--------------------------------------------------------\n";
//   log.stream()<<prmpt;
//   sprintf(buff,"%-10.2f   %-10.2f   %-10.2f   %-10.2f\n\n",
// 	  time,
// 	  data.kinetic_energy,
// 	  data.current_temp,
// 	  data.kinetic_energy+data.current_energy);
//   log.stream()<<buff;
//   return log;
// }




// template<typename FF, typename SMBMDOptionsType>
// DynaDataStream & operator<<(DynaDataStream & dat, 
// 			    SMDImplData<FF, SMBMDOptionsType> & data){
//   typename FF::FloatType time = ((typename FF::FloatType)data.step)*data.time_step;
//   dat.stream()<<time<<"  "
// 	      <<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<<" "
// 	      <<OperatorHelperElec<FF::ELEC>::helper(data)<<" "
// 	      <<data.ff_data.vdw_energy<<" "
// 	      <<OperatorHelperSolv<FF::SOLV>::helper(data)<<" "
// 	      <<OperatorHelperUb<FF::UB>::helper(data)<<" "
// 	      <<data.kinetic_energy<<" "
// 	      <<data.current_temp<<" "
// 	      <<data.kinetic_energy+data.current_energy<<endl;
//   return dat;
// }

#define REGATTR(c,s,w) def_attribute(#s,&c::s,w::s)

#define REGISTER_MBMDC19_OPTIONS(type) \
    Class<MBMDOptions< type > >(mod.self(),"mdoptions") \
      .REGATTR(MBMDOptions< type >,kind,FFDoc)\
      .REGATTR(MBMDOptions< type >,elec,FFDoc)\
      .REGATTR(MBMDOptions< type >,elec_cutoff,FFDoc)\
      .REGATTR(MBMDOptions< type >,vdw,FFDoc) \
      .REGATTR(MBMDOptions< type >,vdw_cutoff,FFDoc) \
      .REGATTR(MBMDOptions< type >,solv,FFDoc) \
      .REGATTR(MBMDOptions< type >,solv_ignore_h,FFDoc) \
      .REGATTR(MBMDOptions< type >,cut_on,FFDoc) \
      .REGATTR(MBMDOptions< type >,cut_off,FFDoc) \
      .REGATTR(MBMDOptions< type >,cut_nb,FFDoc) \
      .REGATTR(MBMDOptions< type >,e_zero,FFDoc) \
      .REGATTR(MBMDOptions< type >,e_14,FFDoc) \
      .REGATTR(MBMDOptions< type >,eps,FFDoc) \
      .REGATTR(MBMDOptions< type >,r_water,FFDoc) \
      .REGATTR(MBMDOptions< type >,gamma_water,RunDoc) \
      .REGATTR(MBMDOptions< type >,vect,RunDoc) \
      .REGATTR(MBMDOptions< type >,algorithm,RunDoc) \
      .REGATTR(MBMDOptions< type >,geometry,RunDoc) \
      .REGATTR(MBMDOptions< type >,Lx,RunDoc) \
      .REGATTR(MBMDOptions< type >,Ly,RunDoc) \
      .REGATTR(MBMDOptions< type >,Lz,RunDoc) \
      .REGATTR(MBMDOptions< type >,granularity,RunDoc) \
      .REGATTR(MBMDOptions< type >,trj,RunDoc) \
      .REGATTR(MBMDOptions< type >,vtrj,RunDoc)\
      .REGATTR(MBMDOptions< type >,rst,RunDoc)\
      .REGATTR(MBMDOptions< type >,log,RunDoc)\
      .REGATTR(MBMDOptions< type >,dat,RunDoc)\
      .REGATTR(MBMDOptions< type >,steps,RunDoc)\
      .REGATTR(MBMDOptions< type >,nprint,RunDoc)\
      .REGATTR(MBMDOptions< type >,nsave,RunDoc)\
      .REGATTR(MBMDOptions< type >,nupdate,RunDoc)\
      .REGATTR(MBMDOptions< type >,nrottrans,RunDoc)\
      .REGATTR(MBMDOptions< type >,shake_mode,RunDoc)\
      .REGATTR(MBMDOptions< type >,shake_tol,RunDoc)\
      .REGATTR(MBMDOptions< type >,temp,RunDoc)\
      .REGATTR(MBMDOptions< type >,time_step,RunDoc)\
      .REGATTR(MBMDOptions< type >,tau,RunDoc)\
      .REGATTR(MBMDOptions< type >,seed,RunDoc)\
      .REGATTR(MBMDOptions< type >,save_fitted,RunDoc)\
      .REGATTR(MBMDOptions< type >,selection,RunDoc);


#define REGISTER_MBMD_CONST(type)\
    mod\
      .def_const("C19",(int)MBMDOptions< type >::C19)\
      .def_const("C22",(int)MBMDOptions< type >::C22)\
      .def_const("NONE",(int)MBMDOptions< type >::NONE)\
      .def_const("SASA",(int)MBMDOptions< type >::SASA)\
      .def_const("EEF1",(int)MBMDOptions< type >::EEF1)\
      .def_const("BERENDSEN",(int)MBMDOptions< type >::BERENDSEN)\
      .def_const("LANGEVIN",(int)MBMDOptions< type >::LANGEVIN)\
      .def_const("BERE",(int)MBMDOptions< type >::BERENDSEN)\
      .def_const("LANG",(int)MBMDOptions< type >::LANGEVIN)\
      .def_const("OFF",(int)MBMDOptions< type >::OFF)\
      .def_const("RDIE",(int)MBMDOptions< type >::RDIE)\
      .def_const("CDIE",(int)MBMDOptions< type >::CDIE)\
      .def_const("LJ",(int)MBMDOptions< type >::LJ)\
      .def_const("SHIFT",(int)MBMDOptions< type >::SHIFT)\
      .def_const("SWITCH",(int)MBMDOptions< type >::SWITCH)\
      .def_const("PLAIN",(int)MBMDOptions< type >::PLAIN)\
      .def_const("CUBIC",(int)MBMDOptions< type >::CUBIC)\
      .def_const("NONE",(int)Shake< type >::NONE)\
      .def_const("BONDH",(int)Shake< type >::BONDH)\
      .def_const("BONDALL",(int)Shake< type >::BONDALL)\
      .def_const("ANGLEALL",(int)Shake< type >::ANGLEALL)\
      ;

#endif
// Local Variables:
// mode:C++
// End: