diff --git a/cpp/ClassEngine.cc b/cpp/ClassEngine.cc
index afadf375..82fcd31b 100644
--- a/cpp/ClassEngine.cc
+++ b/cpp/ClassEngine.cc
@@ -20,6 +20,9 @@
 #include <stdexcept>
 #include<sstream>
 #include<numeric>
+#include<cassert>
+
+//#define DBUG
 
 using namespace std;
 
@@ -67,16 +70,26 @@ ClassEngine::ClassEngine(const ClassParams& pars): cl(0),dofree(true){
   //prepare fp structure
   size_t n=pars.size();
   //
-  parser_init(&fc,n,_errmsg);
-
+  parser_init(&fc,n,"pipo",_errmsg);
+  
   //config
   for (size_t i=0;i<pars.size();i++){
     strcpy(fc.name[i],pars.key(i).c_str());
     strcpy(fc.value[i],pars.value(i).c_str());
+    //store
+    parNames.push_back(pars.key(i));
+    //identify lmax
+    cout << pars.key(i) << "\t" << pars.value(i) <<endl;
+    if (pars.key(i)=="l_max_scalars") {
+      istringstream strstrm(pars.value(i));
+      strstrm >> _lmax;
+    }
   }
+  cout << __FILE__ << " : using lmax=" << _lmax <<endl;
+  assert(_lmax>0);
 
     //input
-  if (input_init(&fc,&pr,&ba,&th,&pt,&tr,&pm,&sp,&nl,&le,&op,_errmsg) == _FAILURE_)
+  if (input_init(&fc,&pr,&ba,&th,&pt,&tr,&pm,&sp,&nl,&le,&op,_errmsg) == _FAILURE_) 
     throw invalid_argument(_errmsg);
 
   //proetction parametres mal defini
@@ -86,7 +99,7 @@ ClassEngine::ClassEngine(const ClassParams& pars): cl(0),dofree(true){
 
   //calcul class
   computeCls();
-
+  
   //cout <<"creating " << sp.ct_size << " arrays" <<endl;
   cl=new double[sp.ct_size];
 
@@ -107,24 +120,32 @@ ClassEngine::ClassEngine(const ClassParams& pars,const string & precision_file):
   //pars
   struct file_content fc_input;
   fc_input.size = 0;
-
+  fc_input.filename=new char[1];
  //prepare fc par structure
   size_t n=pars.size();
-  parser_init(&fc_input,n,_errmsg);
+  parser_init(&fc_input,n,"pipo",_errmsg);
   //config
   for (size_t i=0;i<pars.size();i++){
     strcpy(fc_input.name[i],pars.key(i).c_str());
     strcpy(fc_input.value[i],pars.value(i).c_str());
+    if (pars.key(i)=="l_max_scalars") {
+      istringstream strstrm(pars.value(i));
+      strstrm >> _lmax;
+    }
   }
+  cout << __FILE__ << " : using lmax=" << _lmax <<endl;
+  assert(_lmax>0);
+  
+
 
   //concatenate both
   if (parser_cat(&fc_input,&fc_precision,&fc,_errmsg) == _FAILURE_) throw invalid_argument(_errmsg);
 
   //parser_free(&fc_input);
   parser_free(&fc_precision);
-
+  
   //input
-  if (input_init(&fc,&pr,&ba,&th,&pt,&tr,&pm,&sp,&nl,&le,&op,_errmsg) == _FAILURE_)
+  if (input_init(&fc,&pr,&ba,&th,&pt,&tr,&pm,&sp,&nl,&le,&op,_errmsg) == _FAILURE_) 
     throw invalid_argument(_errmsg);
 
   //proetction parametres mal defini
@@ -134,7 +155,7 @@ ClassEngine::ClassEngine(const ClassParams& pars,const string & precision_file):
 
   //calcul class
   computeCls();
-
+  
   //cout <<"creating " << sp.ct_size << " arrays" <<endl;
   cl=new double[sp.ct_size];
 
@@ -142,7 +163,7 @@ ClassEngine::ClassEngine(const ClassParams& pars,const string & precision_file):
 
 
 }
-
+  
 
 
 //--------------
@@ -161,13 +182,22 @@ ClassEngine::~ClassEngine()
 //-----------------
 // Member functions --
 //-----------------
-int ClassEngine::updateParValues(const std::vector<double>& par){
+bool ClassEngine::updateParValues(const std::vector<double>& par){
   dofree && freeStructs();
   for (size_t i=0;i<par.size();i++) {
     double val=par[i];
     strcpy(fc.value[i],str(val).c_str());
+    strcpy(fc.name[i],parNames[i].c_str());
+#ifdef DBUG
+    cout << "update par values #" << i << "\t" <<  val << "\t" << str(val).c_str() << endl;
+#endif
   }
-  return computeCls();
+  int status=computeCls();
+#ifdef DBUG
+  cout << "update par status=" << status << " succes=" << _SUCCESS_ << endl;
+#endif
+
+  return (status==_SUCCESS_);
 }
 
 //print content of file_content
@@ -177,21 +207,20 @@ void ClassEngine::printFC() {
 
 
 }
-int ClassEngine::class(
-                       struct file_content *pfc,
-                       struct precision * ppr,
-                       struct background * pba,
-                       struct thermo * pth,
-                       struct perturbs * ppt,
-                       struct primordial * ppm,
-                       struct nonlinear * pnl,
-                       struct transfers * ptr,
-                       struct spectra * psp,
-                       struct lensing * ple,
-                       struct output * pop,
-                       ErrorMsg errmsg) {
-
-
+int ClassEngine::class_main(
+			    struct file_content *pfc,
+			    struct precision * ppr,
+			    struct background * pba,
+			    struct thermo * pth,
+			    struct perturbs * ppt,
+			    struct transfers * ptr,
+			    struct primordial * ppm,
+			    struct spectra * psp,
+			    struct nonlinear * pnl,
+			    struct lensing * ple,
+			    struct output * pop,
+			    ErrorMsg errmsg) {
+  
 
   if (input_init(pfc,ppr,pba,pth,ppt,ptr,ppm,psp,pnl,ple,pop,errmsg) == _FAILURE_) {
     printf("\n\nError running input_init_from_arguments \n=>%s\n",errmsg);
@@ -275,7 +304,6 @@ int ClassEngine::class(
     return _FAILURE_;
   }
 
-  //fprintf(stderr,"%d %e %e %e\n",l,cl[l][0],cl[l][1],cl[l][2]);
 
   dofree=true;
   return _SUCCESS_;
@@ -284,35 +312,43 @@ int ClassEngine::class(
 
 int ClassEngine::computeCls(){
 
+#ifdef DBUG
+  cout <<"call computecls" << endl;
   //printFC();
-  //new call
-  return this->class_main(&fc,&pr,&ba,&th,&pt,&tr,&pm,&sp,&nl,&le,&op,_errmsg);
+#endif
+
+  int status=this->class_main(&fc,&pr,&ba,&th,&pt,&tr,&pm,&sp,&nl,&le,&op,_errmsg);
+#ifdef DBUG
+  cout <<"status=" << status << endl;
+#endif
+  return status;
+
 }
 
 int
 ClassEngine::freeStructs(){
-
-
+  
+  
   if (lensing_free(&le) == _FAILURE_) {
     printf("\n\nError in spectra_free \n=>%s\n",le.error_message);
     return _FAILURE_;
   }
-
+  
   if (nonlinear_free(&nl) == _FAILURE_) {
     printf("\n\nError in nonlinear_free \n=>%s\n",nl.error_message);
     return _FAILURE_;
   }
-
+  
   if (spectra_free(&sp) == _FAILURE_) {
     printf("\n\nError in spectra_free \n=>%s\n",sp.error_message);
     return _FAILURE_;
   }
-
+    
   if (primordial_free(&pm) == _FAILURE_) {
     printf("\n\nError in primordial_free \n=>%s\n",pm.error_message);
     return _FAILURE_;
   }
-
+  
   if (transfer_free(&tr) == _FAILURE_) {
     printf("\n\nError in transfer_free \n=>%s\n",tr.error_message);
     return _FAILURE_;
@@ -336,46 +372,13 @@ ClassEngine::freeStructs(){
   return _SUCCESS_;
 }
 
-// int
-// ClassEngine::l_size(Engine::cltype t){
-//   int lmax(-1);
-
-//   switch(t)
-//     {
-//     case TT:
-//       if (sp.has_tt==_TRUE_) lmax=sp.l_size[sp.index_ct_tt];
-//       break;
-//     case TE:
-//       if (sp.has_te==_TRUE_) lmax=sp.l_size[sp.index_ct_te] ;
-//       break;
-//     case EE:
-//       if (sp.has_ee==_TRUE_) lmax=sp.l_size[sp.index_ct_ee] ;
-//       break;
-//     case BB:
-//       if (sp.has_bb==_TRUE_) lmax=sp.l_size[sp.index_ct_bb] ;
-//       break;
-//     case PP:
-//       if (sp.has_pp==_TRUE_) lmax=sp.l_size[sp.index_ct_pp] ;
-//       break;
-//     case TP:
-//       if (sp.has_tp==_TRUE_) lmax=sp.l_size[sp.index_ct_tp] ;
-//       break;
-//     case EP:
-//       if (sp.has_ep==_TRUE_) lmax=sp.l_size[sp.index_ct_ep] ;
-//       break;
-//     }
-//   return lmax;
-// }
-
-
-
 double
 ClassEngine::getCl(Engine::cltype t,const long &l){
 
   if (!dofree) throw out_of_range("no Cl available because CLASS failed");
 
   if (output_total_cl_at_l(&sp,&le,&op,static_cast<double>(l),cl) == _FAILURE_){
-    cerr << ">>>fail getting Cl type=" << (int)t << " @l=" << l <<endl;
+    cerr << ">>>fail getting Cl type=" << (int)t << " @l=" << l <<endl; 
     throw out_of_range(sp.error_message);
   }
 
@@ -391,7 +394,7 @@ ClassEngine::getCl(Engine::cltype t,const long &l){
       break;
     case TE:
       (sp.has_te==_TRUE_) ? zecl=tomuk2*cl[sp.index_ct_te] : throw invalid_argument("no ClTE available");
-      break;
+      break; 
     case EE:
       (sp.has_ee==_TRUE_) ? zecl=tomuk2*cl[sp.index_ct_ee] : throw invalid_argument("no ClEE available");
       break;
@@ -408,22 +411,22 @@ ClassEngine::getCl(Engine::cltype t,const long &l){
       (sp.has_ep==_TRUE_) ? zecl=tomuk*cl[sp.index_ct_ep] : throw invalid_argument("no ClE-Phi available");
       break;
     }
-
+  
   return zecl;
 
 }
-void
-ClassEngine::getCls(const std::vector<unsigned>& lvec, //input
-		      std::vector<double>& cltt,
-		      std::vector<double>& clte,
-		      std::vector<double>& clee,
+void 
+ClassEngine::getCls(const std::vector<unsigned>& lvec, //input 
+		      std::vector<double>& cltt, 
+		      std::vector<double>& clte, 
+		      std::vector<double>& clee, 
 		      std::vector<double>& clbb)
 {
   cltt.resize(lvec.size());
   clte.resize(lvec.size());
   clee.resize(lvec.size());
   clbb.resize(lvec.size());
-
+  
   for (size_t i=0;i<lvec.size();i++){
     try{
       cltt[i]=getCl(ClassEngine::TT,lvec[i]);
@@ -437,19 +440,18 @@ ClassEngine::getCls(const std::vector<unsigned>& lvec, //input
   }
 
 }
-
-
-bool
-ClassEngine::getLensing(const std::vector<unsigned>& lvec, //input
-		std::vector<double>& clpp    ,
-		std::vector<double>& cltp  ,
+ 
+bool 
+ClassEngine::getLensing(const std::vector<unsigned>& lvec, //input 
+		std::vector<double>& clpp    , 
+		std::vector<double>& cltp  , 
 		std::vector<double>& clep  ){
-
+ 
 
   clpp.resize(lvec.size());
   cltp.resize(lvec.size());
   clep.resize(lvec.size());
-
+  
   for (size_t i=0;i<lvec.size();i++){
     try{
       clpp[i]=getCl(ClassEngine::PP,lvec[i]);
@@ -466,36 +468,161 @@ ClassEngine::getLensing(const std::vector<unsigned>& lvec, //input
 }
 
 
-void
-ClassEngine::writeCls(std::ostream &of,int ttmax){
+double ClassEngine::get_f(double z)
+{
+  double tau;
+  int index;
+  double *pvecback;
+  //transform redshift in conformal time
+  background_tau_of_z(&ba,z,&tau);
 
-  vector<unsigned> lvec(ttmax-1,1);
-  lvec[0]=2;
-  partial_sum(lvec.begin(),lvec.end(),lvec.begin());
+  //pvecback must be allocated 
+  pvecback=(double *)malloc(ba.bg_size*sizeof(double));
 
-  vector<double> cltt,clte,clee,clbb,clpp,cltp,clep;
-  bool hasLensing=false;
-  try{
-    getCls(lvec,cltt,clte,clee,clbb);
-    hasLensing=getLensing(lvec,clpp,cltp,clep);
-  }
-  catch (std::exception &e){
-    cout << "GIOSH" << e.what() << endl;
-  }
+  //call to fill pvecback
+  background_at_tau(&ba,tau,ba.long_info,ba.inter_normal, &index, pvecback);
 
-  //cout.precision( 16 );
-  for (size_t i=0;i<lvec.size();i++) {
-    of << lvec[i] << "\t"
-       << cltt[i] << "\t"
-       << clte[i] << "\t"
-       << clee[i] << "\t"
-       << clbb[i];
-    if (hasLensing){
-      of << "\t" << clpp[i] << "\t" << cltp[i] << "\t" << clep[i];
-    }
-    of << "\n";
-  }
 
 
+  double f_z=pvecback[ba.index_bg_f];
+#ifdef DBUG
+  cout << "f_of_z= "<< f_z <<endl;
+#endif
+  return f_z;
+}
+
+
+double ClassEngine::get_sigma8(double z)
+{
+  double tau;
+  int index;
+  double *pvecback;
+  double sigma8 = 0.;
+  //transform redshift in conformal time
+  background_tau_of_z(&ba,z,&tau);
+
+  //pvecback must be allocated 
+  pvecback=(double *)malloc(ba.bg_size*sizeof(double));
+
+  //call to fill pvecback
+  background_at_tau(&ba,tau,ba.long_info,ba.inter_normal, &index, pvecback);
+  //background_at_tau(pba,tau,pba->long_info,pba->inter_normal,&last_index,pvecback);
+  spectra_sigma(&ba,&pm,&sp,8./ba.h,z,&sigma8);
+
+#ifdef DBUG
+  cout << "sigma_8= "<< sigma8 <<endl;
+#endif
+  return sigma8;
+}
+
+// ATTENTION FONCTION BIDON - GET omegam ! -------------------
+double ClassEngine::get_Az(double z)
+{
+  double Dv = get_Dv(z);
+  // A(z)=100DV(z)sqrt(~mh2)/cz
+  double omega_bidon = 0.12 ;
+  double Az = 100.*Dv*sqrt(omega_bidon)/(3.e8*z); // is there speed of light somewhere ? 
+}
+//      --------------------------
+
+double ClassEngine::get_Dv(double z)
+{
+  double tau;
+  int index;
+  double *pvecback;
+  //transform redshift in conformal time
+  background_tau_of_z(&ba,z,&tau);
+
+  //pvecback must be allocated 
+  pvecback=(double *)malloc(ba.bg_size*sizeof(double));
+
+  //call to fill pvecback
+  background_at_tau(&ba,tau,ba.long_info,ba.inter_normal, &index, pvecback);
+
+
+  double H_z=pvecback[ba.index_bg_H];
+  double D_ang=pvecback[ba.index_bg_ang_distance];
+#ifdef DBUG
+  cout << "H_z= "<< H_z <<endl;
+  cout << "D_ang= "<< D_ang <<endl;
+#endif
+  double D_v;
+
+  D_v=pow(D_ang*(1+z),2)*z/H_z;
+  D_v=pow(D_v,1./3.);
+#ifdef DBUG
+  cout << D_v << endl;
+#endif
+  return D_v;
+}
+
+double ClassEngine::get_Fz(double z)
+{
+  double tau;
+  int index;
+  double *pvecback;
+  //transform redshift in conformal time
+  background_tau_of_z(&ba,z,&tau);
+
+  //pvecback must be allocated 
+  pvecback=(double *)malloc(ba.bg_size*sizeof(double));
+
+  //call to fill pvecback
+  background_at_tau(&ba,tau,ba.long_info,ba.inter_normal, &index, pvecback);
+
+
+  double H_z=pvecback[ba.index_bg_H];
+  double D_ang=pvecback[ba.index_bg_ang_distance];
+#ifdef DBUG
+  cout << "H_z= "<< H_z <<endl;
+  cout << "D_ang= "<< D_ang <<endl;
+#endif
+  double F_z = (1.+z) * D_ang * H_z /(3.e8) ; // is there speed of light somewhere ? 
+  return F_z;
+}
+
+double ClassEngine::get_Hz(double z)
+{
+  double tau;
+  int index;
+  double *pvecback;
+  //transform redshift in conformal time
+  background_tau_of_z(&ba,z,&tau);
+
+  //pvecback must be allocated 
+  pvecback=(double *)malloc(ba.bg_size*sizeof(double));
+
+  //call to fill pvecback
+  background_at_tau(&ba,tau,ba.long_info,ba.inter_normal, &index, pvecback);
 
+
+  double H_z=pvecback[ba.index_bg_H];
+
+  return(H_z);
+
+}
+
+
+double ClassEngine::get_Da(double z)
+{
+  double tau;
+  int index;
+  double *pvecback;
+  //transform redshift in conformal time
+  background_tau_of_z(&ba,z,&tau);
+
+  //pvecback must be allocated 
+  pvecback=(double *)malloc(ba.bg_size*sizeof(double));
+
+  //call to fill pvecback
+  background_at_tau(&ba,tau,ba.long_info,ba.inter_normal, &index, pvecback);
+
+
+  double H_z=pvecback[ba.index_bg_H];
+  double D_ang=pvecback[ba.index_bg_ang_distance];
+#ifdef DBUG
+  cout << "H_z= "<< H_z <<endl;
+  cout << "D_ang= "<< D_ang <<endl;
+#endif
+  return D_ang;
 }
diff --git a/cpp/ClassEngine.hh b/cpp/ClassEngine.hh
index fa2827dc..21fdca2b 100644
--- a/cpp/ClassEngine.hh
+++ b/cpp/ClassEngine.hh
@@ -9,8 +9,7 @@
 //	Stephane Plaszczynski (plaszczy@lal.in2p3.fr)
 //
 // History (add to end):
-//	creation:   ven. nov. 4 11:02:20 CET 2011
-//  updated to class v2.1 by Julien Lesgourgues (7 March 2014)
+//	creation:   ven. nov. 4 11:02:20 CET 2011 
 //
 //-----------------------------------------------------------------------
 
@@ -51,7 +50,7 @@ public:
   pars.push_back(make_pair(key,str(val)));
   return pars.size();
   }
-
+  
   //accesors
   inline unsigned size() const {return pars.size();}
   inline string key(const unsigned& i) const {return pars[i].first;}
@@ -73,41 +72,55 @@ public:
   ClassEngine(const ClassParams& pars);
   //with a class .pre file
   ClassEngine(const ClassParams& pars,const string & precision_file);
-
+  
 
   // destructor
   ~ClassEngine();
 
   //modfiers: _FAILURE_ returned if CLASS pb:
-  int updateParValues(const std::vector<double>& par);
+  bool updateParValues(const std::vector<double>& par);
 
 
   //get value at l ( 2<l<lmax): in units = (micro-K)^2
   //don't call if FAILURE returned previously
   //throws std::execption if pb
 
-  double getCl(Engine::cltype t,const long &l);
-  void getCls(const std::vector<unsigned>& lVec, //input
-	      std::vector<double>& cltt,
-	      std::vector<double>& clte,
-	      std::vector<double>& clee,
+  double getCl(Engine::cltype t,const long &l);  
+  void getCls(const std::vector<unsigned>& lVec, //input 
+	      std::vector<double>& cltt, 
+	      std::vector<double>& clte, 
+	      std::vector<double>& clee, 
 	      std::vector<double>& clbb);
 
-
-  bool getLensing(const std::vector<unsigned>& lVec, //input
-	      std::vector<double>& clphiphi,
-	      std::vector<double>& cltphi,
+  
+  bool getLensing(const std::vector<unsigned>& lVec, //input 
+	      std::vector<double>& clphiphi, 
+	      std::vector<double>& cltphi, 
 	      std::vector<double>& clephi);
 
+ //for BAO
+  inline double z_drag() const {return th.z_d;}
+  inline double rs_drag() const {return th.rs_d;} 
+  double get_Dv(double z);
+
+  double get_Da(double z);
+  double get_sigma8(double z);
+  double get_f(double z);
+
+  double get_Fz(double z);
+  double get_Hz(double z);
+  double get_Az(double z);
+
+  double getTauReio() const {return th.tau_reio;}
 
   //may need that
   inline int numCls() const {return sp.ct_size;};
   inline double Tcmb() const {return ba.T_cmb;}
 
+  inline int l_max_scalars() const {return _lmax;}
+
   //print content of file_content
   void printFC();
-  void writeCls(std::ostream &o,int lmax);
-
 
 private:
   //structures class en commun
@@ -134,24 +147,27 @@ private:
   int computeCls();
 
   int class_main(
-                 struct file_content *pfc,
-                 struct precision * ppr,
-                 struct background * pba,
-                 struct thermo * pth,
-                 struct perturbs * ppt,
-                 struct primordial * ppm,
-                 struct nonlinear * pnl,
-                 struct transfers * ptr,
-                 struct spectra * psp,
-                 struct lensing * ple,
-                 struct output * pop,
-                 ErrorMsg errmsg);
+		 struct file_content *pfc,
+		 struct precision * ppr,
+		 struct background * pba,
+		 struct thermo * pth,
+		 struct perturbs * ppt,
+		 struct transfers * ptr,
+		 struct primordial * ppm,
+		 struct spectra * psp,
+		 struct nonlinear * pnl,
+		 struct lensing * ple,
+		 struct output * pop,
+		 ErrorMsg errmsg);
+  //parnames
+  std::vector<std::string> parNames;
 
 protected:
-
-
+ 
+  
 };
 
 
 ;
 #endif
+
diff --git a/cpp/Engine.cc b/cpp/Engine.cc
new file mode 100644
index 00000000..12b3ac98
--- /dev/null
+++ b/cpp/Engine.cc
@@ -0,0 +1,70 @@
+//--------------------------------------------------------------------------
+//
+// Description:
+// 	class Engine : see header file (Engine.hh) for description.
+//
+//------------------------------------------------------------------------
+//-----------------------
+// This Class's Header --
+//-----------------------
+#include "Engine.hh"
+// ------------------------
+// Collaborating classes --
+//-------------------------
+//--------------------
+// C++
+//--------------------
+#include<numeric>
+#include<iostream>
+#include<stdexcept>
+//--------------------
+// C 
+//----------------
+
+using namespace std;
+//---------------
+// Constructors --
+//----------------
+Engine::Engine():_lmax(-1)
+{
+}
+//--------------
+// Destructor --
+//--------------
+
+//-----------------
+// Member functions --
+//-----------------
+
+void 
+Engine::writeCls(std::ostream &of){
+
+  vector<unsigned> lvec(_lmax-1,1);
+  lvec[0]=2;
+  partial_sum(lvec.begin(),lvec.end(),lvec.begin());
+      
+  vector<double> cltt,clte,clee,clbb,clpp,cltp,clep;
+  bool hasLensing=false;
+  try{
+    getCls(lvec,cltt,clte,clee,clbb);
+    hasLensing=getLensing(lvec,clpp,cltp,clep); 
+  }
+  catch (std::exception &e){
+    cout << "GIOSH" << e.what() << endl;
+  }
+      
+  cout.precision( 16 );
+  for (size_t i=0;i<lvec.size();i++) {
+    of << lvec[i] << "\t" 
+       << cltt[i] << "\t" 
+       << clte[i] << "\t" 
+       << clee[i] << "\t" 
+       << clbb[i];
+    if (hasLensing){
+      of << "\t" << clpp[i] << "\t" << cltp[i] << "\t" << clep[i];
+    }
+    of << "\n";
+  }
+  
+
+}
diff --git a/cpp/Engine.hh b/cpp/Engine.hh
new file mode 100644
index 00000000..231dc45f
--- /dev/null
+++ b/cpp/Engine.hh
@@ -0,0 +1,76 @@
+//--------------------------------------------------------------------------
+//
+// Description:
+// 	class Engine :
+//base class for Boltzmann code
+//
+//
+// Author List:
+//	Stephane Plaszczynski (plaszczy@lal.in2p3.fr)
+//
+// History (add to end):
+//	creation:   Tue Mar 13 15:28:50 CET 2012 
+//
+//------------------------------------------------------------------------
+
+#ifndef Engine_hh
+#define Engine_hh
+
+#include<vector>
+#include<ostream>
+
+class Engine
+{
+
+public:
+
+  enum cltype {TT=0,EE,TE,BB,PP,TP,EP}; //P stands for phi (lensing potential)
+
+  //constructors
+  Engine();
+
+  //pure virtual:
+  virtual bool updateParValues(const std::vector<double>& cosmopars)=0;
+
+  // units = (micro-K)^2
+  virtual void getCls(const std::vector<unsigned>& lVec, //input 
+		      std::vector<double>& cltt, 
+		      std::vector<double>& clte, 
+		      std::vector<double>& clee, 
+		      std::vector<double>& clbb)=0;
+  
+
+  virtual bool getLensing(const std::vector<unsigned>& lVec, //input 
+			  std::vector<double>& clpp, 
+			  std::vector<double>& cltp, 
+			  std::vector<double>& clep)=0;
+
+
+  virtual double z_drag() const=0;
+  virtual double rs_drag() const =0;
+
+  virtual double get_Dv(double z)=0;
+  
+  virtual double get_Da(double z)=0;
+  virtual double get_sigma8(double z)=0;
+  virtual double get_f(double z)=0;
+  virtual double get_Fz(double z)=0;
+  virtual double get_Az(double z)=0;
+  virtual double get_Hz(double z)=0;
+
+  virtual double getTauReio() const=0;
+
+  // destructor
+  virtual ~Engine(){};
+
+  //write Cl model+lensing in ostream
+  virtual void writeCls(std::ostream &o);
+  inline int lmax() {return _lmax;}
+
+protected:
+  int _lmax;
+
+};
+
+#endif
+
diff --git a/cpp/README b/cpp/README
index 92f3c1e7..b08e8890 100644
--- a/cpp/README
+++ b/cpp/README
@@ -1,8 +1,9 @@
 The C++ wrapper ClassEngine.cc for Class (written by S. Plaszczynski) is distributed together with a test code, testKlass.cc, in which you can write a list of input parameters. This test code can be compiled with (assuming you are already in the directory cpp/):
 
+> c++ -O2 -fopenmp -I../include -c Engine.cc -o Engine.o
 > c++ -O2 -fopenmp -I../include -c ClassEngine.cc -o ClassEngine.o
 > c++ -O2 -fopenmp -I../include -c testKlass.cc -o testKlass.o
 > cd ..
-> c++ -O2 -fopenmp build/growTable.o build/dei_rkck.o build/sparse.o build/evolver_rkck.o build/evolver_ndf15.o build/arrays.o build/parser.o build/quadrature.o build/input.o build/background.o build/thermodynamics.o build/perturbations.o build/bessel.o build/transfer.o build/primordial.o build/spectra.o build/trg.o build/nonlinear.o build/lensing.o build/hyrectools.o build/helium.o build/hydrogen.o build/history.o build/output.o cpp/ClassEngine.o cpp/testKlass.o -o testKlass
+> c++ -O2 -fopenmp build/arrays.o build/background.o build/common.o build/dei_rkck.o build/evolver_ndf15.o build/evolver_rkck.o build/growTable.o build/helium.o build/history.o build/hydrogen.o build/hyperspherical.o build/hyrectools.o build/input.o build/lensing.o build/nonlinear.o build/output.o build/parser.o build/perturbations.o build/primordial.o build/quadrature.o build/sparse.o build/spectra.o build/thermodynamics.o build/transfer.o cpp/ClassEngine.o cpp/Engine.o cpp/testKlass.o -o testKlass
 
 then run ./testKlass.cc
diff --git a/cpp/testKlass.cc b/cpp/testKlass.cc
index 7f0bb7e6..0d708ee7 100644
--- a/cpp/testKlass.cc
+++ b/cpp/testKlass.cc
@@ -18,28 +18,26 @@ int main(int argc,char** argv){
   //CLASS config
   ClassParams pars;
   
-  pars.add("H0",70.3);
+  //pars.add("H0",70.3);
+  pars.add("100*theta_s",1.04);
   pars.add("omega_b",0.0220);
-  //pars.add("omega_b",0.0215);
   pars.add("omega_cdm",0.1116);
   pars.add("A_s",2.42e-9);
   pars.add("n_s",.96);
-  pars.add("z_reio",10.4);
+  pars.add("tau_reio",0.09);
 
-  pars.add("k_pivot",0.002);
+  pars.add("k_pivot",0.05);
   pars.add("YHe",0.25);
   pars.add("output","tCl,pCl,lCl"); //pol +clphi
 
   pars.add("l_max_scalars",l_max_scalars);
-  pars.add("lensing",false); //note boolean
+  pars.add("lensing",true); //note boolean
 
-  pars.add("modes","s"); //scalars
-  pars.add("ic","ad"); //adiabatic
 
+  ClassEngine* KKK(0);
 
   try{
     //le calculateur de spectres
-    ClassEngine* KKK(0);
     if (argc==2){
       string pre=string(argv[1]);
       KKK=new ClassEngine(pars,pre);
@@ -49,29 +47,12 @@ int main(int argc,char** argv){
     }
     
     cout.precision( 16 );
-
-    for (int l=2;l<=l_max_scalars;l++) {
-      try{
-      cout << l << "\t" 
-	   << KKK->getCl(ClassEngine::TT,l) << "\t" 
-	   << KKK->getCl(ClassEngine::TE,l) << "\t" 
-	   << KKK->getCl(ClassEngine::EE,l) << "\t" 
-	   << KKK->getCl(ClassEngine::BB,l)<< "\t" 
-	   << KKK->getCl(ClassEngine::PP,l)<< "\t" 
-	   << KKK->getCl(ClassEngine::TP,l)<< "\t"
-	   << KKK->getCl(ClassEngine::EP,l)  
-	   << endl;
-      }
-      catch (std::exception &e){
-	cout << "GIOSH" << e.what() << endl;
-      }
-
-    }
-    delete KKK;
+    KKK->writeCls(cout);
   }
-  //class engine throws std:exceptions
-  catch(exception& e){
-    cerr << e.what() << endl;
+  catch (std::exception &e){
+    cout << "GIOSH" << e.what() << endl;
   }
 
+  delete KKK;
+
 }