ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/io/Globals.hpp
(Generate patch)

Comparing trunk/src/io/Globals.hpp (file contents):
Revision 665 by tim, Thu Oct 13 22:26:47 2005 UTC vs.
Revision 963 by tim, Wed May 17 21:51:42 2006 UTC

# Line 49 | Line 49
49   #include <string>
50   #include <map>
51  
52 – #include "io/BASS_interface.h"
52   #include "types/Component.hpp"
53 < #include "types/MakeStamps.hpp"
54 < #include "types/ZconStamp.hpp"
55 < #include "utils/CaseConversion.hpp"
53 > #include "types/ZconsStamp.hpp"
54 > #include "types/MoleculeStamp.hpp"
55 > #include "utils/ParameterManager.hpp"
56  
57 < template<typename T>
58 < struct ParameterTraits;
60 <
61 < //string
62 < template<>                    
63 < struct ParameterTraits<std::string>{
64 <  typedef std::string RepType;       // Representation type of the value
65 <
66 < template<typename T> static bool    convert(T v, RepType& r){return false;} // !NB everything is ok
67 < template<typename T> static RepType convert(T v)            {RepType tmp; convert(v,tmp);return tmp;}
68 <  static bool convert(RepType v, RepType& r) { r = v; return true;}
69 < };
70 < //bool
71 < template<>                    
72 < struct ParameterTraits<bool>{
73 <  typedef bool RepType;
74 <  template<typename T> static bool    convert(T, RepType&){return false;}
75 <  template<typename T> static RepType convert(T v)        {RepType tmp; convert(v,tmp);return tmp;}
76 <  static bool convert(std::string v, RepType& r) {
77 <    oopse::toLower(v);
78 <    bool result = false;
79 <    if (v == "true") {
80 <        r = true;
81 <        result = true;
82 <    } else if (v == "false") {
83 <        r = false;
84 <        result = true;
85 <    }
86 <    
87 <     return result;
88 <  }
89 < };
90 <
91 < //int  
92 < template<>
93 < struct ParameterTraits<int>{
94 <    typedef int RepType;
95 <    template<typename T> static bool    convert(T, RepType&){return false;}
96 <    template<typename T> static RepType convert(T v)        {RepType tmp; convert(v,tmp);return tmp;}
97 <    static bool convert(RepType v, RepType& r)            { r=v; return true;}
98 < };
99 <
100 < //double
101 < template<>                    
102 < struct ParameterTraits<double>{
103 <    typedef double RepType;
104 <    template<typename T> static bool    convert(T, RepType&){return false;}
105 <    template<typename T> static RepType convert(T v)        {RepType tmp; convert(v,tmp);return tmp;}
106 <    static bool convert(RepType v, RepType& r)            {r=v; return true;}
107 <    static bool convert(int v, RepType& r)                {r = static_cast<double>(v); return true;}
108 < };
109 <
110 <
111 < class ParameterBase {
112 <  public:    
113 <    ParameterBase() : keyword_(), optional_(false), defaultValue_(false), empty_(true) {}
114 <    bool isOptional() {return optional_;}
115 <    void setOptional(bool optional) {optional_ = optional;}
116 <    bool hasDefaultValue() {return defaultValue_;}
117 <    virtual bool isValid() { return true;}
118 <    const std::string& getKeyword() {return keyword_;}
119 <    void setKeyword(const std::string& keyword) { keyword_ = keyword;}
120 <    bool empty() {return empty_;}
121 <    virtual bool setData(std::string) = 0;
122 <    virtual bool setData(int) = 0;
123 <    virtual bool setData(double) = 0;
124 <    
125 <  protected:
126 <    std::string keyword_;
127 <    bool optional_;
128 <    bool defaultValue_;
129 <    bool empty_;
130 < };
131 <
132 < template<class ParamType>
133 < class Parameter : public ParameterBase{
134 <   public:    
135 <    typedef ParameterTraits<ParamType> ValueType;
136 <     void setDefaultValue(const ParamType& value) {data_ = value; defaultValue_ = true;}
137 <     ParamType getData() { return data_;}
138 <
139 <    virtual bool setData(std::string sval) {
140 <        return internalSetData<std::string>(sval);
141 <    }
142 <    virtual bool setData(int ial) {
143 <        return internalSetData<int>(ial);
144 <    }
145 <    
146 <    virtual bool setData(double dval) {
147 <        return internalSetData<double>(dval);
148 <    }
149 <
150 <   private:
151 <     template<class T> bool internalSetData(T data) {
152 <        ParamType tmp;
153 <        bool result = ValueType::convert(data, tmp);
154 <        if (result) {
155 <            empty_ = false;
156 <            data_ = tmp;
157 <        }
158 <        return result;
159 <     }
160 <    
161 <   private:
162 <     ParamType data_;
163 <      
164 < };
165 <
166 < #define DeclareParameter(NAME, TYPE)         \
167 <    private:                                                   \
168 <      Parameter<TYPE> NAME;                                     \
169 <    public:                                                      \
170 <      bool have##NAME() { return !NAME.empty();}  \
171 <      TYPE get##NAME() { return NAME.getData();}
172 <
173 <
174 < class Globals {
57 > namespace oopse {
58 > class Globals : public DataHolder {
59    public:
60      Globals();
61 +    virtual ~Globals();
62      
63    DeclareParameter(ForceField, std::string);
64 <  DeclareParameter(NComponents, int);  
180 <  DeclareParameter(TargetTemp, double);
64 >  DeclareParameter(TargetTemp, RealType);
65    DeclareParameter(Ensemble, std::string);
66 <  DeclareParameter(Dt, double);
67 <  DeclareParameter(RunTime, double);
66 >  DeclareParameter(Dt, RealType);
67 >  DeclareParameter(RunTime, RealType);
68    DeclareParameter(InitialConfig, std::string);
69    DeclareParameter(FinalConfig, std::string);
70 <  DeclareParameter(NMol, int);
71 <  DeclareParameter(Density, double);
72 <  DeclareParameter(Box, double);
73 <  DeclareParameter(BoxX, double);
74 <  DeclareParameter(BoxY, double);
75 <  DeclareParameter(BoxZ, double);
192 <  DeclareParameter(SampleTime, double);
193 <  DeclareParameter(ResetTime, double);
194 <  DeclareParameter(StatusTime, double);
195 <  DeclareParameter(CutoffRadius, double);
196 <  DeclareParameter(SwitchingRadius, double);
197 <  DeclareParameter(Dielectric, double);
70 >  DeclareParameter(SampleTime, RealType);
71 >  DeclareParameter(ResetTime, RealType);
72 >  DeclareParameter(StatusTime, RealType);
73 >  DeclareParameter(CutoffRadius, RealType);
74 >  DeclareParameter(SwitchingRadius, RealType);
75 >  DeclareParameter(Dielectric, RealType);
76    DeclareParameter(TempSet, bool);
77 <  DeclareParameter(ThermalTime, double);
200 <  DeclareParameter(MixingRule, std::string);
77 >  DeclareParameter(ThermalTime, RealType);
78    DeclareParameter(UsePeriodicBoundaryConditions, bool);
79 <  DeclareParameter(TargetPressure, double);
80 <  DeclareParameter(TauThermostat, double);
81 <  DeclareParameter(TauBarostat, double);
82 <  DeclareParameter(ZconsTime, double);
83 <  DeclareParameter(NZconstraints, int);
207 <  DeclareParameter(ZconsTol, double);
79 >  DeclareParameter(TargetPressure, RealType);
80 >  DeclareParameter(TauThermostat, RealType);
81 >  DeclareParameter(TauBarostat, RealType);
82 >  DeclareParameter(ZconsTime, RealType);
83 >  DeclareParameter(ZconsTol, RealType);
84    DeclareParameter(ZconsForcePolicy, std::string);
85    DeclareParameter(Seed, int);
86    DeclareParameter(UseInitalTime, bool);
87    DeclareParameter(UseIntialExtendedSystemState, bool);
88 <  DeclareParameter(OrthoBoxTolerance, double);
88 >  DeclareParameter(OrthoBoxTolerance, RealType);
89    DeclareParameter(Minimizer, std::string);
90 <  DeclareParameter(MinimizerMaxIter, double);
90 >  DeclareParameter(MinimizerMaxIter, RealType);
91    DeclareParameter(MinimizerWriteFrq, int);
92 <  DeclareParameter(MinimizerStepSize, double);
93 <  DeclareParameter(MinimizerFTol, double);
94 <  DeclareParameter(MinimizerGTol, double);
95 <  DeclareParameter(MinimizerLSTol, double);
92 >  DeclareParameter(MinimizerStepSize, RealType);
93 >  DeclareParameter(MinimizerFTol, RealType);
94 >  DeclareParameter(MinimizerGTol, RealType);
95 >  DeclareParameter(MinimizerLSTol, RealType);
96    DeclareParameter(MinimizerLSMaxIter, int);
97 <  DeclareParameter(ZconsGap, double);
98 <  DeclareParameter(ZconsFixtime, double);
97 >  DeclareParameter(ZconsGap, RealType);
98 >  DeclareParameter(ZconsFixtime, RealType);
99    DeclareParameter(ZconsUsingSMD, bool);
100    DeclareParameter(UseSolidThermInt, bool);
101    DeclareParameter(UseLiquidThermInt, bool);
102 <  DeclareParameter(ThermodynamicIntegrationLambda, double);
103 <  DeclareParameter(ThermodynamicIntegrationK, double);
102 >  DeclareParameter(ThermodynamicIntegrationLambda, RealType);
103 >  DeclareParameter(ThermodynamicIntegrationK, RealType);
104    DeclareParameter(ForceFieldVariant, std::string);
105    DeclareParameter(ForceFieldFileName, std::string);
106 <  DeclareParameter(ThermIntDistSpringConst, double);
107 <  DeclareParameter(ThermIntThetaSpringConst, double);
108 <  DeclareParameter(ThermIntOmegaSpringConst, double);
109 <  DeclareParameter(SurfaceTension, double);
106 >  DeclareParameter(ThermIntDistSpringConst, RealType);
107 >  DeclareParameter(ThermIntThetaSpringConst, RealType);
108 >  DeclareParameter(ThermIntOmegaSpringConst, RealType);
109 >  DeclareParameter(SurfaceTension, RealType);
110    DeclareParameter(PrintPressureTensor, bool);
111    DeclareParameter(ElectrostaticSummationMethod, std::string);
112 <  DeclareParameter(DampingAlpha, double);
112 >  DeclareParameter(ElectrostaticScreeningMethod, std::string);
113 >  DeclareParameter(DampingAlpha, RealType);
114    DeclareParameter(CutoffPolicy, std::string);
115 +  DeclareParameter(SwitchingFunctionType, std::string);
116    DeclareParameter(CompressDumpFile, bool);
117 <  DeclareParameter(SkinThickness, double);
117 >  DeclareParameter(OutputForceVector, bool);
118 >  DeclareParameter(SkinThickness, RealType);
119    DeclareParameter(StatFileFormat, std::string);    
120 +  DeclareParameter(HydroPropFile, std::string);
121 +  DeclareParameter(Viscosity, RealType);
122 +  DeclareParameter(BeadSize, RealType);  
123 +  DeclareParameter(UseSphericalBoundaryConditions, bool);
124 +  DeclareParameter(FrozenBufferRadius, RealType);
125 +  DeclareParameter(LangevinBufferRadius, RealType);
126 +  
127 +  public:
128 +    bool addComponent(Component* comp);
129 +    bool addZConsStamp(ZConsStamp* zcons);
130 +    bool addMoleculeStamp(MoleculeStamp* molStamp);
131 +    int getNComponents() {return components_.size();}
132 +    std::vector<Component*> getComponents() {return components_;}
133 +    Component* getComponentAt(int index) {return components_.at(index);}    
134  
135 +    int getNZconsStamps() {return zconstraints_.size();}
136 +    std::vector<ZConsStamp*> getZconsStamps() {return zconstraints_;}
137 +    ZConsStamp* getZconsStampAt(int index) {return zconstraints_.at(index);}    
138 +
139 +    virtual void validate();
140    private:
243 –    typedef std::map<std::string, ParameterBase*> ParamMap;
244 –    ParamMap parameters_;
141      
142 <    Component* current_component;
143 <    Component** components; // the array of components
142 >    std::vector<Component*> components_;
143 >    std::vector<ZConsStamp*> zconstraints_;    
144 >    std::map<std::string, MoleculeStamp*> moleculeStamps_;
145  
249 –    ZconStamp* current_zConstraint;
250 –    ZconStamp** zConstraints; // the array of zConstraints
251 –
252 –    char* checkMe();
253 –
254 –  public:
255 –    int newComponent( event* the_event );
256 –    int componentAssign( event* the_event );
257 –    int componentEnd( event* the_event );
258 –
259 –    int newZconstraint( event* the_event );
260 –    int zConstraintAssign( event* the_event );
261 –    int zConstraintEnd( event* the_event );
262 –  
263 –    int globalAssign( event* the_event );
264 –    int globalEnd( event* the_event );    
265 –
266 –    ZconStamp** getZconStamp() {return zConstraints;}
267 –    Component** getComponents() {return components;}
146   };
147 + }
148   #endif
149  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines