| 179 |
|
public: |
| 180 |
|
typedef std::map<string, IntegratorCreator*> CreatorMapType; |
| 181 |
|
|
| 182 |
< |
bool registerIntegrator(IntegratorCreator* creator); |
| 182 |
> |
bool registerIntegrator(IntegratorCreator* creator) { |
| 183 |
> |
return creatorMap_.insert(creator->getIdent(), creator).second; |
| 184 |
> |
} |
| 185 |
|
|
| 186 |
< |
Integrator* createIntegrator(const string& id, SimInfo* info); |
| 186 |
> |
Integrator* createIntegrator(const string& id, SimInfo* info) { |
| 187 |
> |
Integrator* result = NULL; |
| 188 |
> |
CreatorMapType::iterator i = creatorMap_.find(id); |
| 189 |
> |
if (i != creatorMap_.end()) { |
| 190 |
> |
result = (i->second)->create(info); |
| 191 |
> |
} |
| 192 |
> |
return result; |
| 193 |
> |
} |
| 194 |
|
|
| 195 |
|
private: |
| 196 |
|
CreatorMapType creatorMap_; |
| 197 |
|
}; |
| 189 |
– |
|
| 198 |
|
\end{lstlisting} |
| 199 |
+ |
\begin{lstlisting}[float,caption={[The implementation of Factory pattern (III)]Souce code of creator classes.},label={appendixScheme:integratorCreator}] |
| 200 |
|
|
| 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 |
– |
|
| 201 |
|
class IntegratorCreator { |
| 202 |
|
public: |
| 203 |
|
IntegratorCreator(const string& ident) : ident_(ident) {} |
| 234 |
|
|
| 235 |
|
\begin{figure} |
| 236 |
|
\centering |
| 237 |
< |
\includegraphics[width=\linewidth]{architecture.eps} |
| 237 |
> |
\includegraphics[width=\linewidth]{visitor.eps} |
| 238 |
|
\caption[The architecture of {\sc OOPSE}] {Overview of the structure |
| 239 |
|
of {\sc OOPSE}} \label{appendixFig:visitorUML} |
| 240 |
|
\end{figure} |
| 279 |
|
}; |
| 280 |
|
|
| 281 |
|
\end{lstlisting} |
| 282 |
+ |
|
| 283 |
|
\section{\label{appendixSection:concepts}Concepts} |
| 284 |
|
|
| 285 |
|
OOPSE manipulates both traditional atoms as well as some objects |
| 286 |
|
that {\it behave like atoms}. These objects can be rigid |
| 287 |
|
collections of atoms or atoms which have orientational degrees of |
| 288 |
< |
freedom. Here is a diagram of the class heirarchy: |
| 289 |
< |
|
| 288 |
> |
freedom. A diagram of the class heirarchy is illustrated in |
| 289 |
> |
Fig.~\ref{oopseFig:heirarchy}. Every Molecule, Atom and |
| 290 |
> |
DirectionalAtom in {\sc OOPSE} have their own names which are |
| 291 |
> |
specified in the {\tt .md} file. In contrast, RigidBodies are |
| 292 |
> |
denoted by their membership and index inside a particular molecule: |
| 293 |
> |
[MoleculeName]\_RB\_[index] (the contents inside the brackets depend |
| 294 |
> |
on the specifics of the simulation). The names of rigid bodies are |
| 295 |
> |
generated automatically. For example, the name of the first rigid |
| 296 |
> |
body in a DMPC molecule is DMPC\_RB\_0. |
| 297 |
|
\begin{figure} |
| 298 |
|
\centering |
| 299 |
< |
\includegraphics[width=3in]{heirarchy.eps} |
| 300 |
< |
\caption[Class heirarchy for StuntDoubles in {\sc oopse}-3.0]{ \\ |
| 301 |
< |
The class heirarchy of StuntDoubles in {\sc oopse}-3.0. The |
| 305 |
< |
selection syntax allows the user to select any of the objects that |
| 306 |
< |
are descended from a StuntDouble.} \label{oopseFig:heirarchy} |
| 307 |
< |
\end{figure} |
| 308 |
< |
|
| 299 |
> |
\includegraphics[width=\linewidth]{heirarchy.eps} |
| 300 |
> |
\caption[Class heirarchy for ojects in {\sc OOPSE}]{ A diagram of |
| 301 |
> |
the class heirarchy. |
| 302 |
|
\begin{itemize} |
| 303 |
|
\item A {\bf StuntDouble} is {\it any} object that can be manipulated by the |
| 304 |
|
integrators and minimizers. |
| 307 |
|
\item A {\bf RigidBody} is a collection of {\bf Atom}s or {\bf |
| 308 |
|
DirectionalAtom}s which behaves as a single unit. |
| 309 |
|
\end{itemize} |
| 310 |
< |
|
| 311 |
< |
Every Molecule, Atom and DirectionalAtom in {\sc OOPSE} have their |
| 319 |
< |
own names which are specified in the {\tt .md} file. In contrast, |
| 320 |
< |
RigidBodies are denoted by their membership and index inside a |
| 321 |
< |
particular molecule: [MoleculeName]\_RB\_[index] (the contents |
| 322 |
< |
inside the brackets depend on the specifics of the simulation). The |
| 323 |
< |
names of rigid bodies are generated automatically. For example, the |
| 324 |
< |
name of the first rigid body in a DMPC molecule is DMPC\_RB\_0. |
| 310 |
> |
} \label{oopseFig:heirarchy} |
| 311 |
> |
\end{figure} |
| 312 |
|
|
| 313 |
|
\section{\label{appendixSection:syntax}Syntax of the Select Command} |
| 314 |
|
|
