ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/tengDissertation/Appendix.tex
(Generate patch)

Comparing trunk/tengDissertation/Appendix.tex (file contents):
Revision 2827 by tim, Thu Jun 8 20:05:53 2006 UTC vs.
Revision 2833 by tim, Thu Jun 8 21:14:26 2006 UTC

# Line 132 | Line 132 | class IntegratorFactory {
132   \begin{lstlisting}[float,caption={[A classic Singleton design pattern implementation(I)] Declaration of {\tt IntegratorFactory} class.},label={appendixScheme:singletonDeclaration}]
133  
134   class IntegratorFactory {
135 <  public:
136 <    static IntegratorFactory* getInstance();
137 <    protected:
138 <      IntegratorFactory();
139 <    private:
140 <      static IntegratorFactory* instance_;
135 > public:
136 >  static IntegratorFactory*
137 >  getInstance();
138 > protected:
139 >  IntegratorFactory();
140 > private:
141 >  static IntegratorFactory* instance_;
142   };
143  
144   \end{lstlisting}
# Line 176 | Line 177 | class IntegratorFactory {
177   \begin{lstlisting}[float,caption={[The implementation of Factory pattern (I)].},label={appendixScheme:factoryDeclaration}]
178  
179   class IntegratorFactory {
180 <  public:
181 <    typedef std::map<string, IntegratorCreator*> CreatorMapType;
180 > public:
181 >  typedef std::map<string, IntegratorCreator*> CreatorMapType;
182  
183 <    bool registerIntegrator(IntegratorCreator* creator);
183 >  bool registerIntegrator(IntegratorCreator* creator) {
184 >    return creatorMap_.insert(creator->getIdent(), creator).second;
185 >  }
186  
187 <    Integrator* createIntegrator(const string& id, SimInfo* info);
187 >  Integrator* createIntegrator(const string& id, SimInfo* info) {
188 >    Integrator* result = NULL;
189 >    CreatorMapType::iterator i = creatorMap_.find(id);
190 >    if (i != creatorMap_.end()) {
191 >      result = (i->second)->create(info);
192 >    }
193 >    return result;
194 >  }
195  
196 <  private:
197 <    CreatorMapType creatorMap_;
196 > private:
197 >  CreatorMapType creatorMap_;
198   };
189 –
199   \end{lstlisting}
200 + \begin{lstlisting}[float,caption={[The implementation of Factory pattern (III)]Souce code of creator classes.},label={appendixScheme:integratorCreator}]
201  
192 – \begin{lstlisting}[float,caption={[The implementation of Factory pattern (II)].},label={appendixScheme:factoryDeclarationImplementation}]
193 –
194 – bool IntegratorFactory::unregisterIntegrator(const string& id) {
195 –  return creatorMap_.erase(id) == 1;
196 – }
197 –
198 – Integrator* IntegratorFactory::createIntegrator(const string& id,
199 –                                                SimInfo* info) {
200 –  CreatorMapType::iterator i = creatorMap_.find(id);
201 –  if (i != creatorMap_.end()) {
202 –    return (i->second)->create(info);
203 –  } else {
204 –    return NULL;
205 –  }
206 – }
207 –
208 – \end{lstlisting}
209 –
210 – \begin{lstlisting}[float,caption={[The implementation of Factory pattern (III)].},label={appendixScheme:integratorCreator}]
211 –
202   class IntegratorCreator {
203 <  public:
203 > public:
204      IntegratorCreator(const string& ident) : ident_(ident) {}
205  
206      const string& getIdent() const { return ident_; }
207  
208      virtual Integrator* create(SimInfo* info) const = 0;
209  
210 <  private:
210 > private:
211      string ident_;
212   };
213  
214   template<class ConcreteIntegrator>
215   class IntegratorBuilder : public IntegratorCreator {
216 <  public:
217 <    IntegratorBuilder(const string& ident) : IntegratorCreator(ident) {}
218 <    virtual  Integrator* create(SimInfo* info) const {
219 <      return new ConcreteIntegrator(info);
220 <    }
216 > public:
217 >  IntegratorBuilder(const string& ident)
218 >                   : IntegratorCreator(ident) {}
219 >  virtual  Integrator* create(SimInfo* info) const {
220 >    return new ConcreteIntegrator(info);
221 >  }
222   };
223   \end{lstlisting}
224  
# Line 253 | Line 244 | class BaseVisitor{
244   \begin{lstlisting}[float,caption={[The implementation of Visitor pattern (I)]Source code of the visitor classes.},label={appendixScheme:visitor}]
245  
246   class BaseVisitor{
247 <  public:
248 <    virtual void visit(Atom* atom);
249 <    virtual void visit(DirectionalAtom* datom);
250 <    virtual void visit(RigidBody* rb);
247 > public:
248 >  virtual void visit(Atom* atom);
249 >  virtual void visit(DirectionalAtom* datom);
250 >  virtual void visit(RigidBody* rb);
251   };
252  
253   \end{lstlisting}
# Line 264 | Line 255 | class StuntDouble {
255   \begin{lstlisting}[float,caption={[The implementation of Visitor pattern (II)]Source code of the element classes.},label={appendixScheme:element}]
256  
257   class StuntDouble {
258 <  public:
259 <    virtual void accept(BaseVisitor* v) = 0;
258 > public:
259 >  virtual void accept(BaseVisitor* v) = 0;
260   };
261  
262   class Atom: public StuntDouble {
263 <  public:
264 <    virtual void accept{BaseVisitor* v*} {
265 <      v->visit(this);
266 <    }
263 > public:
264 >  virtual void accept{BaseVisitor* v*} {
265 >    v->visit(this);
266 >  }
267   };
268  
269   class DirectionalAtom: public Atom {
270 <  public:
271 <    virtual void accept{BaseVisitor* v*} {
272 <      v->visit(this);
273 <    }
270 > public:
271 >  virtual void accept{BaseVisitor* v*} {
272 >    v->visit(this);
273 >  }
274   };
275  
276   class RigidBody: public StuntDouble {
277 <  public:
278 <    virtual void accept{BaseVisitor* v*} {
279 <      v->visit(this);
280 <    }
277 > public:
278 >  virtual void accept{BaseVisitor* v*} {
279 >    v->visit(this);
280 >  }
281   };
282  
283   \end{lstlisting}
284 +
285   \section{\label{appendixSection:concepts}Concepts}
286  
287   OOPSE manipulates both traditional atoms as well as some objects
288   that {\it behave like atoms}.  These objects can be rigid
289   collections of atoms or atoms which have orientational degrees of
290 < freedom.  Here is a diagram of the class heirarchy:
291 <
290 > freedom.  A diagram of the class heirarchy is illustrated in
291 > Fig.~\ref{oopseFig:heirarchy}. Every Molecule, Atom and
292 > DirectionalAtom in {\sc OOPSE} have their own names which are
293 > specified in the {\tt .md} file. In contrast, RigidBodies are
294 > denoted by their membership and index inside a particular molecule:
295 > [MoleculeName]\_RB\_[index] (the contents inside the brackets depend
296 > on the specifics of the simulation). The names of rigid bodies are
297 > generated automatically. For example, the name of the first rigid
298 > body in a DMPC molecule is DMPC\_RB\_0.
299   \begin{figure}
300   \centering
301 < \includegraphics[width=3in]{heirarchy.eps}
302 < \caption[Class heirarchy for StuntDoubles in {\sc oopse}-3.0]{ The
303 < class heirarchy of StuntDoubles in {\sc oopse}-3.0.
301 > \includegraphics[width=\linewidth]{heirarchy.eps}
302 > \caption[Class heirarchy for ojects in {\sc OOPSE}]{ A diagram of
303 > the class heirarchy.
304   \begin{itemize}
305   \item A {\bf StuntDouble} is {\it any} object that can be manipulated by the
306   integrators and minimizers.
# Line 309 | Line 308 | DirectionalAtom}s which behaves as a single unit.
308   \item A {\bf DirectionalAtom} is an atom which has {\it orientational} as well as translational degrees of freedom.
309   \item A {\bf RigidBody} is a collection of {\bf Atom}s or {\bf
310   DirectionalAtom}s which behaves as a single unit.
311 < \end{itemize}} \label{oopseFig:heirarchy}
311 > \end{itemize}
312 > } \label{oopseFig:heirarchy}
313   \end{figure}
314 –
315 – Every Molecule, Atom and DirectionalAtom in {\sc OOPSE} have their
316 – own names which are specified in the {\tt .md} file. In contrast,
317 – RigidBodies are denoted by their membership and index inside a
318 – particular molecule: [MoleculeName]\_RB\_[index] (the contents
319 – inside the brackets depend on the specifics of the simulation). The
320 – names of rigid bodies are generated automatically. For example, the
321 – name of the first rigid body in a DMPC molecule is DMPC\_RB\_0.
314  
315   \section{\label{appendixSection:syntax}Syntax of the Select Command}
316  

Diff Legend

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