--- trunk/src/utils/ParameterManager.hpp	2009/11/25 20:02:06	1390
+++ trunk/src/utils/ParameterManager.hpp	2014/10/22 12:23:59	2026
@@ -35,21 +35,16 @@
  *                                                                      
  * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
  * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
- * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
- * [4]  Vardeman & Gezelter, in progress (2009).                        
+ * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (2008).          
+ * [4] Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
  *
- *  ParameterManager.hpp
- *
- *  Created by Charles F. Vardeman II on 11/16/05.
- *  @author  Charles F. Vardeman II 
- *  @version $Id: ParameterManager.hpp,v 1.6 2009-11-25 20:02:04 gezelter Exp $
- *
  */
 
 #ifndef UTILS_PARAMETERMANAGER_HPP
 #define UTILS_PARAMETERMANAGER_HPP
 
 #include <iostream>
+#include <cstdio>
 
 #include <stdlib.h>
 #include <vector>
@@ -148,7 +143,7 @@ struct ParameterTraits<std::pair<int, int> >{
     } else {
       sprintf(painCave.errMsg, 
               "ParameterManager Error: "
-              "Not enough tokens to make pair!\n");
+              "Incorrect number of tokens to make a pair!\n");
       painCave.severity = OPENMD_ERROR;
       painCave.isFatal = 1;
       simError();    
@@ -156,6 +151,27 @@ struct ParameterTraits<std::pair<int, int> >{
     return false;
   }
   static std::string getParamType() { return "std::pair<int, int>";}    
+};
+
+
+template<>                     
+struct ParameterTraits<std::vector<RealType> >{
+  typedef std::vector<RealType>  RepType;
+  template<typename T> static bool    convert(T, RepType&){return false;} 
+  template<typename T> static RepType convert(T v)        {RepType tmp; convert(v,tmp);return tmp;} 
+  static bool convert(RepType v, RepType& r)            {r=v; return true;}
+  static bool convert(std::string v, RepType& r) { 
+    std::cerr << "calling tokenizer\n";
+    OpenMD::StringTokenizer tokenizer(v," ();,\t\n\r");
+    unsigned int size = tokenizer.countTokens();
+    r = std::vector<RealType>( size, 0.0 );
+    for (unsigned int i = 0; i < size; i++) {
+      RealType v = tokenizer.nextTokenAsDouble();
+      r[i] = v;
+    }
+    return true;
+  }
+  static std::string getParamType() {return "std::vector<RealType>"; }
 };
 
 
@@ -175,6 +191,7 @@ class ParameterBase { (public)
   virtual bool setData(unsigned long int) = 0;
   virtual bool setData(RealType) = 0;
   virtual bool setData(std::pair<int, int>) = 0;
+  virtual bool setData(std::vector<RealType>) = 0;
   virtual std::string getParamType() = 0;
 protected:
   std::string keyword_;
@@ -187,28 +204,27 @@ class Parameter : public ParameterBase{ (public)
 class Parameter : public ParameterBase{
 public:    
   typedef ParameterTraits<ParamType> ValueType;
-  void setDefaultValue(const ParamType& value) {data_ = value; defaultValue_ = true;}
+  void setDefaultValue(const ParamType& value) {data_ = value; defaultValue_ = true; empty_ = false;}
   ParamType getData() { return data_;}
   
   virtual bool setData(std::string sval) {
     return internalSetData<std::string>(sval);
   }
-
   virtual bool setData(int ival) {
     return internalSetData<int>(ival);
   }
-
   virtual bool setData(unsigned long int lival) {
     return internalSetData<unsigned long int>(lival);
   }
-  
   virtual bool setData(RealType dval) {
     return internalSetData<RealType>(dval);
   }
-
   virtual bool setData(std::pair<int, int> pval) {
     return internalSetData<std::pair<int, int> >(pval);
   }
+  virtual bool setData(std::vector<RealType> pval) {
+    return internalSetData<std::vector<RealType> >(pval);
+  }
   
   virtual std::string getParamType() { return ParameterTraits<ParamType>::getParamType();}
 private: 
@@ -234,8 +250,16 @@ TYPE get##NAME() { return NAME.getData();}
 bool have##NAME() { return !NAME.empty();}  \
 TYPE get##NAME() { return NAME.getData();}
 
+#define DeclareAlterableParameter(NAME, TYPE)         \
+private:                                                   \
+Parameter<TYPE> NAME;                                     \
+public:                                                      \
+bool have##NAME() { return !NAME.empty();}  \
+TYPE get##NAME() { return NAME.getData();}  \
+bool set##NAME(TYPE s) { return NAME.setData(s);}  \
 
 
+
 #define DefineParameter(NAME,KEYWORD)                              \
 NAME.setKeyword(KEYWORD);                  \
 parameters_.insert(std::map<std::string, ParameterBase*>::value_type(std::string(KEYWORD), static_cast<ParameterBase*>(&NAME)));