Ignore:
Timestamp:
Feb 25, 2013, 5:28:58 PM (12 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
1f3b2a
Parents:
d94e7e
git-author:
Frederik Heber <heber@…> (11/26/12 22:23:13)
git-committer:
Frederik Heber <heber@…> (02/25/13 17:28:58)
Message:

FunctionArgument now contains charges, too, and rewrote Extractors accordingly.

  • gatherDistancesFromFragment is now what we mostly want: Returns exactly the arguments in the way we specify.
  • PairPotential_AngleUnitTest now has gives additional types to potential's cstor.
Location:
src/FunctionApproximation
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • src/FunctionApproximation/Extractors.cpp

    rd94e7e r691be4  
    5252FunctionModel::arguments_t
    5353Extractors::gatherAllDistanceArguments(
    54     const Fragment::positions_t &positions,
     54    const Fragment::positions_t& positions,
     55    const Fragment::charges_t& charges,
    5556    const size_t globalid)
    5657{
    … …  
    6869      const Vector secondtemp((*secondpositer)[0],(*secondpositer)[1],(*secondpositer)[2]);
    6970      arg.distance = firsttemp.distance(secondtemp);
     71      arg.types = std::make_pair(
     72          charges[ std::distance(positions.begin(), firstpositer) ],
     73          charges[ std::distance(positions.begin(), secondpositer) ]
     74          );
    7075      arg.indices = std::make_pair(
    7176          std::distance(
    … …  
    8489FunctionModel::arguments_t
    8590Extractors::gatherAllSymmetricDistanceArguments(
    86     const Fragment::positions_t &positions,
     91    const Fragment::positions_t& positions,
     92    const Fragment::charges_t& charges,
    8793    const size_t globalid)
    8894{
    … …  
    100106      const Vector secondtemp((*secondpositer)[0],(*secondpositer)[1],(*secondpositer)[2]);
    101107      arg.distance = firsttemp.distance(secondtemp);
     108      arg.types = std::make_pair(
     109          charges[ std::distance(positions.begin(), firstpositer) ],
     110          charges[ std::distance(positions.begin(), secondpositer) ]
     111          );
    102112      arg.indices = std::make_pair(
    103113          std::distance(
    … …  
    114124}
    115125
    116 Fragment::positions_t Extractors::_detail::gatherPositionsFromCharges(
    117     const Fragment::positions_t &positions,
    118     const Fragment::charges_t &charges,
    119     const chargeiters_t targets
     126Fragment::positions_t Extractors::_detail::gatherPositionsFromTargets(
     127    const Fragment::positions_t& positions,
     128    const Fragment::charges_t& charges,
     129    const chargeiters_t &targets
    120130    )
    121131{
    … …  
    129139  }
    130140  return filtered_positions;
     141}
     142
     143FunctionModel::arguments_t Extractors::_detail::gatherDistancesFromTargets(
     144    const Fragment::positions_t& positions,
     145    const Fragment::charges_t& charges,
     146    const chargeiters_t &targets,
     147    const size_t globalid
     148    )
     149{
     150  Fragment::positions_t filtered_positions;
     151  Fragment::charges_t filtered_charges;
     152  for (chargeiters_t::const_iterator firstpairiter = targets.begin();
     153      firstpairiter != targets.end(); ++firstpairiter) {
     154    Fragment::positions_t::const_iterator positer = positions.begin();
     155    const size_t steps = std::distance(charges.begin(), *firstpairiter);
     156    std::advance(positer, steps);
     157    filtered_positions.push_back(*positer);
     158    filtered_charges.push_back(**firstpairiter);
     159  }
     160  return Extractors::gatherAllSymmetricDistanceArguments(
     161      filtered_positions,
     162      filtered_charges,
     163      globalid);
    131164}
    132165
    … …  
    218251}
    219252
    220 Fragment::positions_t
    221 Extractors::gatherPositionOfTuples(
    222     const Fragment& fragment,
     253Extractors::chargeiters_t
     254Extractors::_detail::gatherTargetsFromFragment(
     255    const Fragment::charges_t& charges,
    223256    const Fragment::charges_t elements
    224     ) {
    225   const Fragment::charges_t charges = fragment.getCharges();
     257    )
     258{
    226259  /// The main problem here is that we have to know how many same
    227260  /// elements (but different atoms!) we are required to find. Hence,
    … …  
    248281      ++chargeiter)
    249282    ASSERT( *chargeiter != charges.end(),
    250         "Extractors::gatherDistanceOfTuples() - we have not found enough targets?!");
     283        "Extractors::gatherTargetsFromFragment() - we have not found enough targets?!");
    251284#endif
     285
     286  return targets;
     287}
     288
     289Fragment::positions_t
     290Extractors::gatherPositionsFromFragment(
     291    const Fragment::positions_t positions,
     292    const Fragment::charges_t charges,
     293    const Fragment::charges_t& elements
     294    )
     295{
     296  // 1.-3. gather correct charge positions
     297  chargeiters_t targets =
     298      Extractors::_detail::gatherTargetsFromFragment(charges, elements);
    252299  // 4. convert position_t to Vector
    253   return Extractors::_detail::gatherPositionsFromCharges(
    254           fragment.getPositions(),
     300  return Extractors::_detail::gatherPositionsFromTargets(
     301          positions,
    255302          charges,
    256303          targets);
     304}
     305
     306FunctionModel::arguments_t
     307Extractors::gatherDistancesFromFragment(
     308    const Fragment::positions_t positions,
     309    const Fragment::charges_t charges,
     310    const Fragment::charges_t& elements,
     311    const size_t globalid
     312    )
     313{
     314  // 1.-3. gather correct charge positions
     315  chargeiters_t targets =
     316      Extractors::_detail::gatherTargetsFromFragment(charges, elements);
     317  // 4. convert position_t to Vector
     318  return Extractors::_detail::gatherDistancesFromTargets(
     319          positions,
     320          charges,
     321          targets,
     322          globalid);
    257323}
    258324

  • src/FunctionApproximation/Extractors.hpp

    rd94e7e r691be4  
    3535   */
    3636  namespace _detail {
    37     /** Gather all positions from the same aligned vector of charges.
     37    /** Gather all distance arguments from the same aligned vector of charges.
    3838     *
    3939     * Basically, we filter the positions indicated by the targets but
    4040     * from a different vector that has the same layout.
    4141     *
    42      * \param positions positions to search
    43      * \param charges charges to match with \targets
     42     * \param positions all nuclei positions
     43     * \param charges all nuclei charges
     44     * \param targets iterators on charges
     45     * \return filtered distance arguments
     46     */
     47    FunctionModel::arguments_t gatherDistancesFromTargets(
     48        const Fragment::positions_t& positions,
     49        const Fragment::charges_t& charges,
     50        const chargeiters_t &targets,
     51        const size_t globalid
     52        );
     53
     54    /** Gather all positions from the same aligned vector of charges.
     55     *
     56     * Basically, we filter the positions indicated by the targets but
     57     * from a different vector that has the same layout.
     58     *
     59     * \param positions all nuclei positions
     60     * \param charges all nuclei charges
    4461     * \param targets iterators on charges
    4562     * \return filtered positions
    4663     */
    47     Fragment::positions_t gatherPositionsFromCharges(
    48         const Fragment::positions_t &positions,
    49         const Fragment::charges_t &charges,
    50         const chargeiters_t targets
     64    Fragment::positions_t gatherPositionsFromTargets(
     65        const Fragment::positions_t& positions,
     66        const Fragment::charges_t& charges,
     67        const chargeiters_t& targets
    5168        );
    5269
    … …  
    86103        const elementcounts_t &elementcounts
    87104        );
     105
     106    /** Searches for desired elements in charges in a unique manner.
     107     *
     108     * The idea is to have e.g. a fragment with charges 8,1,1,2 and
     109     * elements as 1,8,1 (e.g. for an angle HOH) and we get the
     110     * chargeiters in the desired manner on indices: 1,0,3.
     111     *
     112     * \param charges charges to look through
     113     * \param elements vector of elements to find
     114     */
     115    chargeiters_t
     116    gatherTargetsFromFragment(
     117        const Fragment::charges_t& charges,
     118        const Fragment::charges_t elements
     119        );
    88120  }
    89121
    90122  /** Gather all distances from a given set of positions.
    91123   *
    92    * \param positions vector of positions
     124   * \param positions all nuclei positions
     125   * \param charges all nuclei charges
    93126   * \param globalid index to associated in argument_t with
    94127   * \return vector of argument_ , each with a distance
    … …  
    96129  FunctionModel::arguments_t
    97130  gatherAllDistanceArguments(
    98       const Fragment::positions_t &positions,
     131      const Fragment::positions_t& positions,
     132      const Fragment::charges_t& charges,
    99133      const size_t globalid);
    100134
    … …  
    103137   *  Here, we only return one of the two equal distances.
    104138   *
    105    * \param positions vector of positions
     139   * \param positions all nuclei positions
     140   * \param charges all nuclei charges
    106141   * \param globalid index to associated in argument_t with
    107142   * \return vector of argument_ , each with a distance
    … …  
    109144  FunctionModel::arguments_t
    110145  gatherAllSymmetricDistanceArguments(
    111       const Fragment::positions_t &positions,
     146      const Fragment::positions_t& positions,
     147      const Fragment::charges_t& charges,
    112148      const size_t globalid);
    113149
    114150  /** Simple extractor of all unique pair distances of a given \a fragment.
    115151   *
    116    * \param fragment fragment with all nuclei positions
     152   * \param positions all nuclei positions
     153   * \param charges all nuclei charges
    117154   * \param index index refers to the index within the global set of configurations
    118155   * \return vector of of argument_t containing all found distances
    119156   */
    120157  inline FunctionModel::arguments_t gatherAllDistances(
    121       const Fragment& fragment,
     158      const Fragment::positions_t& positions,
     159      const Fragment::charges_t& charges,
    122160      const size_t index
    123161      ) {
    124162    // get distance out of Fragment
    125     return gatherAllDistanceArguments(fragment.getPositions(), index);
     163    return gatherAllDistanceArguments(positions, charges, index);
    126164  }
    127165
    128   /** Gather all positions associated to the matching \a elements.
    129    *
    130    * \param fragment fragment with all nuclei positions
     166  /** Simple extractor of all unique pair distances of a given \a fragment, where
     167   * the first index is less than the second one.
     168   *
     169   * \param positions all nuclei positions
     170   * \param charges all nuclei charges
     171   * \param index index refers to the index within the global set of configurations
     172   * \return vector of of argument_t containing all found distances
     173   */
     174  inline FunctionModel::arguments_t gatherAllSymmetricDistances(
     175      const Fragment::positions_t& positions,
     176      const Fragment::charges_t& charges,
     177      const size_t index
     178      ) {
     179    // get distance out of Fragment
     180    return gatherAllSymmetricDistanceArguments(positions, charges, index);
     181  }
     182
     183  /** Filters only those positions out of given \a fragment that match \a elements.
     184   *
     185   * \param positions all nuclei positions
     186   * \param charges all nuclei charges
    131187   * \param elements tuple of desired elements
    132188   * \return vector of positions_t containing
    133189   */
    134   Fragment::positions_t gatherPositionOfTuples(
    135       const Fragment& fragment,
    136       const Fragment::charges_t elements
     190  Fragment::positions_t gatherPositionsFromFragment(
     191      const Fragment::positions_t positions,
     192      const Fragment::charges_t charges,
     193      const Fragment::charges_t& elements
     194      );
     195
     196  /** Filters only those distances out of given \a fragment that match \a elements.
     197   *
     198   * \param positions all nuclei positions
     199   * \param charges all nuclei charges
     200   * \param elements tuple of desired elements
     201   * \return vector of arguments_t containing those matched with elements
     202   */
     203  FunctionModel::arguments_t gatherDistancesFromFragment(
     204      const Fragment::positions_t positions,
     205      const Fragment::charges_t charges,
     206      const Fragment::charges_t& elements,
     207      const size_t globalid
    137208      );
    138209

  • src/FunctionApproximation/FunctionArgument.cpp

    rd94e7e r691be4  
    4444{
    4545  ost << "[(" << arg.indices.first << "," << arg.indices.second
     46      << "), q(   " << arg.types.first << "," << arg.types.second << "),"
    4647      << "r=" << arg.distance;
    4748  return ost;

  • src/FunctionApproximation/FunctionArgument.hpp

    rd94e7e r691be4  
    3232  //!> typedef for the two indices of the argument
    3333  typedef std::pair<size_t, size_t> indices_t;
     34  //!> typedef for the underlying type of the particle
     35  typedef int ParticleType_t;
     36  //!> typedef for the two particle types of the argument
     37  typedef std::pair<ParticleType_t, ParticleType_t> types_t;
    3438
    3539  /** Default constructor for class argument_t.
    … …  
    3842  argument_t() :
    3943    indices( std::make_pair(0,1) ),
     44    types( std::make_pair(0,0) ),
    4045    distance(0.),
    4146    globalid(-1)
    … …  
    5055  argument_t(const double &_distance) :
    5156    indices( std::make_pair(0,1) ),
     57    types( std::make_pair(0,0) ),
    5258    distance(_distance),
    5359    globalid(-1)
    … …  
    6167  argument_t(const indices_t &_indices, const double &_distance) :
    6268    indices( _indices ),
     69    types( std::make_pair(0,0) ),
     70    distance(_distance),
     71    globalid(-1)
     72  {}
     73
     74  /** Constructor for class argument_t.
     75   *
     76   * \param _indices pair of indices associated with the \a _distance
     77   * \param _types pair of particle type
     78   * \param _distance distance argument
     79   */
     80  argument_t(const indices_t &_indices, const types_t &_types, const double &_distance) :
     81    indices( _indices ),
     82    types( _types ),
    6383    distance(_distance),
    6484    globalid(-1)
    … …  
    98118  //!> indices between which the distance is given
    99119  indices_t indices;
     120  //!> indices between which the distance is given
     121  types_t types;
    100122  //!> distance
    101123  double distance;

  • src/FunctionApproximation/unittests/ExtractorsUnitTest.cpp

    rd94e7e r691be4  
    8484  }
    8585
     86  // create charges
     87  Fragment::charges_t charges;
     88  charges += 6., 6., 1., 1., 1.;
     89
    8690  // create distances
    8791  FunctionModel::arguments_t args =
    88       Extractors::gatherAllDistanceArguments(positions, 0);
     92      Extractors::gatherAllDistanceArguments(positions, charges, 0);
    8993  CPPUNIT_ASSERT_EQUAL( (size_t)(5*4), args.size() );
    9094
    … …  
    9498}
    9599
    96 /** UnitTest for gatherPositionOfTuples()
     100/** UnitTest for gatherPositionsFromFragment()
    97101 */
    98 void ExtractorsTest::gatherPositionOfTuplesTest()
     102void ExtractorsTest::gatherPositionsFromFragmentTest()
    99103{
    100104  // create positions
    … …  
    110114  charges += 6., 6., 1., 1., 1.;
    111115
    112   // create Fragment
    113   Fragment fragment(positions, charges);
     116  {
     117    // extract carbon pairs
     118    Fragment::charges_t carbonpair;
     119    carbonpair += 6.,6.;
     120    Fragment::positions_t filtered_positions =
     121        Extractors::gatherPositionsFromFragment(positions, charges, carbonpair);
     122    CPPUNIT_ASSERT_EQUAL( (size_t)2, filtered_positions.size() );
     123  }
     124
     125  {
     126    // extract hydrogen triple
     127    Fragment::charges_t hydrogentriple;
     128    hydrogentriple += 1.,1.,1.;
     129    Fragment::positions_t filtered_positions =
     130        Extractors::gatherPositionsFromFragment(positions, charges, hydrogentriple);
     131    CPPUNIT_ASSERT_EQUAL( (size_t)3, filtered_positions.size() );
     132  }
     133}
     134
     135/** UnitTest for gatherDistancesFromFragment()
     136 */
     137void ExtractorsTest::gatherDistancesFromFragmentTest()
     138{
     139  // create positions
     140  Fragment::positions_t positions;
     141  Fragment::position_t pos(3, 0.);
     142  for (double i = 0; i < 5; i+=1.) {
     143    pos[0] = i;
     144    positions.push_back(pos);
     145  }
     146
     147  // create charges
     148  Fragment::charges_t charges;
     149  charges += 6., 6., 1., 1., 1.;
    114150
    115151  {
    … …  
    118154    carbonpair += 6.,6.;
    119155    FunctionModel::arguments_t args =
    120         Extractors::gatherAllSymmetricDistanceArguments(
    121             Extractors::gatherPositionOfTuples(fragment, carbonpair),
    122             0
    123         );
     156        Extractors::gatherDistancesFromFragment(positions, charges, carbonpair, 0);
    124157    CPPUNIT_ASSERT_EQUAL( (size_t)1, args.size() );
    125     CPPUNIT_ASSERT_EQUAL( 1., args[0].distance );
    126158  }
    127159
    … …  
    131163    hydrogentriple += 1.,1.,1.;
    132164    FunctionModel::arguments_t args =
    133         Extractors::reorderArgumentsByIncreasingDistance(
    134             Extractors::gatherAllSymmetricDistanceArguments(
    135                 Extractors::gatherPositionOfTuples(fragment, hydrogentriple),
    136                 0
    137             )
    138         );
     165        Extractors::gatherDistancesFromFragment(positions, charges, hydrogentriple, 0);
    139166    CPPUNIT_ASSERT_EQUAL( (size_t)3, args.size() );
    140     CPPUNIT_ASSERT_EQUAL( 1., args[0].distance );
    141     CPPUNIT_ASSERT_EQUAL( 1., args[1].distance );
    142     CPPUNIT_ASSERT_EQUAL( 2., args[2].distance );
    143167  }
    144168}

  • src/FunctionApproximation/unittests/ExtractorsUnitTest.hpp

    rd94e7e r691be4  
    2424    CPPUNIT_TEST ( gatherAllDistanceArgumentsTest );
    2525    CPPUNIT_TEST ( reorderArgumentsByIncreasingDistanceTest );
    26     CPPUNIT_TEST ( gatherPositionOfTuplesTest );
     26    CPPUNIT_TEST ( gatherPositionsFromFragmentTest );
     27    CPPUNIT_TEST ( gatherDistancesFromFragmentTest );
    2728    CPPUNIT_TEST_SUITE_END();
    2829
    … …  
    3233      void gatherAllDistanceArgumentsTest();
    3334      void reorderArgumentsByIncreasingDistanceTest();
    34       void gatherPositionOfTuplesTest();
     35      void gatherPositionsFromFragmentTest();
     36      void gatherDistancesFromFragmentTest();
    3537
    3638private:
Note: See TracChangeset for help on using the changeset viewer.