Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/molecule_template.hpp

    r273382 rd74077  
    1919/********************************************** declarations *******************************/
    2020
    21 // ================== Acting on all Vectors ========================== //
    22 
    23 // zero arguments
    24 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
    25     {
    26   atom *Walker = start;
    27   while (Walker->next != end) {
    28     Walker = Walker->next;
    29     ((Walker->node)->*f)();
    30   }
    31 };
    32 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
    33     {
    34   atom *Walker = start;
    35   while (Walker->next != end) {
    36     Walker = Walker->next;
    37     ((Walker->node)->*f)();
    38   }
    39 };
    40 // one argument
    41 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
    42 {
    43   atom *Walker = start;
    44   while (Walker->next != end) {
    45     Walker = Walker->next;
    46     ((Walker->node)->*f)(t);
    47   }
    48 };
    49 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
    50 {
    51   atom *Walker = start;
    52   while (Walker->next != end) {
    53     Walker = Walker->next;
    54     ((Walker->node)->*f)(t);
    55   }
    56 };
    57 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&), T &t ) const
    58 {
    59   atom *Walker = start;
    60   while (Walker->next != end) {
    61     Walker = Walker->next;
    62     ((Walker->node)->*f)(t);
    63   }
    64 };
    65 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&) const, T &t ) const
    66 {
    67   atom *Walker = start;
    68   while (Walker->next != end) {
    69     Walker = Walker->next;
    70     ((Walker->node)->*f)(t);
    71   }
    72 };
    73 // two arguments
    74 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
    75 {
    76   atom *Walker = start;
    77   while (Walker->next != end) {
    78     Walker = Walker->next;
    79     ((Walker->node)->*f)(t, u);
    80   }
    81 };
    82 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
    83 {
    84   atom *Walker = start;
    85   while (Walker->next != end) {
    86     Walker = Walker->next;
    87     ((Walker->node)->*f)(t, u);
    88   }
    89 };
    90 // three arguments
    91 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
    92 {
    93   atom *Walker = start;
    94   while (Walker->next != end) {
    95     Walker = Walker->next;
    96     ((Walker->node)->*f)(t, u, v);
    97   }
    98 };
    99 template <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
    100 {
    101   atom *Walker = start;
    102   while (Walker->next != end) {
    103     Walker = Walker->next;
    104     ((Walker->node)->*f)(t, u, v);
    105   }
    106 };
    10721
    10822// ========================= Summing over each Atoms =================================== //
    … …  
    11226{
    11327  res result = 0;
    114   atom *Walker = start;
    115   while (Walker->next != end) {
    116     Walker = Walker->next;
    117     result += (Walker->*f)();
     28  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     29    result += ((*iter)->*f)();
    11830  }
    11931  return result;
    … …  
    12234{
    12335  res result = 0;
    124   atom *Walker = start;
    125   while (Walker->next != end) {
    126     Walker = Walker->next;
    127     result += (Walker->*f)();
     36  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     37    result += ((*iter)->*f)();
    12838  }
    12939  return result;
    … …  
    13343{
    13444  res result = 0;
    135   atom *Walker = start;
    136   while (Walker->next != end) {
    137     Walker = Walker->next;
    138     result += (Walker->*f)(t);
     45  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     46    result += ((*iter)->*f)(t);
    13947  }
    14048  return result;
    … …  
    14351{
    14452  res result = 0;
    145   atom *Walker = start;
    146   while (Walker->next != end) {
    147     Walker = Walker->next;
    148     result += (Walker->*f)(t);
     53  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     54    result += ((*iter)->*f)(t);
    14955  }
    15056  return result;
    … …  
    15763template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
    15864{
    159   atom *Walker = start;
    160   while (Walker->next != end) {
    161     Walker = Walker->next;
    162     (*f)(Walker);
     65  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     66    (*f)((*iter));
    16367  }
    16468};
    16569template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
    16670{
    167   atom *Walker = start;
    168   while (Walker->next != end) {
    169     Walker = Walker->next;
    170     (*f)(Walker);
     71  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     72    (*f)((*iter));
    17173  }
    17274};
    … …  
    17779template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
    17880{
    179   atom *Walker = start;
    180   while (Walker->next != end) {
    181     Walker = Walker->next;
    182     (copy->*f)(Walker);
     81  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     82    (copy->*f)((*iter));
    18383  }
    18484};
    18585template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
    18686{
    187   atom *Walker = start;
    188   while (Walker->next != end) {
    189     Walker = Walker->next;
    190     (copy->*f)(Walker);
     87  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     88    (copy->*f)((*iter));
    19189  }
    19290};
    … …  
    19795template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
    19896{
    199   atom *Walker = start;
    200   while (Walker->next != end) {
    201     Walker = Walker->next;
    202     if ((Walker->*condition)())
    203       (copy->*f)(Walker);
     97  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     98    if (((*iter)->*condition)())
     99      (copy->*f)((*iter));
    204100  }
    205101};
    206102template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const
    207103{
    208   atom *Walker = start;
    209   while (Walker->next != end) {
    210     Walker = Walker->next;
    211     if ((Walker->*condition)())
    212       (copy->*f)(Walker);
     104  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     105    if (((*iter)->*condition)())
     106      (copy->*f)((*iter));
    213107  }
    214108};
    215109template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const
    216110{
    217   atom *Walker = start;
    218   while (Walker->next != end) {
    219     Walker = Walker->next;
    220     if ((Walker->*condition)())
    221       (copy->*f)(Walker);
     111  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     112    if (((*iter)->*condition)())
     113      (copy->*f)((*iter));
    222114  }
    223115};
    224116template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) () const ) const
    225117{
    226   atom *Walker = start;
    227   while (Walker->next != end) {
    228     Walker = Walker->next;
    229     if ((Walker->*condition)())
    230       (copy->*f)(Walker);
     118  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     119    if (((*iter)->*condition)())
     120      (copy->*f)((*iter));
    231121  }
    232122};
    … …  
    234124template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const
    235125{
    236   atom *Walker = start;
    237   while (Walker->next != end) {
    238     Walker = Walker->next;
    239     if ((Walker->*condition)(t))
    240       (copy->*f)(Walker);
     126  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     127    if (((*iter)->*condition)(t))
     128      (copy->*f)((*iter));
    241129  }
    242130};
    243131template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const
    244132{
    245   atom *Walker = start;
    246   while (Walker->next != end) {
    247     Walker = Walker->next;
    248     if ((Walker->*condition)(t))
    249       (copy->*f)(Walker);
     133  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     134    if (((*iter)->*condition)(t))
     135      (copy->*f)((*iter));
    250136  }
    251137};
    252138template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T), T t ) const
    253139{
    254   atom *Walker = start;
    255   while (Walker->next != end) {
    256     Walker = Walker->next;
    257     if ((Walker->*condition)(t))
    258       (copy->*f)(Walker);
     140  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     141    if (((*iter)->*condition)(t))
     142      (copy->*f)((*iter));
    259143  }
    260144};
    261145template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T) const, T t ) const
    262146{
    263   atom *Walker = start;
    264   while (Walker->next != end) {
    265     Walker = Walker->next;
    266     if ((Walker->*condition)(t))
    267       (copy->*f)(Walker);
     147  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     148    if (((*iter)->*condition)(t))
     149      (copy->*f)((*iter));
    268150  }
    269151};
    … …  
    271153template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
    272154{
    273   atom *Walker = start;
    274   while (Walker->next != end) {
    275     Walker = Walker->next;
    276     if ((Walker->*condition)(t,u))
    277       (copy->*f)(Walker);
     155  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     156    if (((*iter)->*condition)(t,u))
     157      (copy->*f)((*iter));
    278158  }
    279159};
    280160template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
    281161{
    282   atom *Walker = start;
    283   while (Walker->next != end) {
    284     Walker = Walker->next;
    285     if ((Walker->*condition)(t,u))
    286       (copy->*f)(Walker);
     162  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     163    if (((*iter)->*condition)(t,u))
     164      (copy->*f)((*iter));
    287165  }
    288166};
    289167template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
    290168{
    291   atom *Walker = start;
    292   while (Walker->next != end) {
    293     Walker = Walker->next;
    294     if ((Walker->*condition)(t,u))
    295       (copy->*f)(Walker);
     169  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     170    if (((*iter)->*condition)(t,u))
     171      (copy->*f)((*iter));
    296172  }
    297173};
    298174template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
    299175{
    300   atom *Walker = start;
    301   while (Walker->next != end) {
    302     Walker = Walker->next;
    303     if ((Walker->*condition)(t,u))
    304       (copy->*f)(Walker);
     176  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     177    if (((*iter)->*condition)(t,u))
     178      (copy->*f)((*iter));
    305179  }
    306180};
    … …  
    308182template <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 ) const
    309183{
    310   atom *Walker = start;
    311   while (Walker->next != end) {
    312     Walker = Walker->next;
    313     if ((Walker->*condition)(t,u,v))
    314       (copy->*f)(Walker);
     184  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     185    if (((*iter)->*condition)(t,u,v))
     186      (copy->*f)((*iter));
    315187  }
    316188};
    317189template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
    318190{
    319   atom *Walker = start;
    320   while (Walker->next != end) {
    321     Walker = Walker->next;
    322     if ((Walker->*condition)(t,u,v))
    323       (copy->*f)(Walker);
     191  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     192    if (((*iter)->*condition)(t,u,v))
     193      (copy->*f)((*iter));
    324194  }
    325195};
    326196template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
    327197{
    328   atom *Walker = start;
    329   while (Walker->next != end) {
    330     Walker = Walker->next;
    331     if ((Walker->*condition)(t,u,v))
    332       (copy->*f)(Walker);
     198  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     199    if (((*iter)->*condition)(t,u,v))
     200      (copy->*f)((*iter));
    333201  }
    334202};
    335203template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
    336204{
    337   atom *Walker = start;
    338   while (Walker->next != end) {
    339     Walker = Walker->next;
    340     if ((Walker->*condition)(t,u,v))
    341       (copy->*f)(Walker);
     205  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     206    if (((*iter)->*condition)(t,u,v))
     207      (copy->*f)((*iter));
    342208  }
    343209};
    … …  
    348214template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
    349215{
    350   atom *Walker = start;
    351   while (Walker->next != end) {
    352     Walker = Walker->next;
    353     (Walker->*f)();
     216  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     217    ((*iter)->*f)();
    354218  }
    355219};
    356220template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
    357221{
    358   atom *Walker = start;
    359   while (Walker->next != end) {
    360     Walker = Walker->next;
    361     (Walker->*f)();
     222  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     223    ((*iter)->*f)();
    362224  }
    363225};
    … …  
    365227template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
    366228{
    367   atom *Walker = start;
    368   while (Walker->next != end) {
    369     Walker = Walker->next;
    370     (Walker->*f)(t);
     229  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     230    ((*iter)->*f)(t);
    371231  }
    372232};
    373233template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
    374234{
    375   atom *Walker = start;
    376   while (Walker->next != end) {
    377     Walker = Walker->next;
    378     (Walker->*f)(t);
     235  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     236    ((*iter)->*f)(t);
    379237  }
    380238};
    … …  
    382240template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
    383241{
    384   atom *Walker = start;
    385   while (Walker->next != end) {
    386     Walker = Walker->next;
    387     (Walker->*f)(t, u);
     242  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     243    ((*iter)->*f)(t, u);
    388244  }
    389245};
    390246template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
    391247{
    392   atom *Walker = start;
    393   while (Walker->next != end) {
    394     Walker = Walker->next;
    395     (Walker->*f)(t, u);
     248  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     249    ((*iter)->*f)(t, u);
    396250  }
    397251};
    … …  
    399253template <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
    400254{
    401   atom *Walker = start;
    402   while (Walker->next != end) {
    403     Walker = Walker->next;
    404     (Walker->*f)(t, u, v);
     255  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     256    ((*iter)->*f)(t, u, v);
    405257  }
    406258};
    407259template <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
    408260{
    409   atom *Walker = start;
    410   while (Walker->next != end) {
    411     Walker = Walker->next;
    412     (Walker->*f)(t, u, v);
     261  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     262    ((*iter)->*f)(t, u, v);
    413263  }
    414264};
    … …  
    416266template <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
    417267{
    418   atom *Walker = start;
    419   while (Walker->next != end) {
    420     Walker = Walker->next;
    421     (Walker->*f)(t, u, v, w);
     268  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     269    ((*iter)->*f)(t, u, v, w);
    422270  }
    423271};
    424272template <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
    425273{
    426   atom *Walker = start;
    427   while (Walker->next != end) {
    428     Walker = Walker->next;
    429     (Walker->*f)(t, u, v, w);
     274  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     275    ((*iter)->*f)(t, u, v, w);
    430276  }
    431277};
    … …  
    436282template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
    437283{
    438   atom *Walker = start;
    439284  int inc = 1;
    440   while (Walker->next != end) {
    441     Walker = Walker->next;
    442     (*Setor) (&array[(Walker->*index)], &inc);
     285  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     286    (*Setor) (&array[((*iter)->*index)], &inc);
    443287  }
    444288};
    445289template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
    446290{
    447   atom *Walker = start;
    448   while (Walker->next != end) {
    449     Walker = Walker->next;
    450     (*Setor) (&array[(Walker->*index)], &value);
     291  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     292    (*Setor) (&array[((*iter)->*index)], &value);
    451293  }
    452294};
    453295template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
    454296{
    455   atom *Walker = start;
    456   while (Walker->next != end) {
    457     Walker = Walker->next;
    458     (*Setor) (&array[(Walker->*index)], value);
     297  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     298    (*Setor) (&array[((*iter)->*index)], value);
    459299  }
    460300};
    … …  
    462302template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
    463303{
    464   atom *Walker = start;
    465304  int inc = 1;
    466   while (Walker->next != end) {
    467     Walker = Walker->next;
    468     (*Setor) (&array[(Walker->type->*index)], &inc);
     305  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     306    (*Setor) (&array[((*iter)->getType()->*index)], &inc);
    469307  }
    470308};
    471309template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
    472310{
    473   atom *Walker = start;
    474   while (Walker->next != end) {
    475     Walker = Walker->next;
    476     (*Setor) (&array[(Walker->type->*index)], &value);
     311  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     312    (*Setor) (&array[((*iter)->getType()->*index)], &value);
    477313  }
    478314};
    479315template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
    480316{
    481   atom *Walker = start;
    482   while (Walker->next != end) {
    483     Walker = Walker->next;
    484     (*Setor) (&array[(Walker->type->*index)], value);
     317  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     318    (*Setor) (&array[((*iter)->getType()->*index)], value);
    485319  }
    486320};
    … …  
    488322template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
    489323{
    490   atom *Walker = start;
    491   while (Walker->next != end) {
    492     Walker = Walker->next;
    493     array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
     324  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     325    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
    494326  }
    495327};
    496328template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value ) const
    497329{
    498   atom *Walker = start;
    499   while (Walker->next != end) {
    500     Walker = Walker->next;
    501     array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
     330  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     331    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
    502332  }
    503333};
    504334template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
    505335{
    506   atom *Walker = start;
    507   while (Walker->next != end) {
    508     Walker = Walker->next;
    509     array[(Walker->*index)] = (Walker->*Setor) (vect);
     336  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     337    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
    510338  }
    511339};
    512340template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const
    513341{
    514   atom *Walker = start;
    515   while (Walker->next != end) {
    516     Walker = Walker->next;
    517     array[(Walker->*index)] = (Walker->*Setor) (vect);
     342  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     343    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
    518344  }
    519345};
    520346template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
    521347{
    522   atom *Walker = start;
    523   while (Walker->next != end) {
    524     Walker = Walker->next;
    525     Walker->*value = array[(Walker->*index)];
    526     //Log() << Verbose(2) << *Walker << " gets " << (Walker->*value); << endl;
     348  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     349    (*iter)->*value = array[((*iter)->*index)];
     350    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*value); << endl;
    527351  }
    528352};
    … …  
    530354template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr ) const
    531355{
    532   atom *Walker = start;
    533   while (Walker->next != end) {
    534     Walker = Walker->next;
    535     Walker->*ptr = value;
    536     //Log() << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
     356  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     357    (*iter)->*ptr = value;
     358    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*ptr) << endl;
    537359  }
    538360};
Note: See TracChangeset for help on using the changeset viewer.