Changeset 9c793c for src


Ignore:
Timestamp:
Nov 11, 2016, 2:25:36 PM (9 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_StructOpt_integration_tests, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, 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_ChronosMutex, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, GeometryObjects, Gui_displays_atomic_force_velocity, IndependentFragmentGrids_IntegrationTest, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, RotateToPrincipalAxisSystem_UndoRedo, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, ThirdParty_MPQC_rebuilt_buildsystem, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, Ubuntu_1604_changes, stable
Children:
f5dbea
Parents:
bc069f
git-author:
Frederik Heber <heber@…> (10/05/16 21:33:40)
git-committer:
Frederik Heber <heber@…> (11/11/16 14:25:36)
Message:

All ..Potentials now return BindingModel instead of HomologyGraph, Extractors::reorderArg..() uses it.

  • Extractors::filterArg..() and ::reorderArg..() expect BindingModel instead of HomologyGraph.
  • TESTFIX: Lennard Jones potential fitting regression test no longer fails because it is purely non-bonded.
Location:
src
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • src/FunctionApproximation/Extractors.cpp

    rbc069f r9c793c  
    6161#include "LinearAlgebra/Vector.hpp"
    6262
     63#include "Fragmentation/Homology/HomologyGraph.hpp"
    6364#include "FunctionApproximation/Extractors.hpp"
    6465#include "FunctionApproximation/FunctionArgument.hpp"
    65 
    66 #include "Fragmentation/Homology/HomologyGraph.hpp"
     66#include "Potentials/BindingModel.hpp"
    6767
    6868using namespace boost::assign;
    … …  
    535535    const HomologyGraph &_graph,
    536536    const ParticleTypes_t &_types,
    537     const HomologyGraph &_bindingmodel
     537    const BindingModel &_bindingmodel
    538538    )
    539539{
    … …  
    545545    // deal with the case when there are no distances (ConstantPotential)
    546546    if (_bindingmodel.getNodes().size() < 2) {
    547       LOG(3, "DEBUG: Potential requires only zero or no particle types, needs no distances.");
     547      LOG(3, "DEBUG: Potential requires only one or no particle types, needs no distances.");
    548548      continue;
    549549    }
    550     if (_bindingmodel.getEdges().empty()) {
     550    if (_bindingmodel.getGraph().getEdges().empty()) {
    551551      LOG(3, "DEBUG: Potential represents non-bonded interactions, gets all distances.");
     552      // TODO: Here we need to constrain to all distances matching the types?
    552553      returnargs.push_back(args);
    553554      continue;
    … …  
    604605
    605606    /// 2. grab first node of the binding model (gives a type)
    606     const FragmentNode &firstnode = _bindingmodel.getNodes().begin()->first;
    607     const size_t &firsttimes = _bindingmodel.getNodes().begin()->second;
    608     const size_t &firsttype = firstnode.getAtomicNumber(); // TODO: convert to ParticleNumber_t ?
     607    const BindingModel::vector_nodes_t::const_iterator firstiter = _bindingmodel.getNodes().begin();
     608    const FragmentNode &firstnode = *firstiter;
     609    const Extractors::ParticleType_t &firsttype = firstnode.getAtomicNumber();
    609610
    610611    /// 3. grab all candidate nodes contained in arguments_t
    … …  
    612613        type_index_lookup_t::right_const_iterator,
    613614        type_index_lookup_t::right_const_iterator> range = type_index_lookup.right.equal_range(firsttype);
    614 #ifndef NDEBUG
    615     const size_t checktimes = std::distance(range.first, range.second);
    616     ASSERT( firsttimes == checktimes,
    617         "Extractors::reorderArgumentsByParticleTypes() - unequal amounts of same first type "
    618         +toString(firsttype)+" in HomologyGraph and in type lookup "+toString(checktimes));
    619 #endif
    620615
    621616    /// 4. go over all candidate nodes (gives index)
     617    const size_t nodes_in_bindingmodel = _bindingmodel.getNodes().size();
     618    LOG(2, "DEBUG: There are " << nodes_in_bindingmodel << " nodes in the binding model.");
    622619    set_of_nodes_t set_of_nodes;
    623620    for (type_index_lookup_t::right_const_iterator rangeiter = range.first;
    … …  
    648645
    649646      generateAllInducedConnectedSubgraphs(
    650           N-1, level, nodes, set_of_nodes, nodes_per_level, fragmentgraph, distances, index_map);
     647          nodes_in_bindingmodel-1, level, nodes, set_of_nodes, nodes_per_level, fragmentgraph, distances, index_map);
    651648      LOG(2, "DEBUG: We have found " << set_of_nodes.size() << " unique induced, connected subgraphs.");
    652649    }
    … …  
    661658
    662659      /// 10. compare each converted HomologyGraph with _bindingmodel: Accept or Reject
    663       if (nodes_graph == _bindingmodel) {
    664         LOG(2, "ACCEPT: " << nodes_graph << " is identical to " << _bindingmodel);
     660      if (nodes_graph == _bindingmodel.getGraph()) {
     661        LOG(2, "ACCEPT: " << nodes_graph << " is identical to " << _bindingmodel.getGraph());
    665662        /// 11. for each accepted keyset, pick _all_ symmetric distances from arguments_t
    666663        FunctionModel::arguments_t argumentbunch;
    … …  
    687684         */
    688685
    689         /// So, we need to store for each node its type and the number of connected
    690         /// edges, which we extract from the argumentbunch.
     686        /// So, we need to extract from the argumentbunch the information contained in each
     687        /// FragmentNode, namely its type and the number of connected edges
    691688        node_FragmentNode_map_t node_FragmentNode_map = fillNodeFragmentMap(argumentbunch);
    692689
    693         /// Then, we step through the nodes of the bindingmodel
    694         const HomologyGraph::nodes_t bindingmodel_nodes = _bindingmodel.getNodes();
     690        /// Then, we step through the nodes of the bindingmodel ...
     691        /// ... and find a suitable mapping from indices in the arguments to
     692        /// the index in the order of the HomologyGraph's nodes
     693        const BindingModel::vector_nodes_t bindingmodel_nodes = _bindingmodel.getNodes();
    695694        argindex_to_nodeindex_t argindex_to_nodeindex;
    696695        size_t nodeindex = 0;
    697         for (HomologyGraph::nodes_t::const_iterator nodeiter = bindingmodel_nodes.begin();
     696        for (BindingModel::vector_nodes_t::const_iterator nodeiter = bindingmodel_nodes.begin();
    698697            nodeiter != bindingmodel_nodes.end(); ++nodeiter) {
    699           const FragmentNode &node = nodeiter->first;
     698          const FragmentNode &node = *nodeiter;
    700699          LOG(3, "DEBUG: Binding model's node #" << node << ".");
    701           // might have to pick several
    702           for (size_t pick_no = 0; pick_no < nodeiter->second; ++pick_no) {
    703             /// ... and pick for each the first (and unique) from these stored nodes.
    704             node_FragmentNode_map_t::iterator mapiter = node_FragmentNode_map.begin();
    705             for (;mapiter != node_FragmentNode_map.end(); ++mapiter) {
    706               if ((mapiter->second.first == node.getAtomicNumber())
    707                   && (mapiter->second.second == node.getConnectedEdges())) {
    708                 LOG(3, "DEBUG: #" << mapiter->first << " with type " << mapiter->second.first
    709                     << " and " << mapiter->second.second << " connected edges matches as choice #"
    710                     << pick_no << ".");
    711                 break;
    712               }
     700          /// ... and pick for each the first (and unique) from these stored nodes.
     701          node_FragmentNode_map_t::iterator mapiter = node_FragmentNode_map.begin();
     702          for (;mapiter != node_FragmentNode_map.end(); ++mapiter) {
     703            if ((mapiter->second.first == node.getAtomicNumber())
     704                && (mapiter->second.second == node.getConnectedEdges())) {
     705              LOG(3, "DEBUG: #" << mapiter->first << " with type " << mapiter->second.first
     706                  << " and " << mapiter->second.second << " connected edges matches.");
     707              break;
    713708            }
    714             ASSERT( mapiter != node_FragmentNode_map.end(),
    715                 "Extractors::reorderArgumentsByParticleTypes() - could not find a suitable node for #"+
    716                 toString(mapiter->first)+" with type "+toString(mapiter->second.first)+" and "+
    717                 toString(mapiter->second.second)+" connected edges");
    718             std::pair<argindex_to_nodeindex_t::iterator, bool> inserter =
    719                 argindex_to_nodeindex.insert( std::make_pair(mapiter->first, nodeindex++) );
    720             ASSERT( inserter.second,
    721                 "Extractors::reorderArgumentsByParticleTypes() - node #"+toString(mapiter->first)+
    722                 " is already present?");
    723             // remove to ensure uniqueness of choice
    724             node_FragmentNode_map.erase(mapiter);
    725709          }
     710          ASSERT( mapiter != node_FragmentNode_map.end(),
     711              "Extractors::reorderArgumentsByParticleTypes() - could not find a suitable node for #"+
     712              toString(mapiter->first)+" with type "+toString(mapiter->second.first)+" and "+
     713              toString(mapiter->second.second)+" connected edges");
     714          std::pair<argindex_to_nodeindex_t::iterator, bool> inserter =
     715              argindex_to_nodeindex.insert( std::make_pair(mapiter->first, nodeindex++) );
     716          ASSERT( inserter.second,
     717              "Extractors::reorderArgumentsByParticleTypes() - node #"+toString(mapiter->first)+
     718              " is already present?");
     719          // remove to ensure uniqueness of choice
     720          node_FragmentNode_map.erase(mapiter);
    726721        }
    727         /// This gives then the desired mapping from indices in the arguments to
    728         /// the index in the order of the HomologyGraph's nodes
     722        LOG(4, "DEBUG: argument's indices to node index map is " << argindex_to_nodeindex);
     723        // i.e. this is not the arg's index in argumentbunch, but the index of the position
     724        // contained in the argument_t
    729725
    730726        /// Finally, we only need to bring the arguments in the typical order:
    731727        /// 01 02 03 04 ... 0n, 12 13 14 ... 1n, 23 24 25 ... 2n, ...,  (n-1)n
     728        /// These ordering we store in a map for each argument's indices
    732729        const size_t num_args = argindex_to_nodeindex.size();
    733730        argument_placement_map_t argument_placement_map = fillArgumentsPlacementMap(num_args);
    … …  
    737734            toString(argument_placement_map.size())+" and we expected "+toString(argumentbunch.size()));
    738735
    739         // and finally resort the arguments with the known placement map
    740         FunctionModel::arguments_t sortedargs(argumentbunch);
     736        // and finally resort the arguments with the constructed placement map
     737        FunctionModel::arguments_t sortedargs(argumentbunch.size());
    741738        for (FunctionModel::arguments_t::const_iterator argiter = argumentbunch.begin();
    742739            argiter != argumentbunch.end(); ++argiter) {
    743740          const argument_t &arg = *argiter;
     741          const argument_t::indices_t translatedIndices =
     742              translateIndices(argindex_to_nodeindex, arg.indices);
    744743          const argument_placement_map_t::const_iterator indexiter =
    745               argument_placement_map.find( translateIndices(argindex_to_nodeindex, arg.indices) );
     744              argument_placement_map.find( translatedIndices );
    746745          ASSERT( indexiter != argument_placement_map.end(),
    747746              "Extractors::reorderArgumentsByParticleTypes() - could not find place for edge "+
    … …  
    749748          sortedargs[indexiter->second] = arg;
    750749          LOG(3, "DEBUG: Placed argument " << arg << " at #" << indexiter->second
    751               << " as translated indices are " << translateIndices(argindex_to_nodeindex, arg.indices));
     750              << " as translated indices are " << translatedIndices);
    752751        }
    753752        LOG(2, "DEBUG: Sorted arguments are " << sortedargs << ".");
    … …  
    755754        returnargs.push_back(sortedargs);
    756755      } else {
    757         LOG(2, "REJECT: " << nodes_graph << " is not identical to " << _bindingmodel);
     756        LOG(2, "REJECT: " << nodes_graph << " is not identical to " << _bindingmodel.getGraph());
    758757      }
    759758    }
    … …  
    767766    const HomologyGraph &_graph,
    768767    const ParticleTypes_t &_types,
    769     const HomologyGraph &_bindingmodel
     768    const BindingModel &_bindingmodel
    770769    )
    771770{

  • src/FunctionApproximation/Extractors.hpp

    rbc069f r9c793c  
    2020#include "FunctionApproximation/FunctionModel.hpp"
    2121
     22class BindingModel;
    2223class Fragment;
    2324class HomologyGraph;
    … …  
    118119      const HomologyGraph &_graph,
    119120      const ParticleTypes_t &_types,
    120       const HomologyGraph &_bindingmodel
     121      const BindingModel &_bindingmodel
    121122      );
    122123
    … …  
    135136      const HomologyGraph &_graph,
    136137      const ParticleTypes_t &_types,
    137       const HomologyGraph &_bindingmodel
     138      const BindingModel &_bindingmodel
    138139      );
    139140

  • src/Potentials/EmpiricalPotential.hpp

    rbc069f r9c793c  
    1717#include <vector>
    1818
    19 #include "Fragmentation/Homology/HomologyGraph.hpp"
    2019#include "FunctionApproximation/FunctionArgument.hpp"
    2120#include "FunctionApproximation/FunctionModel.hpp"
     21#include "Potentials/BindingModel.hpp"
    2222#include "Potentials/SerializablePotential.hpp"
    2323#include "Potentials/InternalCoordinates/Coordinator.hpp"
    … …  
    8484  /** Getter for the graph specifying the binding model of the potential.
    8585   *
    86    * \return HomologyGraph of the binding model
     86   * \return BindingModel ref of the binding model
    8787   */
    88   virtual const HomologyGraph& getBindingModel() const=0;
     88  virtual const BindingModel& getBindingModel() const=0;
    8989
    9090protected:

  • src/Potentials/Specifics/ConstantPotential.cpp

    rbc069f r9c793c  
    6565Coordinator::ptr ConstantPotential::coordinator(Memory::ignore(new OneBody_Constant()));
    6666
    67 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     67static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    6868{
    6969  // fill nodes
    7070  ASSERT( _ParticleTypes.size() <= (size_t)1,
    7171      "generateBindingModel() - ConstantPotential needs zero or one type.");
    72   HomologyGraph::nodes_t nodes;
     72  BindingModel::vector_nodes_t nodes;
    7373  if (_ParticleTypes.size() == (size_t)1)
    74     nodes.insert( std::make_pair(FragmentNode(_ParticleTypes.front(), 0), 1) );
     74    nodes.push_back( FragmentNode(_ParticleTypes.front(), 0) );
    7575
    7676  // there are no edges
    7777  HomologyGraph::edges_t edges;
    7878
    79   return HomologyGraph(nodes, edges);
     79  return BindingModel(nodes, edges);
    8080}
    8181
    … …  
    8383    EmpiricalPotential(),
    8484    params(parameters_t(MAXPARAMS, 0.)),
    85     bindingmodel(HomologyGraph())
     85    bindingmodel(BindingModel())
    8686{
    8787  // have some decent defaults for parameter_derivative checking

  • src/Potentials/Specifics/ConstantPotential.hpp

    rbc069f r9c793c  
    186186  /** Getter for the graph specifying the binding model of the potential.
    187187   *
    188    * \return HomologyGraph of the binding model
    189    */
    190   const HomologyGraph& getBindingModel() const
     188   * \return BindingModel ref of the binding model
     189   */
     190  const BindingModel& getBindingModel() const
    191191  { return bindingmodel; }
    192192
    … …  
    205205
    206206  //!> binding model for this potential
    207   const HomologyGraph bindingmodel;
     207  const BindingModel bindingmodel;
    208208};
    209209

  • src/Potentials/Specifics/FourBodyPotential_Improper.cpp

    rbc069f r9c793c  
    5353Coordinator::ptr FourBodyPotential_Improper::coordinator(Memory::ignore(new FourBody_ImproperAngle()));
    5454
    55 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     55static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    5656{
    5757  // fill nodes
    58   HomologyGraph::nodes_t nodes;
     58  BindingModel::vector_nodes_t nodes;
    5959  {
    6060    ASSERT( _ParticleTypes.size() == (size_t)4,
    6161        "generateBindingModel() - FourBodyPotential_Improper needs four types.");
    62     std::pair<HomologyGraph::nodes_t::iterator, bool > inserter;
    63     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[0], 3), 1) );
    64     if (!inserter.second)
    65       ++(inserter.first->second);
    66     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[1], 1), 1) );
    67     if (!inserter.second)
    68       ++(inserter.first->second);
    69     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[2], 1), 1) );
    70     if (!inserter.second)
    71       ++(inserter.first->second);
    72     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[3], 1), 1) );
    73     if (!inserter.second)
    74       ++(inserter.first->second);
     62    nodes.push_back( FragmentNode(_ParticleTypes[0], 3) );
     63    nodes.push_back( FragmentNode(_ParticleTypes[1], 1) );
     64    nodes.push_back( FragmentNode(_ParticleTypes[2], 1) );
     65    nodes.push_back( FragmentNode(_ParticleTypes[3], 1) );
    7566  }
    7667
    … …  
    9081  }
    9182
    92   return HomologyGraph(nodes, edges);
     83  return BindingModel(nodes, edges);
    9384}
    9485
    9586FourBodyPotential_Improper::FourBodyPotential_Improper() :
    9687    FourBodyPotential_Torsion(),
    97     bindingmodel(HomologyGraph())
     88    bindingmodel(BindingModel())
    9889{}
    9990

  • src/Potentials/Specifics/FourBodyPotential_Improper.hpp

    rbc069f r9c793c  
    6262  /** Getter for the graph specifying the binding model of the potential.
    6363   *
    64    * \return HomologyGraph of the binding model
     64   * \return BindingModel ref of the binding model
    6565   */
    66   const HomologyGraph& getBindingModel() const
     66  const BindingModel& getBindingModel() const
    6767  { return bindingmodel; }
    6868
    … …  
    8989
    9090  //!> binding model for this potential
    91   const HomologyGraph bindingmodel;
     91  const BindingModel bindingmodel;
    9292};
    9393

  • src/Potentials/Specifics/FourBodyPotential_Torsion.cpp

    rbc069f r9c793c  
    6666Coordinator::ptr FourBodyPotential_Torsion::coordinator(Memory::ignore(new FourBody_TorsionAngle()));
    6767
    68 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     68static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    6969{
    7070  // fill nodes
    71   HomologyGraph::nodes_t nodes;
     71  BindingModel::vector_nodes_t nodes;
    7272  {
    7373    ASSERT( _ParticleTypes.size() == (size_t)4,
    7474        "generateBindingModel() - FourBodyPotential_Torsion needs four types.");
    75     std::pair<HomologyGraph::nodes_t::iterator, bool > inserter;
    76     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[0], 1), 1) );
    77     if (!inserter.second)
    78       ++(inserter.first->second);
    79     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[1], 2), 1) );
    80     if (!inserter.second)
    81       ++(inserter.first->second);
    82     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[2], 2), 1) );
    83     if (!inserter.second)
    84       ++(inserter.first->second);
    85     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[3], 1), 1) );
    86     if (!inserter.second)
    87       ++(inserter.first->second);
     75    nodes.push_back( FragmentNode(_ParticleTypes[0], 1) );
     76    nodes.push_back( FragmentNode(_ParticleTypes[1], 2) );
     77    nodes.push_back( FragmentNode(_ParticleTypes[2], 2) );
     78    nodes.push_back( FragmentNode(_ParticleTypes[3], 1) );
    8879  }
    8980
    … …  
    10394  }
    10495
    105   return HomologyGraph(nodes, edges);
     96  return BindingModel(nodes, edges);
    10697}
    10798
    … …  
    109100  EmpiricalPotential(),
    110101  params(parameters_t(MAXPARAMS, 0.)),
    111   bindingmodel(HomologyGraph())
     102  bindingmodel(BindingModel())
    112103{
    113104  // have some decent defaults for parameter_derivative checking

  • src/Potentials/Specifics/FourBodyPotential_Torsion.hpp

    rbc069f r9c793c  
    193193  /** Getter for the graph specifying the binding model of the potential.
    194194   *
    195    * \return HomologyGraph of the binding model
    196    */
    197   const HomologyGraph& getBindingModel() const
     195   * \return BindingModel ref of the binding model
     196   */
     197  const BindingModel& getBindingModel() const
    198198  { return bindingmodel; }
    199199
    … …  
    221221
    222222  //!> binding model for this potential
    223   const HomologyGraph bindingmodel;
     223  const BindingModel bindingmodel;
    224224};
    225225

  • src/Potentials/Specifics/ManyBodyPotential_Tersoff.cpp

    rbc069f r9c793c  
    8282Coordinator::ptr ManyBodyPotential_Tersoff::coordinator(Memory::ignore(new OneBody_Constant()));
    8383
    84 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     84static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    8585{
    8686  // fill nodes
    87   HomologyGraph::nodes_t nodes;
     87  BindingModel::vector_nodes_t nodes;
    8888  {
    8989    ASSERT( _ParticleTypes.size() == (size_t)2,
    9090        "generateBindingModel() - ManyBodyPotential_Tersoff needs two types.");
    91     std::pair<HomologyGraph::nodes_t::iterator, bool > inserter;
    92     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[0], 1), 1) );
    93     if (!inserter.second)
    94       ++(inserter.first->second);
    95     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[1], 1), 1) );
    96     if (!inserter.second)
    97       ++(inserter.first->second);
     91    nodes.push_back( FragmentNode(_ParticleTypes[0], 1) );
     92    nodes.push_back( FragmentNode(_ParticleTypes[1], 1) );
    9893  }
    9994
    … …  
    10499  }
    105100
    106   return HomologyGraph(nodes, edges);
     101  return BindingModel(nodes, edges);
    107102}
    108103
    … …  
    117112    omega(1.),
    118113    triplefunction(&Helpers::NoOp_Triplefunction),
    119     bindingmodel(HomologyGraph())
     114    bindingmodel(BindingModel())
    120115{}
    121116

  • src/Potentials/Specifics/ManyBodyPotential_Tersoff.hpp

    rbc069f r9c793c  
    215215  /** Getter for the graph specifying the binding model of the potential.
    216216   *
    217    * \return HomologyGraph of the binding model
    218    */
    219   const HomologyGraph& getBindingModel() const
     217   * \return BindingModel ref of the binding model
     218   */
     219  const BindingModel& getBindingModel() const
    220220  { return bindingmodel; }
    221221
    … …  
    372372
    373373  //!> binding model for this potential
    374   const HomologyGraph bindingmodel;
     374  const BindingModel bindingmodel;
    375375};
    376376

  • src/Potentials/Specifics/PairPotential_Harmonic.cpp

    rbc069f r9c793c  
    6767Coordinator::ptr PairPotential_Harmonic::coordinator(Memory::ignore(new TwoBody_Length()));
    6868
    69 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     69static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    7070{
    7171  // fill nodes
    72   HomologyGraph::nodes_t nodes;
     72  BindingModel::vector_nodes_t nodes;
    7373  {
    7474    ASSERT( _ParticleTypes.size() == (size_t)2,
    7575        "generateBindingModel() - PairPotential_Harmonic needs two types.");
    76     std::pair<HomologyGraph::nodes_t::iterator, bool > inserter;
    77     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[0], 1), 1) );
    78     if (!inserter.second)
    79       ++(inserter.first->second);
    80     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[1], 1), 1) );
    81     if (!inserter.second)
    82       ++(inserter.first->second);
     76    nodes.push_back( FragmentNode(_ParticleTypes[0], 1) );
     77    nodes.push_back( FragmentNode(_ParticleTypes[1], 1) );
    8378  }
    8479
    … …  
    8984  }
    9085
    91   return HomologyGraph(nodes, edges);
     86  return BindingModel(nodes, edges);
    9287}
    9388
    … …  
    9590  EmpiricalPotential(),
    9691  params(parameters_t(MAXPARAMS, 0.)),
    97   bindingmodel(HomologyGraph())
     92  bindingmodel(BindingModel())
    9893{
    9994  // have some decent defaults for parameter_derivative checking

  • src/Potentials/Specifics/PairPotential_Harmonic.hpp

    rbc069f r9c793c  
    188188  /** Getter for the graph specifying the binding model of the potential.
    189189   *
    190    * \return HomologyGraph of the binding model
    191    */
    192   const HomologyGraph& getBindingModel() const
     190   * \return BindingModel ref of the binding model
     191   */
     192  const BindingModel& getBindingModel() const
    193193  { return bindingmodel; }
    194194
    … …  
    207207
    208208  //!> binding model for this potential
    209   const HomologyGraph bindingmodel;
     209  const BindingModel bindingmodel;
    210210};
    211211

  • src/Potentials/Specifics/PairPotential_LennardJones.cpp

    rbc069f r9c793c  
    6767Coordinator::ptr PairPotential_LennardJones::coordinator(Memory::ignore(new TwoBody_Length()));
    6868
    69 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     69static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    7070{
    7171  // fill nodes
    72   HomologyGraph::nodes_t nodes;
     72  BindingModel::vector_nodes_t nodes;
    7373  {
    7474    ASSERT( _ParticleTypes.size() == (size_t)2,
    7575        "generateBindingModel() - PairPotential_LennardJones needs two types.");
    76     std::pair<HomologyGraph::nodes_t::iterator, bool > inserter;
    77     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[0], 1), 1) );
    78     if (!inserter.second)
    79       ++(inserter.first->second);
    80     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[1], 1), 1) );
    81     if (!inserter.second)
    82       ++(inserter.first->second);
     76    nodes.push_back( FragmentNode(_ParticleTypes[0], 1) );
     77    nodes.push_back( FragmentNode(_ParticleTypes[1], 1) );
    8378  }
    8479
    … …  
    8681  HomologyGraph::edges_t edges;
    8782
    88   return HomologyGraph(nodes, edges);
     83  return BindingModel(nodes, edges);
    8984}
    9085
    … …  
    9893    EmpiricalPotential(),
    9994    params(parameters_t(MAXPARAMS, 0.)),
    100     bindingmodel(HomologyGraph())
     95    bindingmodel(BindingModel())
    10196{
    10297  // have some decent defaults for parameter_derivative checking

  • src/Potentials/Specifics/PairPotential_LennardJones.hpp

    rbc069f r9c793c  
    189189  /** Getter for the graph specifying the binding model of the potential.
    190190   *
    191    * \return HomologyGraph of the binding model
    192    */
    193   const HomologyGraph& getBindingModel() const
     191   * \return BindingModel ref of the binding model
     192   */
     193  const BindingModel& getBindingModel() const
    194194  { return bindingmodel; }
    195195
    … …  
    214214
    215215  //!> binding model for this potential
    216   const HomologyGraph bindingmodel;
     216  const BindingModel bindingmodel;
    217217};
    218218

  • src/Potentials/Specifics/PairPotential_Morse.cpp

    rbc069f r9c793c  
    6969Coordinator::ptr PairPotential_Morse::coordinator(Memory::ignore(new TwoBody_Length()));
    7070
    71 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     71static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    7272{
    7373  // fill nodes
    74   HomologyGraph::nodes_t nodes;
     74  BindingModel::vector_nodes_t nodes;
    7575  {
    7676    ASSERT( _ParticleTypes.size() == (size_t)2,
    7777        "generateBindingModel() - PairPotential_Morse needs two types.");
    78     std::pair<HomologyGraph::nodes_t::iterator, bool > inserter;
    79     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[0], 1), 1) );
    80     if (!inserter.second)
    81       ++(inserter.first->second);
    82     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[1], 1), 1) );
    83     if (!inserter.second)
    84       ++(inserter.first->second);
     78    nodes.push_back( FragmentNode(_ParticleTypes[0], 1) );
     79    nodes.push_back( FragmentNode(_ParticleTypes[1], 1) );
    8580  }
    8681
    … …  
    9186  }
    9287
    93   return HomologyGraph(nodes, edges);
     88  return BindingModel(nodes, edges);
    9489}
    9590
    … …  
    9792  EmpiricalPotential(),
    9893  params(parameters_t(MAXPARAMS, 0.)),
    99   bindingmodel(HomologyGraph())
     94  bindingmodel(BindingModel())
    10095{
    10196  // have some decent defaults for parameter_derivative checking

  • src/Potentials/Specifics/PairPotential_Morse.hpp

    rbc069f r9c793c  
    190190  /** Getter for the graph specifying the binding model of the potential.
    191191   *
    192    * \return HomologyGraph of the binding model
    193    */
    194   const HomologyGraph& getBindingModel() const
     192   * \return BindingModel ref of the binding model
     193   */
     194  const BindingModel& getBindingModel() const
    195195  { return bindingmodel; }
    196196
    … …  
    209209
    210210  //!> binding model for this potential
    211   const HomologyGraph bindingmodel;
     211  const BindingModel bindingmodel;
    212212};
    213213

  • src/Potentials/Specifics/ThreeBodyPotential_Angle.cpp

    rbc069f r9c793c  
    6767Coordinator::ptr ThreeBodyPotential_Angle::coordinator(Memory::ignore(new ThreeBody_Angle()));
    6868
    69 static HomologyGraph generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
     69static BindingModel generateBindingModel(const EmpiricalPotential::ParticleTypes_t &_ParticleTypes)
    7070{
    7171  // fill nodes
    72   HomologyGraph::nodes_t nodes;
     72  BindingModel::vector_nodes_t nodes;
    7373  {
    7474    ASSERT( _ParticleTypes.size() == (size_t)3,
    7575        "generateBindingModel() - ThreeBodyPotential_Angle needs three types.");
    76     std::pair<HomologyGraph::nodes_t::iterator, bool > inserter;
    77     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[0], 1), 1) );
    78     if (!inserter.second)
    79       ++(inserter.first->second);
    80     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[1], 2), 1) );
    81     if (!inserter.second)
    82       ++(inserter.first->second);
    83     inserter = nodes.insert( std::make_pair(FragmentNode(_ParticleTypes[2], 1), 1) );
    84     if (!inserter.second)
    85       ++(inserter.first->second);
     76    nodes.push_back( FragmentNode(_ParticleTypes[0], 1) );
     77    nodes.push_back( FragmentNode(_ParticleTypes[1], 2) );
     78    nodes.push_back( FragmentNode(_ParticleTypes[2], 1) );
    8679  }
    8780
    … …  
    9891  }
    9992
    100   return HomologyGraph(nodes, edges);
     93  return BindingModel(nodes, edges);
    10194}
    10295
    … …  
    10497  EmpiricalPotential(),
    10598  params(parameters_t(MAXPARAMS, 0.)),
    106   bindingmodel(HomologyGraph())
     99  bindingmodel(BindingModel())
    107100{
    108101  // have some decent defaults for parameter_derivative checking

  • src/Potentials/Specifics/ThreeBodyPotential_Angle.hpp

    rbc069f r9c793c  
    192192   * \return HomologyGraph of the binding model
    193193   */
    194   const HomologyGraph& getBindingModel() const
     194  const BindingModel& getBindingModel() const
    195195  { return bindingmodel; }
    196196
    … …  
    216216
    217217  //!> binding model for this potential
    218   const HomologyGraph bindingmodel;
     218  const BindingModel bindingmodel;
    219219};
    220220
Note: See TracChangeset for help on using the changeset viewer.