Changeset e83114 for src/Potentials

Timestamp:

Aug 30, 2025, 2:41:40 PM (2 months ago)

Author:

Frederik Heber <frederik.heber@…>

Branches:

Candidate_v1.7.0, stable

Children:

a0d8aa

Parents:

72b6d7

git-author:

Frederik Heber <frederik.heber@…> (08/16/25 10:32:39)

git-committer:

Frederik Heber <frederik.heber@…> (08/30/25 14:41:40)

Message:

StreamFactory_EmpiricalPotential creates potential instances with params.

• EmpiricalPotential expose getter and setter for parameters.
• potential and stream factor for EmpiricalPotential have new createInstance that also takes a present parameter set.
• this is used in StreamFactory_EmpiricalPotential::createInstance from istream to create the correct instance with parameters directly.

Location:

src/Potentials

Files:

• EmpiricalPotential.hpp (modified) (1 diff)
• PotentialFactory.cpp (modified) (1 diff)
• PotentialFactory.hpp (modified) (1 diff)
• StreamFactory_EmpiricalPotential.cpp (modified) (1 diff)
• StreamFactory_EmpiricalPotential.hpp (modified) (1 diff)

src/Potentials/EmpiricalPotential.hpp

@@ -95 +95 @@
   virtual unsigned int getParticleTypeNumber() const=0;
 
+  /** Sets the parameters from a given vector.
+   *
+   * \param params vector of parameters, specific to a specialized potential
+   */
+  virtual void setParameters(const parameters_t &params)=0;
+
+  /** Getter for the parameter set for this specialized potential.
+   *
+   * \return vector of parameters
+   */
+  virtual parameters_t getParameters() const=0;
+
 protected:
   /** Default constructor for class EmpiricalPotential.

src/Potentials/PotentialFactory.cpp

@@ -137 +137 @@
 }
 
-EmpiricalPotential* PotentialFactory::getDefaultPotential(const std::string &_name) const
-{
-  EmpiricalPotential *potential = NULL;
-  switch (getTypeForName(_name)) {
+EmpiricalPotential *PotentialFactory::createInstance(
+    const std::string &potentialtype,
+    const SerializablePotential::ParticleTypes_t &types,
+                const FunctionModel::parameters_t &params) const
+{
+        EmpiricalPotential *potential = NULL;
+  switch (getTypeForName(potentialtype)) {
   case constant:
-    potential = new ConstantPotential();
-    break;
+      potential = new ConstantPotential(types);
+      break;
   case tersoff:
-    potential = new ManyBodyPotential_Tersoff();
-    break;
+      potential = new ManyBodyPotential_Tersoff(types);
+      break;
   case morse:
-    potential = new PairPotential_Morse();
-    break;
+      potential = new PairPotential_Morse(types);
+      break;
   case harmonic_bond:
-    potential = new PairPotential_Harmonic();
-    break;
+      potential = new PairPotential_Harmonic(types);
+      break;
   case harmonic_angle:
-    potential = new ThreeBodyPotential_Angle();
-    break;
+      potential = new ThreeBodyPotential_Angle(types);
+      break;
   case lennardjones:
-    potential = new PairPotential_LennardJones();
-    break;
+      potential = new PairPotential_LennardJones(types);
+      break;
   case torsion:
-    potential = new FourBodyPotential_Torsion();
-    break;
+      potential = new FourBodyPotential_Torsion(types);
+      break;
   case improper:
-    potential = new FourBodyPotential_Improper();
-    break;
+      potential = new FourBodyPotential_Improper(types);
+      break;
   default:
     ASSERT(0, "PotentialFactory::createInstance() - unknown potential desired to create.");
     break;
   }
+  if (potential != NULL)
+        potential->setParameters(params);
   return potential;
+}
+
+EmpiricalPotential* PotentialFactory::getDefaultPotential(const std::string &_name) const
+{
+  switch (getTypeForName(_name)) {
+  case constant:
+    return new ConstantPotential();
+  case tersoff:
+    return new ManyBodyPotential_Tersoff();
+  case morse:
+    return new PairPotential_Morse();
+  case harmonic_bond:
+    return new PairPotential_Harmonic();
+  case harmonic_angle:
+    return new ThreeBodyPotential_Angle();
+  case lennardjones:
+    return new PairPotential_LennardJones();
+  case torsion:
+    return new FourBodyPotential_Torsion();
+  case improper:
+    return new FourBodyPotential_Improper();
+  default:
+    ASSERT(0, "PotentialFactory::createInstance() - unknown potential desired to create.");
+    break;
+  }
+  return NULL;
 }
 

src/Potentials/PotentialFactory.hpp

@@ -59 +59 @@
       const SerializablePotential::ParticleTypes_t &charges) const;
 
+  /** Creates an instance of the requested potential.
+   *
+   * \param potentialtype key of potential to create
+   * \param charges charges for which the potential is (to be) fitted
+   */
+  EmpiricalPotential *createInstance(
+      const std::string &potentialtype,
+      const SerializablePotential::ParticleTypes_t &charges,
+                        const FunctionModel::parameters_t &params) const;
+
   //!> typedef for map to lookup type for a given name
   typedef std::map< std::string, enum PotentialTypes > NameToType_t;

src/Potentials/StreamFactory_EmpiricalPotential.cpp

@@ -56 +56 @@
     potential->stream_from(serialized);
     // then create a proper instance which also has the correct BindingModel
-    full_potential = createInstance(potentialtype, potential->getParticleTypes());
-    // finally, serialize&deserialize parameters from default into the full instance
-    std::stringstream parameter_stream;
-    potential->stream_to(parameter_stream);
-    full_potential->stream_from(parameter_stream);
+    full_potential = createInstance(potentialtype, potential->getParticleTypes(), potential->getParameters());
     LOG(3, "Deserialized full potential: " << *full_potential);
     delete potential;

src/Potentials/StreamFactory_EmpiricalPotential.hpp

@@ -55 +55 @@
       const SerializablePotential::ParticleTypes_t &charges) const=0;
 
+  virtual EmpiricalPotential *createInstance(
+      const std::string &potentialtype,
+      const SerializablePotential::ParticleTypes_t &charges,
+                        const FunctionModel::parameters_t &params) const=0;
+
 };