source: molecuilder/src/molecule_template.hpp@ 6b937bd

Last change on this file since 6b937bd was 6b937bd, checked in by Frederik Heber <heber@…>, 16 years ago

Huge Refactoring: class atom split up into several inherited classes.
  • Property mode set to 100644
File size: 17.7 KB
RevLine 
[8ffe32]1/*
2 * molecule_template.hpp
3 *
4 * Created on: Oct 6, 2009
5 * Author: heber
6 */
7
8#ifndef MOLECULE_TEMPLATE_HPP_
9#define MOLECULE_TEMPLATE_HPP_
10
[17b3a5c]11/*********************************************** includes ***********************************/
12
13// include config.h
14#ifdef HAVE_CONFIG_H
15#include <config.h>
16#endif
17
18/********************************************** declarations *******************************/
19
[8ffe32]20// ================== Acting on all Vectors ========================== //
21
22// zero arguments
23template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() )
24{
25 atom *Walker = start;
26 while (Walker->next != end) {
27 Walker = Walker->next;
28 ((Walker->node)->*f)();
29 }
30};
31template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const )
32{
33 atom *Walker = start;
34 while (Walker->next != end) {
35 Walker = Walker->next;
36 ((Walker->node)->*f)();
37 }
38};
39template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
40 {
41 atom *Walker = start;
42 while (Walker->next != end) {
43 Walker = Walker->next;
44 ((Walker->node)->*f)();
45 }
46};
[3efb4a]47template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
48 {
49 atom *Walker = start;
50 while (Walker->next != end) {
51 Walker = Walker->next;
52 ((Walker->node)->*f)();
53 }
54};
[8ffe32]55// one argument
56template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t )
57{
58 atom *Walker = start;
59 while (Walker->next != end) {
60 Walker = Walker->next;
61 ((Walker->node)->*f)(t);
62 }
63};
64template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t )
65{
66 atom *Walker = start;
67 while (Walker->next != end) {
68 Walker = Walker->next;
69 ((Walker->node)->*f)(t);
70 }
71};
72template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
73{
74 atom *Walker = start;
75 while (Walker->next != end) {
76 Walker = Walker->next;
77 ((Walker->node)->*f)(t);
78 }
79};
[3efb4a]80template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
81{
82 atom *Walker = start;
83 while (Walker->next != end) {
84 Walker = Walker->next;
85 ((Walker->node)->*f)(t);
86 }
87};
[8ffe32]88// two arguments
89template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u )
90{
91 atom *Walker = start;
92 while (Walker->next != end) {
93 Walker = Walker->next;
94 ((Walker->node)->*f)(t, u);
95 }
96};
97template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u )
98{
99 atom *Walker = start;
100 while (Walker->next != end) {
101 Walker = Walker->next;
102 ((Walker->node)->*f)(t, u);
103 }
104};
105template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
106{
107 atom *Walker = start;
108 while (Walker->next != end) {
109 Walker = Walker->next;
110 ((Walker->node)->*f)(t, u);
111 }
112};
[3efb4a]113template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
114{
115 atom *Walker = start;
116 while (Walker->next != end) {
117 Walker = Walker->next;
118 ((Walker->node)->*f)(t, u);
119 }
120};
[8ffe32]121// three arguments
122template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v)
123{
124 atom *Walker = start;
125 while (Walker->next != end) {
126 Walker = Walker->next;
127 ((Walker->node)->*f)(t, u, v);
128 }
129};
130template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v)
131{
132 atom *Walker = start;
133 while (Walker->next != end) {
134 Walker = Walker->next;
135 ((Walker->node)->*f)(t, u, v);
136 }
137};
138template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
139{
140 atom *Walker = start;
141 while (Walker->next != end) {
142 Walker = Walker->next;
143 ((Walker->node)->*f)(t, u, v);
144 }
145};
[3efb4a]146template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
147{
148 atom *Walker = start;
149 while (Walker->next != end) {
150 Walker = Walker->next;
151 ((Walker->node)->*f)(t, u, v);
152 }
153};
[8ffe32]154
[872b51]155// ========================= Summing over each Atoms =================================== //
156
157// zero arguments
[6b937bd]158template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() )
[872b51]159{
160 res result = 0;
161 atom *Walker = start;
162 while (Walker->next != end) {
163 Walker = Walker->next;
164 result += (Walker->*f)();
165 }
166 return result;
167};
[6b937bd]168template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() const )
[872b51]169{
170 res result = 0;
171 atom *Walker = start;
172 while (Walker->next != end) {
173 Walker = Walker->next;
174 result += (Walker->*f)();
175 }
176 return result;
177};
[6b937bd]178template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() ) const
[872b51]179{
180 res result = 0;
181 atom *Walker = start;
182 while (Walker->next != end) {
183 Walker = Walker->next;
184 result += (Walker->*f)();
185 }
186 return result;
187};
[6b937bd]188template <typename res, typename typ> res molecule::SumPerAtom(res (typ::*f)() const ) const
[872b51]189{
190 res result = 0;
191 atom *Walker = start;
192 while (Walker->next != end) {
193 Walker = Walker->next;
194 result += (Walker->*f)();
195 }
196 return result;
197};
198// one argument
[6b937bd]199template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T), T t )
[872b51]200{
201 res result = 0;
202 atom *Walker = start;
203 while (Walker->next != end) {
204 Walker = Walker->next;
205 result += (Walker->*f)(t);
206 }
207 return result;
208};
[6b937bd]209template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T) const, T t )
[872b51]210{
211 res result = 0;
212 atom *Walker = start;
213 while (Walker->next != end) {
214 Walker = Walker->next;
215 result += (Walker->*f)(t);
216 }
217 return result;
218};
[6b937bd]219template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T), T t ) const
[872b51]220{
221 res result = 0;
222 atom *Walker = start;
223 while (Walker->next != end) {
224 Walker = Walker->next;
225 result += (Walker->*f)(t);
226 }
227 return result;
228};
[6b937bd]229template <typename res, typename typ, typename T> res molecule::SumPerAtom(res (typ::*f)(T) const, T t ) const
[872b51]230{
231 res result = 0;
232 atom *Walker = start;
233 while (Walker->next != end) {
234 Walker = Walker->next;
235 result += (Walker->*f)(t);
236 }
237 return result;
238};
239
240
[8ffe32]241// ================== Acting with each Atoms on same molecule ========================== //
242
243// zero arguments
244template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *))
245{
246 atom *Walker = start;
247 while (Walker->next != end) {
248 Walker = Walker->next;
249 (*f)(Walker);
250 }
251};
252template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const)
253{
254 atom *Walker = start;
255 while (Walker->next != end) {
256 Walker = Walker->next;
257 (*f)(Walker);
258 }
259};
260template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
261{
262 atom *Walker = start;
263 while (Walker->next != end) {
264 Walker = Walker->next;
265 (*f)(Walker);
266 }
267};
[3efb4a]268template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
269{
270 atom *Walker = start;
271 while (Walker->next != end) {
272 Walker = Walker->next;
273 (*f)(Walker);
274 }
275};
[8ffe32]276
277// ================== Acting with each Atoms on copy molecule ========================== //
278
279// zero arguments
280template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy)
281{
282 atom *Walker = start;
283 while (Walker->next != end) {
284 Walker = Walker->next;
285 (copy->*f)(Walker);
286 }
287};
288template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const , molecule *copy)
289{
290 atom *Walker = start;
291 while (Walker->next != end) {
292 Walker = Walker->next;
293 (copy->*f)(Walker);
294 }
295};
296template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
297{
298 atom *Walker = start;
299 while (Walker->next != end) {
300 Walker = Walker->next;
301 (copy->*f)(Walker);
302 }
303};
[3efb4a]304template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
305{
306 atom *Walker = start;
307 while (Walker->next != end) {
308 Walker = Walker->next;
309 (copy->*f)(Walker);
310 }
311};
[8ffe32]312
313// ================== Acting with each Atoms on copy molecule if true ========================== //
314
315// zero arguments
316template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () )
317{
318 atom *Walker = start;
319 while (Walker->next != end) {
320 Walker = Walker->next;
321 if ((Walker->*condition)())
322 (copy->*f)(Walker);
323 }
324};
325// one argument
326template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t )
327{
328 atom *Walker = start;
329 while (Walker->next != end) {
330 Walker = Walker->next;
331 if ((Walker->*condition)(t))
332 (copy->*f)(Walker);
333 }
334};
335// two arguments
336template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u )
337{
338 atom *Walker = start;
339 while (Walker->next != end) {
340 Walker = Walker->next;
341 if ((Walker->*condition)(t,u))
342 (copy->*f)(Walker);
343 }
344};
345// three arguments
346template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v )
347{
348 atom *Walker = start;
349 while (Walker->next != end) {
350 Walker = Walker->next;
351 if ((Walker->*condition)(t,u,v))
352 (copy->*f)(Walker);
353 }
354};
355
356// ================== Acting on all Atoms ========================== //
357
358// zero arguments
[6b937bd]359template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)())
[8ffe32]360{
361 atom *Walker = start;
362 while (Walker->next != end) {
363 Walker = Walker->next;
364 (Walker->*f)();
365 }
366};
[6b937bd]367template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const)
[8ffe32]368{
369 atom *Walker = start;
370 while (Walker->next != end) {
371 Walker = Walker->next;
372 (Walker->*f)();
373 }
374};
[6b937bd]375template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
[8ffe32]376{
377 atom *Walker = start;
378 while (Walker->next != end) {
379 Walker = Walker->next;
380 (Walker->*f)();
381 }
382};
[6b937bd]383template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
[3efb4a]384{
385 atom *Walker = start;
386 while (Walker->next != end) {
387 Walker = Walker->next;
388 (Walker->*f)();
389 }
390};
[8ffe32]391// one argument
[6b937bd]392template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t )
[8ffe32]393{
394 atom *Walker = start;
395 while (Walker->next != end) {
396 Walker = Walker->next;
397 (Walker->*f)(t);
398 }
399};
[6b937bd]400template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t )
[8ffe32]401{
402 atom *Walker = start;
403 while (Walker->next != end) {
404 Walker = Walker->next;
405 (Walker->*f)(t);
406 }
407};
[6b937bd]408template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
[3efb4a]409{
410 atom *Walker = start;
411 while (Walker->next != end) {
412 Walker = Walker->next;
413 (Walker->*f)(t);
414 }
415};
[6b937bd]416template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
[8ffe32]417{
418 atom *Walker = start;
419 while (Walker->next != end) {
420 Walker = Walker->next;
421 (Walker->*f)(t);
422 }
423};
424// two argument
[6b937bd]425template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u )
[8ffe32]426{
427 atom *Walker = start;
428 while (Walker->next != end) {
429 Walker = Walker->next;
430 (Walker->*f)(t, u);
431 }
432};
[6b937bd]433template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u )
[8ffe32]434{
435 atom *Walker = start;
436 while (Walker->next != end) {
437 Walker = Walker->next;
438 (Walker->*f)(t, u);
439 }
440};
[6b937bd]441template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
[8ffe32]442{
443 atom *Walker = start;
444 while (Walker->next != end) {
445 Walker = Walker->next;
446 (Walker->*f)(t, u);
447 }
448};
[6b937bd]449template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
[3efb4a]450{
451 atom *Walker = start;
452 while (Walker->next != end) {
453 Walker = Walker->next;
454 (Walker->*f)(t, u);
455 }
456};
[8ffe32]457// three argument
[6b937bd]458template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v)
[8ffe32]459{
460 atom *Walker = start;
461 while (Walker->next != end) {
462 Walker = Walker->next;
463 (Walker->*f)(t, u, v);
464 }
465};
[6b937bd]466template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v)
[8ffe32]467{
468 atom *Walker = start;
469 while (Walker->next != end) {
470 Walker = Walker->next;
471 (Walker->*f)(t, u, v);
472 }
473};
[6b937bd]474template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const
[8ffe32]475{
476 atom *Walker = start;
477 while (Walker->next != end) {
478 Walker = Walker->next;
479 (Walker->*f)(t, u, v);
480 }
481};
[6b937bd]482template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const
[3efb4a]483{
484 atom *Walker = start;
485 while (Walker->next != end) {
486 Walker = Walker->next;
487 (Walker->*f)(t, u, v);
488 }
489};
[8ffe32]490// four arguments
[6b937bd]491template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w)
[8ffe32]492{
493 atom *Walker = start;
494 while (Walker->next != end) {
495 Walker = Walker->next;
496 (Walker->*f)(t, u, v, w);
497 }
498};
[6b937bd]499template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w)
[8ffe32]500{
501 atom *Walker = start;
502 while (Walker->next != end) {
503 Walker = Walker->next;
504 (Walker->*f)(t, u, v, w);
505 }
506};
[6b937bd]507template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const
[8ffe32]508{
509 atom *Walker = start;
510 while (Walker->next != end) {
511 Walker = Walker->next;
512 (Walker->*f)(t, u, v, w);
513 }
514};
[6b937bd]515template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const
[3efb4a]516{
517 atom *Walker = start;
518 while (Walker->next != end) {
519 Walker = Walker->next;
520 (Walker->*f)(t, u, v, w);
521 }
522};
[8ffe32]523
[7c2f6b]524// ===================== Accessing arrays indexed by some integer for each atom ======================
[8ffe32]525
526// for atom ints
[6b937bd]527template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) )
[8ffe32]528{
529 atom *Walker = start;
[ff9879]530 int inc = 1;
[8ffe32]531 while (Walker->next != end) {
532 Walker = Walker->next;
[ff9879]533 (*Setor) (&array[(Walker->*index)], &inc);
[8ffe32]534 }
535};
[6b937bd]536template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value )
[ff9879]537{
538 atom *Walker = start;
539 while (Walker->next != end) {
540 Walker = Walker->next;
541 (*Setor) (&array[(Walker->*index)], &value);
542 }
543};
[6b937bd]544template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value )
[8ffe32]545{
546 atom *Walker = start;
547 while (Walker->next != end) {
548 Walker = Walker->next;
549 (*Setor) (&array[(Walker->*index)], value);
550 }
551};
[6b937bd]552// for element ints
[ff9879]553template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) )
[8ffe32]554{
555 atom *Walker = start;
[ff9879]556 int inc = 1;
[8ffe32]557 while (Walker->next != end) {
558 Walker = Walker->next;
[ff9879]559 (*Setor) (&array[(Walker->type->*index)], &inc);
[8ffe32]560 }
561};
[ff9879]562template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value )
563{
564 atom *Walker = start;
565 while (Walker->next != end) {
566 Walker = Walker->next;
567 (*Setor) (&array[(Walker->type->*index)], &value);
568 }
569};
570template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value )
[8ffe32]571{
572 atom *Walker = start;
573 while (Walker->next != end) {
574 Walker = Walker->next;
575 (*Setor) (&array[(Walker->type->*index)], value);
576 }
577};
[6b937bd]578
579template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(Vector &), Vector atom::*value )
[3efb4a]580{
581 atom *Walker = start;
582 while (Walker->next != end) {
583 Walker = Walker->next;
584 array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
585 }
586};
[6b937bd]587template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(Vector &), Vector &vect )
[3efb4a]588{
589 atom *Walker = start;
590 while (Walker->next != end) {
591 Walker = Walker->next;
592 array[(Walker->*index)] = (Walker->*Setor) (vect);
593 }
594};
[8ffe32]595
[6b937bd]596template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value )
[ff9879]597{
598 atom *Walker = start;
599 while (Walker->next != end) {
600 Walker = Walker->next;
601 Walker->*value = array[(Walker->*index)];
602 //cout << Verbose(2) << *Walker << " gets " << (Walker->*value); << endl;
603 }
604};
605
[6b937bd]606template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr )
[6e250f]607{
608 atom *Walker = start;
609 while (Walker->next != end) {
610 Walker = Walker->next;
611 Walker->*ptr = value;
612 //cout << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
613 }
614};
615
[ff9879]616
[8ffe32]617#endif /* MOLECULE_TEMPLATE_HPP_ */
Note: See TracBrowser for help on using the repository browser.