Changeset 8d5db8


Ignore:
Timestamp:
Oct 2, 2016, 1:49:57 PM (9 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Fix_FitPotential_needs_atomicnumbers
Children:
a13e21
Parents:
f6f761
git-author:
Frederik Heber <heber@…> (10/02/16 13:24:41)
git-committer:
Frederik Heber <heber@…> (10/02/16 13:49:57)
Message:

MPQCData additionally stores the atomic number per nuclei.

Location:
src/Fragmentation
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • src/Fragmentation/Homology/unittests/HomologyContainerUnitTest.cpp

    rf6f761 r8d5db8  
    9393  Fragment::position_t pos(3, 0.);
    9494  Fragment::positions_t positions(1, pos);
     95  Fragment::atomicnumbers_t atomicnumbers(1,1.);
    9596  Fragment::charges_t charges(1,1.);
    96   Fragment dummy(positions, charges);
     97  Fragment dummy(positions, atomicnumbers, charges);
    9798  charges[0] = 6.;
    9899  positions[0][0] = 1.;
    99   Fragment dummy1(positions, charges);
     100  Fragment dummy1(positions, atomicnumbers, charges);
    100101  positions[0][0] = 2.;
    101   Fragment dummy2(positions, charges);
     102  Fragment dummy2(positions, atomicnumbers, charges);
    102103  HomologyContainer::value_t value1;
    103104  value1.fragment = dummy1;
    … …  
    133134  Fragment::position_t pos(3, 0.);
    134135  Fragment::positions_t positions(1, pos);
     136  Fragment::atomicnumbers_t atomicnumbers(1,1.);
    135137  Fragment::charges_t charges(1,1.);
    136   Fragment dummy(positions, charges);
     138  Fragment dummy(positions, atomicnumbers, charges);
    137139  HomologyContainer::value_t value;
    138140  value.fragment = dummy;
    … …  
    158160  Fragment::position_t pos(3, 0.);
    159161  Fragment::positions_t positions(1, pos);
     162  Fragment::atomicnumbers_t atomicnumbers(1,1.);
    160163  Fragment::charges_t charges(1,1.);
    161   Fragment dummy(positions, charges);
     164  Fragment dummy(positions, atomicnumbers, charges);
    162165  HomologyContainer::value_t value;
    163166  value.fragment = dummy;

  • src/Fragmentation/Homology/unittests/stubs/FragmentStub.cpp

    rf6f761 r8d5db8  
    5656 *
    5757 * @param _positions given positions
     58 * @param _atomicnumbers given atomic numbers
    5859 * @param _charges given charges
    5960 */
    60 Fragment::Fragment(const positions_t &_positions, const charges_t &_charges)
     61Fragment::Fragment(
     62    const positions_t &_positions,
     63    const atomicnumbers_t &_atomicnumbers,
     64    const charges_t &_charges)
    6165{}
    6266
    … …  
    9498Fragment::positions_t Fragment::getPositions() const
    9599{ return positions_t(); }
     100
     101/** Getter for all stored atomic numbers.
     102 *
     103 * @return vector of atomic numbers
     104 */
     105Fragment::atomicnumbers_t Fragment::getAtomicNumbers() const
     106{ return atomicnumbers_t(); }
    96107
    97108/** Getter for all stored charges.

  • src/Fragmentation/Summation/Containers/MPQCData.cpp

    rf6f761 r8d5db8  
    139139        +toString(instance.sampled_grid.getWindowGridPoints())+" and was "+toString(window_gridpoints));
    140140    instance.positions = other.positions;
     141    instance.atomicnumbers = other.atomicnumbers;
    141142    instance.charges = other.charges;
    142143    instance.times = other.times;

  • src/Fragmentation/Summation/Containers/MPQCData.hpp

    rf6f761 r8d5db8  
    110110  SamplingGrid sampled_grid;
    111111
    112   // nuclei positions and charges
     112  // nuclei positions, atomic numbers and charges
    113113  std::vector< std::vector<double> > positions;
     114  std::vector< unsigned int > atomicnumbers;
    114115  std::vector<double> charges;
    115116
    … …  
    160161      ar & DoValenceOnly;
    161162    ar & positions;
     163    if (version > 3) {
     164      ar & atomicnumbers;
     165    }
    162166    ar & charges;
    163167    ar & times.total_walltime;
    … …  
    174178};
    175179
    176 BOOST_CLASS_VERSION(MPQCData, 3)
     180BOOST_CLASS_VERSION(MPQCData, 4)
    177181
    178182std::ostream & operator<<(std::ostream &ost, const MPQCData &data);

  • src/Fragmentation/Summation/Converter/DataConverter.hpp

    rf6f761 r8d5db8  
    175175    MPQCDataFragmentMap_t instance;
    176176    boost::fusion::at_key<MPQCDataFused::fragment>(instance) =
    177         Fragment(extractedData.positions, extractedData.charges);
     177        Fragment(extractedData.positions, extractedData.atomicnumbers, extractedData.charges);
    178178    MPQCData_Fragment_fused.insert( std::make_pair(dataiter->first, instance) );
    179179  }

  • src/Fragmentation/Summation/SetValues/Fragment.cpp

    rf6f761 r8d5db8  
    5454{}
    5555
    56 Fragment::Fragment(const positions_t &_positions, const charges_t &_charges)
     56Fragment::Fragment(
     57    const positions_t &_positions,
     58    const atomicnumbers_t &_atomicnumbers,
     59    const charges_t &_charges)
    5760{
    5861  ASSERT( _positions.size() == _charges.size(),
    5962      "Fragment::Fragment() - given charges and positions don't match in size.");
    6063  positions_t::const_iterator piter = _positions.begin();
     64  atomicnumbers_t::const_iterator aiter = _atomicnumbers.begin();
    6165  charges_t::const_iterator citer = _charges.begin();
    62   for (;piter != _positions.end(); ++piter, ++citer)
    63     nuclei.push_back( make_pair( *piter, *citer) );
     66  for (;piter != _positions.end(); ++piter, ++aiter, ++citer)
     67    nuclei.push_back( createNucleus(*piter, *aiter, *citer) );
    6468}
    6569
    … …  
    121125}
    122126
     127Fragment::atomicnumbers_t Fragment::getAtomicNumbers() const
     128{
     129  atomicnumbers_t positions;
     130  for (nuclei_t::const_iterator iter = nuclei.begin();
     131      iter != nuclei.end(); ++iter)
     132    positions.push_back(iter->second.first);
     133  return positions;
     134}
     135
    123136Fragment::charges_t Fragment::getCharges() const
    124137{
    … …  
    126139  for (nuclei_t::const_iterator iter = nuclei.begin();
    127140      iter != nuclei.end(); ++iter)
    128     charges.push_back(iter->second);
     141    charges.push_back(iter->second.second);
    129142  return charges;
    130143}
    131144
    132 Fragment::nucleus_t Fragment::createNucleus(const position_t &position, const double charge)
    133 {
    134   return nucleus_t( make_pair( position, charge ) );
     145Fragment::nucleus_t Fragment::createNucleus(
     146    const position_t &position,
     147    const atomicNumber_t &atomicnumber,
     148    const double charge)
     149{
     150  return nucleus_t( make_pair( position, std::make_pair(atomicnumber, charge) ) );
    135151}
    136152
    … …  
    174190std::ostream & operator<<(std::ostream &ost, const Fragment::nucleus_t &n)
    175191{
    176   ost << n.first << " with charge " << n.second;
     192  ost << n.first << " with Z of " << n.second.first << " charge " << n.second.second;
    177193  return ost;
    178194}
    … …  
    183199  // check positions
    184200  status &= Fragment::isPositionEqual(a.first, b.first);
    185   status &= fabs(a.second - b.second) < std::numeric_limits<double>::epsilon();
     201  status &= (a.second.first == b.second.first);
     202  status &= fabs(a.second.second - b.second.second) < std::numeric_limits<double>::epsilon();
    186203  return status;
    187204}
    … …  
    190207{
    191208  Fragment::positions_t positions;
     209  Fragment::atomicnumbers_t atomicnumbers;
    192210  Fragment::charges_t charges;
    193   Fragment returnvalue(positions, charges);
     211  Fragment returnvalue(positions, atomicnumbers, charges);
    194212  return returnvalue;
    195213}

  • src/Fragmentation/Summation/SetValues/Fragment.hpp

    rf6f761 r8d5db8  
    3434  typedef double charge_t;
    3535  typedef std::vector< charge_t > charges_t;
    36   typedef std::pair< position_t, charge_t> nucleus_t;
     36  typedef unsigned int atomicNumber_t; // typedef is copied
     37  typedef std::vector< atomicNumber_t > atomicnumbers_t;
     38  typedef std::pair< position_t, std::pair<atomicNumber_t, charge_t> > nucleus_t;
    3739  typedef std::vector< nucleus_t > nuclei_t;
    3840
    … …  
    5254   *
    5355   * @param _positions given positions
     56   * @param _atomicnumbers given atomic numbers
    5457   * @param _charges given charges
    5558   */
    56   Fragment(const positions_t &_positions, const charges_t &_charges);
     59  Fragment(
     60      const positions_t &_positions,
     61      const atomicnumbers_t &_atomicnumbers,
     62      const charges_t &_charges);
    5763
    5864  /** Adding another fragment onto this one.
    … …  
    8692  positions_t getPositions() const;
    8793
     94  /** Getter for all stored atomic numbers.
     95   *
     96   * @return vector of atomic numbers
     97   */
     98  atomicnumbers_t getAtomicNumbers() const;
     99
    88100  /** Getter for all stored charges.
    89101   *
    … …  
    107119   *
    108120   * @param position position of nucleus to create
     121   * @param atomicnumber atomic number of nucleus to create
    109122   * @param charge charge of nucleus to create
    110123   * @return nucleus with given \a position and \a charge
    111124   */
    112   static nucleus_t createNucleus(const position_t &position, const double charge);
     125  static nucleus_t createNucleus(
     126      const position_t &position,
     127      const atomicNumber_t &atomicnumber,
     128      const double charge);
    113129
    114130  /** Helper function to check whether two positions are equal.

  • src/Fragmentation/Summation/SetValues/unittests/FragmentUnitTest.cpp

    rf6f761 r8d5db8  
    8181  pos[2] = 1.;
    8282  positions += pos;
     83  atomicnumbers += 1, 2, 3, 4;
    8384  charges += 1., 2., 3., 4.;
    8485  CPPUNIT_ASSERT_EQUAL( (size_t)3, pos.size() );
    8586  CPPUNIT_ASSERT( positions.size() == charges.size() );
    86 
    87   fragment = new Fragment(positions, charges);
     87  CPPUNIT_ASSERT( atomicnumbers.size() == charges.size() );
     88
     89  fragment = new Fragment(positions, atomicnumbers, charges);
    8890}
    8991
    … …  
    110112}
    111113
     114static Fragment::nuclei_t createNucleiFromTriple(
     115    const Fragment::positions_t &_positions,
     116    const Fragment::atomicnumbers_t &_atomicnumbers,
     117    const Fragment::charges_t &_charges
     118    )
     119{
     120  Fragment::nuclei_t returnnuclei;
     121  Fragment::positions_t::const_iterator piter = _positions.begin();
     122  Fragment::atomicnumbers_t::const_iterator aiter = _atomicnumbers.begin();
     123  Fragment::charges_t::const_iterator citer = _charges.begin();
     124  for (;piter != _positions.end(); ++piter)
     125    returnnuclei.push_back( Fragment::createNucleus(*piter, *aiter, *citer) );
     126  return returnnuclei;
     127}
    112128
    113129/** UnitTest for containsNuclei()
    … …  
    117133  {
    118134    // tests present ones for containment
    119     Fragment::nuclei_t validnuclei(positions.size());
    120     std::transform(positions.begin(), positions.end(),
    121         charges.begin(), validnuclei.begin(), Fragment::createNucleus);
     135    Fragment::nuclei_t validnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
    122136    BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    123137      CPPUNIT_ASSERT( fragment->containsNuclei(nucleus) );
    … …  
    129143    Fragment::nuclei_t invalidnuclei;
    130144    Fragment::position_t pos(3, -1.);
    131     invalidnuclei += Fragment::createNucleus(pos, 1.);
     145    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    132146    pos[0] = 0.;
    133     invalidnuclei += Fragment::createNucleus(pos, 1.);
     147    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    134148    pos[1] = 0.;
    135     invalidnuclei += Fragment::createNucleus(pos, 1.);
     149    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    136150    pos[2] = -std::numeric_limits<double>::epsilon()*1e+4;
    137     invalidnuclei += Fragment::createNucleus(pos, 1.);
     151    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    138152    BOOST_FOREACH( Fragment::nucleus_t nucleus, invalidnuclei) {
    139153      CPPUNIT_ASSERT( !fragment->containsNuclei(nucleus) );
    … …  
    149163    // tests present ones for removal
    150164    size_t size = fragment->nuclei.size();
    151     Fragment::nuclei_t validnuclei(positions.size());
    152     std::transform(positions.begin(), positions.end(),
    153         charges.begin(), validnuclei.begin(), Fragment::createNucleus);
     165    Fragment::nuclei_t validnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
    154166    BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    155167      CPPUNIT_ASSERT_NO_THROW( fragment->removeNuclei(nucleus) );
    … …  
    161173    Fragment::nuclei_t invalidnuclei;
    162174    Fragment::position_t pos(3, -1.);
    163     invalidnuclei += Fragment::createNucleus(pos, 1.);
     175    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    164176    pos[0] = 0;
    165     invalidnuclei += Fragment::createNucleus(pos, 1.);
     177    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    166178    pos[1] = 0;
    167     invalidnuclei += Fragment::createNucleus(pos, 1.);
     179    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    168180    pos[2] = -std::numeric_limits<double>::epsilon()*1e+4;
    169     invalidnuclei += Fragment::createNucleus(pos, 1.);
     181    invalidnuclei += Fragment::createNucleus(pos, 1, 1.);
    170182    BOOST_FOREACH( Fragment::nucleus_t nucleus, invalidnuclei) {
    171183      CPPUNIT_ASSERT_NO_THROW( fragment->removeNuclei(nucleus) );
    … …  
    178190void FragmentTest::equalityNucleus_Test()
    179191{
    180   Fragment::nuclei_t validnuclei(positions.size());
    181   std::transform(positions.begin(), positions.end(),
    182       charges.begin(), validnuclei.begin(), Fragment::createNucleus);
     192  Fragment::nuclei_t validnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
    183193  {
    184194    // create some nuclei
    … …  
    191201    // create nucleus at other position
    192202    Fragment::position_t pos(3, 2.);
    193     Fragment::nucleus_t unequalposnucleus(pos, 1.);
     203    Fragment::nucleus_t unequalposnucleus( Fragment::createNucleus(pos, 1, 1.) );
    194204    BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    195205      CPPUNIT_ASSERT( nucleus != unequalposnucleus );
    … …  
    200210    // create nucleus with different charge
    201211    Fragment::position_t pos(3, 1.);
    202     Fragment::nucleus_t unequalchargenucleus(pos, 5.);
     212    Fragment::nucleus_t unequalchargenucleus( Fragment::createNucleus(pos, 5, 5.) );
    203213    BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    204214      CPPUNIT_ASSERT( nucleus != unequalchargenucleus );
    … …  
    219229  otherpos[1] = 0.;
    220230  otherpositions += otherpos;
     231  Fragment::atomicnumbers_t otheratomicnumbers;
     232  otheratomicnumbers += 1, 2, 3;
    221233  Fragment::charges_t othercharges;
    222234  othercharges += 1., 2., 3.;
    223   Fragment otherfragment(otherpositions, othercharges);
     235  Fragment otherfragment(otherpositions, otheratomicnumbers, othercharges);
    224236
    225237  CPPUNIT_ASSERT( !(*fragment == otherfragment) );
    … …  
    253265  otherpos[1] = 0.;
    254266  otherpositions += otherpos;
     267  Fragment::atomicnumbers_t otheratomicnumbers;
     268  otheratomicnumbers += 1, 2, 3;
    255269  Fragment::charges_t othercharges;
    256270  othercharges += 1., 2., 3.;
    257   Fragment otherfragment(otherpositions, othercharges);
     271  Fragment otherfragment(otherpositions, otheratomicnumbers, othercharges);
    258272
    259273  // check for inequality
    … …  
    282296    otherpos[1] = 0.;
    283297    otherpositions += otherpos;
     298    Fragment::atomicnumbers_t otheratomicnumbers;
     299    otheratomicnumbers += 1, 2, 3;
    284300    Fragment::charges_t othercharges;
    285301    othercharges += 1., 2., 3.;
    286     Fragment otherfragment(otherpositions, othercharges);
     302    Fragment otherfragment(otherpositions, otheratomicnumbers, othercharges);
    287303    const size_t othersize = otherfragment.nuclei.size();
    288304    const size_t size = fragment->nuclei.size();
    … …  
    292308    {
    293309      // tests all for containment
    294       Fragment::nuclei_t validnuclei(positions.size()+otherpositions.size());
    295       Fragment::nuclei_t::iterator iter =
    296           std::transform(positions.begin(), positions.end(),
    297           charges.begin(), validnuclei.begin(), Fragment::createNucleus);
    298       std::transform(otherpositions.begin(), otherpositions.end(),
    299           othercharges.begin(), iter, Fragment::createNucleus);
     310      Fragment::nuclei_t validnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
     311      Fragment::nuclei_t othervalidnuclei( createNucleiFromTriple(otherpositions, otheratomicnumbers, othercharges) );
     312      validnuclei.insert(validnuclei.end(), othervalidnuclei.begin(), othervalidnuclei.end());
    300313      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    301314        CPPUNIT_ASSERT( fragment->containsNuclei(nucleus) );
    … …  
    304317    {
    305318      // tests positions for no containment in otherfragment
    306       Fragment::nuclei_t invalidnuclei(positions.size());
    307       std::transform(positions.begin(), positions.end(),
    308           charges.begin(), invalidnuclei.begin(), Fragment::createNucleus);
     319      Fragment::nuclei_t invalidnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
    309320      BOOST_FOREACH( Fragment::nucleus_t nucleus, invalidnuclei) {
    310321        CPPUNIT_ASSERT( !otherfragment.containsNuclei(nucleus) );
    … …  
    313324    {
    314325      // tests otherpositions for containment in otherfragment
    315       Fragment::nuclei_t validnuclei(otherpositions.size());
    316       std::transform(otherpositions.begin(), otherpositions.end(),
    317           othercharges.begin(), validnuclei.begin(), Fragment::createNucleus);
     326      Fragment::nuclei_t validnuclei( createNucleiFromTriple(otherpositions, otheratomicnumbers, othercharges) );
    318327      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    319328        CPPUNIT_ASSERT( otherfragment.containsNuclei(nucleus) );
    … …  
    336345    otherpos[1] = 2.;
    337346    otherpositions += otherpos;
     347    Fragment::atomicnumbers_t otheratomicnumbers;
     348    otheratomicnumbers += 1, 2, 3;
    338349    Fragment::charges_t othercharges;
    339350    othercharges += 1., 2., 3.;
    340     Fragment otherfragment(otherpositions, othercharges);
     351    Fragment otherfragment(otherpositions, otheratomicnumbers, othercharges);
    341352    const size_t othersize = otherfragment.nuclei.size();
    342353    const size_t size = fragment->nuclei.size();
    … …  
    346357    {
    347358      // tests all for containment
    348       Fragment::nuclei_t validnuclei(positions.size()+otherpositions.size());
    349       Fragment::nuclei_t::iterator iter =
    350           std::transform(positions.begin(), positions.end(),
    351           charges.begin(), validnuclei.begin(), Fragment::createNucleus);
    352       std::transform(otherpositions.begin(), otherpositions.end(),
    353           othercharges.begin(), iter, Fragment::createNucleus);
     359      Fragment::nuclei_t validnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
     360      Fragment::nuclei_t othervalidnuclei( createNucleiFromTriple(otherpositions, otheratomicnumbers, othercharges) );
     361      validnuclei.insert(validnuclei.end(), othervalidnuclei.begin(), othervalidnuclei.end());
    354362      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    355363        CPPUNIT_ASSERT( fragment->containsNuclei(nucleus) );
    … …  
    358366    {
    359367      // tests positions for no containment in otherfragment (but last)
    360       Fragment::nuclei_t invalidnuclei(positions.size()-1);
    361       std::transform(positions.begin(), --positions.end(),
    362           charges.begin(), invalidnuclei.begin(), Fragment::createNucleus);
     368      Fragment::positions_t lesspositions(positions.begin(), --positions.end());
     369      Fragment::atomicnumbers_t lessatomicnumbers(atomicnumbers.begin(), --atomicnumbers.end());
     370      Fragment::charges_t lesscharges(charges.begin(), --charges.end());
     371      Fragment::nuclei_t invalidnuclei( createNucleiFromTriple(lesspositions, lessatomicnumbers, lesscharges) );
    363372      BOOST_FOREACH( Fragment::nucleus_t nucleus, invalidnuclei) {
    364373        CPPUNIT_ASSERT( !otherfragment.containsNuclei(nucleus) );
    … …  
    367376    {
    368377      // tests otherpositions for containment in otherfragment
    369       Fragment::nuclei_t validnuclei(otherpositions.size());
    370       std::transform(otherpositions.begin(), otherpositions.end(),
    371           othercharges.begin(), validnuclei.begin(), Fragment::createNucleus);
     378      Fragment::nuclei_t validnuclei( createNucleiFromTriple(otherpositions, otheratomicnumbers, othercharges) );
    372379      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    373380        CPPUNIT_ASSERT( otherfragment.containsNuclei(nucleus) );
    … …  
    390397    otherpos[1] = 0.;
    391398    otherpositions += otherpos;
     399    Fragment::atomicnumbers_t otheratomicnumbers;
     400    otheratomicnumbers += 1, 2, 3;
    392401    Fragment::charges_t othercharges;
    393402    othercharges += 1., 2., 3.;
    394     Fragment otherfragment(otherpositions, othercharges);
     403    Fragment otherfragment(otherpositions, otheratomicnumbers, othercharges);
    395404    const size_t othersize = otherfragment.nuclei.size();
    396405    const size_t size = fragment->nuclei.size();
    … …  
    400409    {
    401410      // tests positions for containment
    402       Fragment::nuclei_t validnuclei(positions.size());
    403       std::transform(positions.begin(), positions.end(),
    404           charges.begin(), validnuclei.begin(), Fragment::createNucleus);
     411      Fragment::nuclei_t validnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
    405412      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    406413        CPPUNIT_ASSERT( fragment->containsNuclei(nucleus) );
    … …  
    409416    {
    410417      // tests otherpositions for no containment
    411       Fragment::nuclei_t invalidnuclei(otherpositions.size());
    412       std::transform(otherpositions.begin(), otherpositions.end(),
    413           othercharges.begin(), invalidnuclei.begin(), Fragment::createNucleus);
     418      Fragment::nuclei_t invalidnuclei( createNucleiFromTriple(otherpositions, otheratomicnumbers, othercharges) );
    414419      BOOST_FOREACH( Fragment::nucleus_t nucleus, invalidnuclei) {
    415420        CPPUNIT_ASSERT( !fragment->containsNuclei(nucleus) );
    … …  
    418423    {
    419424      // tests positions for no containment in otherfragment
    420       Fragment::nuclei_t invalidnuclei(positions.size());
    421       std::transform(positions.begin(), positions.end(),
    422           charges.begin(), invalidnuclei.begin(), Fragment::createNucleus);
     425      Fragment::nuclei_t invalidnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
    423426      BOOST_FOREACH( Fragment::nucleus_t nucleus, invalidnuclei) {
    424427        CPPUNIT_ASSERT( !otherfragment.containsNuclei(nucleus) );
    … …  
    427430    {
    428431      // tests otherpositions for containment in otherfragment
    429       Fragment::nuclei_t validnuclei(otherpositions.size());
    430       std::transform(otherpositions.begin(), otherpositions.end(),
    431           othercharges.begin(), validnuclei.begin(), Fragment::createNucleus);
     432      Fragment::nuclei_t validnuclei( createNucleiFromTriple(otherpositions, otheratomicnumbers, othercharges) );
    432433      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    433434        CPPUNIT_ASSERT( otherfragment.containsNuclei(nucleus) );
    … …  
    450451    otherpos[1] = 2.;
    451452    otherpositions += otherpos;
     453    Fragment::atomicnumbers_t otheratomicnumbers;
     454    otheratomicnumbers += 1, 2, 3;
    452455    Fragment::charges_t othercharges;
    453456    othercharges += 1., 2., 3.;
    454     Fragment otherfragment(otherpositions, othercharges);
     457    Fragment otherfragment(otherpositions, otheratomicnumbers, othercharges);
    455458    const size_t othersize = otherfragment.nuclei.size();
    456459    const size_t size = fragment->nuclei.size();
    … …  
    461464    {
    462465      // tests all but last for containment
    463       Fragment::nuclei_t validnuclei(positions.size());
    464       std::transform(positions.begin(), positions.end(),
    465           charges.begin(), validnuclei.begin(), Fragment::createNucleus);
     466      Fragment::nuclei_t validnuclei( createNucleiFromTriple(positions, atomicnumbers, charges) );
    466467      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    467468        if (Fragment::isPositionEqual(nucleus.first, otherpositions[0])) // only test position
    … …  
    473474    {
    474475      // tests positions for no containment in otherfragment
    475       Fragment::nuclei_t invalidnuclei(positions.size()-1);
    476       std::transform(positions.begin(), --positions.end(),
    477           charges.begin(), invalidnuclei.begin(), Fragment::createNucleus);
     476      Fragment::positions_t lesspositions(positions.begin(), --positions.end());
     477      Fragment::atomicnumbers_t lessatomicnumbers(atomicnumbers.begin(), --atomicnumbers.end());
     478      Fragment::charges_t lesscharges(charges.begin(), --charges.end());
     479      Fragment::nuclei_t invalidnuclei( createNucleiFromTriple(lesspositions, lessatomicnumbers, lesscharges) );
    478480      BOOST_FOREACH( Fragment::nucleus_t nucleus, invalidnuclei) {
    479481        CPPUNIT_ASSERT( !otherfragment.containsNuclei(nucleus) );
    … …  
    482484    {
    483485      // tests otherpositions for containment in otherfragment
    484       Fragment::nuclei_t validnuclei(otherpositions.size());
    485       std::transform(otherpositions.begin(), otherpositions.end(),
    486           othercharges.begin(), validnuclei.begin(), Fragment::createNucleus);
     486      Fragment::nuclei_t validnuclei( createNucleiFromTriple(otherpositions, otheratomicnumbers, othercharges) );
    487487      BOOST_FOREACH( Fragment::nucleus_t nucleus, validnuclei) {
    488488        CPPUNIT_ASSERT( otherfragment.containsNuclei(nucleus) );

  • src/Fragmentation/Summation/SetValues/unittests/FragmentUnitTest.hpp

    rf6f761 r8d5db8  
    5555      Fragment *fragment;
    5656      Fragment::positions_t positions;
     57      Fragment::atomicnumbers_t atomicnumbers;
    5758      Fragment::charges_t charges;
    5859};
Note: See TracChangeset for help on using the changeset viewer.