Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/molecule_template.hpp

    rd74077 r273382  
    1919/********************************************** declarations *******************************/
    2020
     21// ================== Acting on all Vectors ========================== //
     22
     23// zero arguments
     24template <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};
     32template <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
     41template <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};
     49template <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};
     57template <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};
     65template <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
     74template <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};
     82template <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
     91template <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};
     99template <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};
    21107
    22108// ========================= Summing over each Atoms =================================== //
    … …  
    26112{
    27113  res result = 0;
    28   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    29     result += ((*iter)->*f)();
     114  atom *Walker = start;
     115  while (Walker->next != end) {
     116    Walker = Walker->next;
     117    result += (Walker->*f)();
    30118  }
    31119  return result;
    … …  
    34122{
    35123  res result = 0;
    36   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    37     result += ((*iter)->*f)();
     124  atom *Walker = start;
     125  while (Walker->next != end) {
     126    Walker = Walker->next;
     127    result += (Walker->*f)();
    38128  }
    39129  return result;
    … …  
    43133{
    44134  res result = 0;
    45   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    46     result += ((*iter)->*f)(t);
     135  atom *Walker = start;
     136  while (Walker->next != end) {
     137    Walker = Walker->next;
     138    result += (Walker->*f)(t);
    47139  }
    48140  return result;
    … …  
    51143{
    52144  res result = 0;
    53   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    54     result += ((*iter)->*f)(t);
     145  atom *Walker = start;
     146  while (Walker->next != end) {
     147    Walker = Walker->next;
     148    result += (Walker->*f)(t);
    55149  }
    56150  return result;
    … …  
    63157template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
    64158{
    65   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    66     (*f)((*iter));
     159  atom *Walker = start;
     160  while (Walker->next != end) {
     161    Walker = Walker->next;
     162    (*f)(Walker);
    67163  }
    68164};
    69165template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
    70166{
    71   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    72     (*f)((*iter));
     167  atom *Walker = start;
     168  while (Walker->next != end) {
     169    Walker = Walker->next;
     170    (*f)(Walker);
    73171  }
    74172};
    … …  
    79177template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
    80178{
    81   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    82     (copy->*f)((*iter));
     179  atom *Walker = start;
     180  while (Walker->next != end) {
     181    Walker = Walker->next;
     182    (copy->*f)(Walker);
    83183  }
    84184};
    85185template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
    86186{
    87   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    88     (copy->*f)((*iter));
     187  atom *Walker = start;
     188  while (Walker->next != end) {
     189    Walker = Walker->next;
     190    (copy->*f)(Walker);
    89191  }
    90192};
    … …  
    95197template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
    96198{
    97   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    98     if (((*iter)->*condition)())
    99       (copy->*f)((*iter));
     199  atom *Walker = start;
     200  while (Walker->next != end) {
     201    Walker = Walker->next;
     202    if ((Walker->*condition)())
     203      (copy->*f)(Walker);
    100204  }
    101205};
    102206template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const
    103207{
    104   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    105     if (((*iter)->*condition)())
    106       (copy->*f)((*iter));
     208  atom *Walker = start;
     209  while (Walker->next != end) {
     210    Walker = Walker->next;
     211    if ((Walker->*condition)())
     212      (copy->*f)(Walker);
    107213  }
    108214};
    109215template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const
    110216{
    111   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    112     if (((*iter)->*condition)())
    113       (copy->*f)((*iter));
     217  atom *Walker = start;
     218  while (Walker->next != end) {
     219    Walker = Walker->next;
     220    if ((Walker->*condition)())
     221      (copy->*f)(Walker);
    114222  }
    115223};
    116224template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) () const ) const
    117225{
    118   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    119     if (((*iter)->*condition)())
    120       (copy->*f)((*iter));
     226  atom *Walker = start;
     227  while (Walker->next != end) {
     228    Walker = Walker->next;
     229    if ((Walker->*condition)())
     230      (copy->*f)(Walker);
    121231  }
    122232};
    … …  
    124234template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const
    125235{
    126   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    127     if (((*iter)->*condition)(t))
    128       (copy->*f)((*iter));
     236  atom *Walker = start;
     237  while (Walker->next != end) {
     238    Walker = Walker->next;
     239    if ((Walker->*condition)(t))
     240      (copy->*f)(Walker);
    129241  }
    130242};
    131243template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const
    132244{
    133   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    134     if (((*iter)->*condition)(t))
    135       (copy->*f)((*iter));
     245  atom *Walker = start;
     246  while (Walker->next != end) {
     247    Walker = Walker->next;
     248    if ((Walker->*condition)(t))
     249      (copy->*f)(Walker);
    136250  }
    137251};
    138252template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T), T t ) const
    139253{
    140   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    141     if (((*iter)->*condition)(t))
    142       (copy->*f)((*iter));
     254  atom *Walker = start;
     255  while (Walker->next != end) {
     256    Walker = Walker->next;
     257    if ((Walker->*condition)(t))
     258      (copy->*f)(Walker);
    143259  }
    144260};
    145261template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T) const, T t ) const
    146262{
    147   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    148     if (((*iter)->*condition)(t))
    149       (copy->*f)((*iter));
     263  atom *Walker = start;
     264  while (Walker->next != end) {
     265    Walker = Walker->next;
     266    if ((Walker->*condition)(t))
     267      (copy->*f)(Walker);
    150268  }
    151269};
    … …  
    153271template <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
    154272{
    155   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    156     if (((*iter)->*condition)(t,u))
    157       (copy->*f)((*iter));
     273  atom *Walker = start;
     274  while (Walker->next != end) {
     275    Walker = Walker->next;
     276    if ((Walker->*condition)(t,u))
     277      (copy->*f)(Walker);
    158278  }
    159279};
    160280template <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
    161281{
    162   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    163     if (((*iter)->*condition)(t,u))
    164       (copy->*f)((*iter));
     282  atom *Walker = start;
     283  while (Walker->next != end) {
     284    Walker = Walker->next;
     285    if ((Walker->*condition)(t,u))
     286      (copy->*f)(Walker);
    165287  }
    166288};
    167289template <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
    168290{
    169   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    170     if (((*iter)->*condition)(t,u))
    171       (copy->*f)((*iter));
     291  atom *Walker = start;
     292  while (Walker->next != end) {
     293    Walker = Walker->next;
     294    if ((Walker->*condition)(t,u))
     295      (copy->*f)(Walker);
    172296  }
    173297};
    174298template <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
    175299{
    176   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    177     if (((*iter)->*condition)(t,u))
    178       (copy->*f)((*iter));
     300  atom *Walker = start;
     301  while (Walker->next != end) {
     302    Walker = Walker->next;
     303    if ((Walker->*condition)(t,u))
     304      (copy->*f)(Walker);
    179305  }
    180306};
    … …  
    182308template <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
    183309{
    184   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    185     if (((*iter)->*condition)(t,u,v))
    186       (copy->*f)((*iter));
     310  atom *Walker = start;
     311  while (Walker->next != end) {
     312    Walker = Walker->next;
     313    if ((Walker->*condition)(t,u,v))
     314      (copy->*f)(Walker);
    187315  }
    188316};
    189317template <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
    190318{
    191   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    192     if (((*iter)->*condition)(t,u,v))
    193       (copy->*f)((*iter));
     319  atom *Walker = start;
     320  while (Walker->next != end) {
     321    Walker = Walker->next;
     322    if ((Walker->*condition)(t,u,v))
     323      (copy->*f)(Walker);
    194324  }
    195325};
    196326template <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
    197327{
    198   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    199     if (((*iter)->*condition)(t,u,v))
    200       (copy->*f)((*iter));
     328  atom *Walker = start;
     329  while (Walker->next != end) {
     330    Walker = Walker->next;
     331    if ((Walker->*condition)(t,u,v))
     332      (copy->*f)(Walker);
    201333  }
    202334};
    203335template <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
    204336{
    205   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    206     if (((*iter)->*condition)(t,u,v))
    207       (copy->*f)((*iter));
     337  atom *Walker = start;
     338  while (Walker->next != end) {
     339    Walker = Walker->next;
     340    if ((Walker->*condition)(t,u,v))
     341      (copy->*f)(Walker);
    208342  }
    209343};
    … …  
    214348template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
    215349{
    216   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    217     ((*iter)->*f)();
     350  atom *Walker = start;
     351  while (Walker->next != end) {
     352    Walker = Walker->next;
     353    (Walker->*f)();
    218354  }
    219355};
    220356template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
    221357{
    222   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    223     ((*iter)->*f)();
     358  atom *Walker = start;
     359  while (Walker->next != end) {
     360    Walker = Walker->next;
     361    (Walker->*f)();
    224362  }
    225363};
    … …  
    227365template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
    228366{
    229   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    230     ((*iter)->*f)(t);
     367  atom *Walker = start;
     368  while (Walker->next != end) {
     369    Walker = Walker->next;
     370    (Walker->*f)(t);
    231371  }
    232372};
    233373template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
    234374{
    235   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    236     ((*iter)->*f)(t);
     375  atom *Walker = start;
     376  while (Walker->next != end) {
     377    Walker = Walker->next;
     378    (Walker->*f)(t);
    237379  }
    238380};
    … …  
    240382template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
    241383{
    242   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    243     ((*iter)->*f)(t, u);
     384  atom *Walker = start;
     385  while (Walker->next != end) {
     386    Walker = Walker->next;
     387    (Walker->*f)(t, u);
    244388  }
    245389};
    246390template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
    247391{
    248   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    249     ((*iter)->*f)(t, u);
     392  atom *Walker = start;
     393  while (Walker->next != end) {
     394    Walker = Walker->next;
     395    (Walker->*f)(t, u);
    250396  }
    251397};
    … …  
    253399template <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
    254400{
    255   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    256     ((*iter)->*f)(t, u, v);
     401  atom *Walker = start;
     402  while (Walker->next != end) {
     403    Walker = Walker->next;
     404    (Walker->*f)(t, u, v);
    257405  }
    258406};
    259407template <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
    260408{
    261   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    262     ((*iter)->*f)(t, u, v);
     409  atom *Walker = start;
     410  while (Walker->next != end) {
     411    Walker = Walker->next;
     412    (Walker->*f)(t, u, v);
    263413  }
    264414};
    … …  
    266416template <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
    267417{
    268   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    269     ((*iter)->*f)(t, u, v, w);
     418  atom *Walker = start;
     419  while (Walker->next != end) {
     420    Walker = Walker->next;
     421    (Walker->*f)(t, u, v, w);
    270422  }
    271423};
    272424template <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
    273425{
    274   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    275     ((*iter)->*f)(t, u, v, w);
     426  atom *Walker = start;
     427  while (Walker->next != end) {
     428    Walker = Walker->next;
     429    (Walker->*f)(t, u, v, w);
    276430  }
    277431};
    … …  
    282436template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
    283437{
     438  atom *Walker = start;
    284439  int inc = 1;
    285   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    286     (*Setor) (&array[((*iter)->*index)], &inc);
     440  while (Walker->next != end) {
     441    Walker = Walker->next;
     442    (*Setor) (&array[(Walker->*index)], &inc);
    287443  }
    288444};
    289445template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
    290446{
    291   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    292     (*Setor) (&array[((*iter)->*index)], &value);
     447  atom *Walker = start;
     448  while (Walker->next != end) {
     449    Walker = Walker->next;
     450    (*Setor) (&array[(Walker->*index)], &value);
    293451  }
    294452};
    295453template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
    296454{
    297   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    298     (*Setor) (&array[((*iter)->*index)], value);
     455  atom *Walker = start;
     456  while (Walker->next != end) {
     457    Walker = Walker->next;
     458    (*Setor) (&array[(Walker->*index)], value);
    299459  }
    300460};
    … …  
    302462template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
    303463{
     464  atom *Walker = start;
    304465  int inc = 1;
    305   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    306     (*Setor) (&array[((*iter)->getType()->*index)], &inc);
     466  while (Walker->next != end) {
     467    Walker = Walker->next;
     468    (*Setor) (&array[(Walker->type->*index)], &inc);
    307469  }
    308470};
    309471template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
    310472{
    311   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    312     (*Setor) (&array[((*iter)->getType()->*index)], &value);
     473  atom *Walker = start;
     474  while (Walker->next != end) {
     475    Walker = Walker->next;
     476    (*Setor) (&array[(Walker->type->*index)], &value);
    313477  }
    314478};
    315479template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
    316480{
    317   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    318     (*Setor) (&array[((*iter)->getType()->*index)], value);
     481  atom *Walker = start;
     482  while (Walker->next != end) {
     483    Walker = Walker->next;
     484    (*Setor) (&array[(Walker->type->*index)], value);
    319485  }
    320486};
    … …  
    322488template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
    323489{
    324   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    325     array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
     490  atom *Walker = start;
     491  while (Walker->next != end) {
     492    Walker = Walker->next;
     493    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
    326494  }
    327495};
    328496template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value ) const
    329497{
    330   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    331     array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
     498  atom *Walker = start;
     499  while (Walker->next != end) {
     500    Walker = Walker->next;
     501    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
    332502  }
    333503};
    334504template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
    335505{
    336   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    337     array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
     506  atom *Walker = start;
     507  while (Walker->next != end) {
     508    Walker = Walker->next;
     509    array[(Walker->*index)] = (Walker->*Setor) (vect);
    338510  }
    339511};
    340512template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const
    341513{
    342   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    343     array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
     514  atom *Walker = start;
     515  while (Walker->next != end) {
     516    Walker = Walker->next;
     517    array[(Walker->*index)] = (Walker->*Setor) (vect);
    344518  }
    345519};
    346520template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
    347521{
    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;
     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;
    351527  }
    352528};
    … …  
    354530template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr ) const
    355531{
    356   for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
    357     (*iter)->*ptr = value;
    358     //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*ptr) << endl;
     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;
    359537  }
    360538};
Note: See TracChangeset for help on using the changeset viewer.