Add vector-valued variants

hoomd/CMakeLists.txt

@@ -95,6 +95,7 @@ set(_hoomd_sources Action.cc
                    Tuner.cc
                    Updater.cc
                    Variant.cc
+                   VectorVariant.cc
                    extern/BVLSSolver.cc
                    extern/gsd.c
                    extern/kiss_fft.cc
@@ -187,6 +188,7 @@ set(_hoomd_headers
     TextureTools.h
     Updater.h
     Variant.h
+    VectorVariant.h
     VectorMath.h
     WarpTools.cuh
     )
@@ -352,7 +354,6 @@ set(files box.py
           operations.py
           pytest_plugin_validate.py
           util.py
-          variant.py
           simulation.py
           state.py
           trigger.py
@@ -384,6 +385,7 @@ add_subdirectory(write)
 add_subdirectory(pytest)
 add_subdirectory(tune)
 add_subdirectory(update)
+add_subdirectory(variant)
 
 if (BUILD_TESTING)
     # add_subdirectory(test-py)

hoomd/Variant.h

@@ -11,10 +11,10 @@
 
 namespace hoomd
     {
-/** Defines quantities that vary with time steps.
+/** Defines scalar quantities that vary with time steps.
 
-    Variant provides an interface to define quanties (such as kT) that vary over time. The base
-    class provides a callable interface. Derived classes implement specific kinds of varying
+    Variant provides an interface to define scalar quanties (such as kT) that vary over time. The
+   base class provides a callable interface. Derived classes implement specific kinds of varying
     quantities.
 */
 class PYBIND11_EXPORT Variant

hoomd/VectorVariant.cc

@@ -0,0 +1,106 @@
+// Copyright (c) 2009-2023 The Regents of the University of Michigan.
+// Part of HOOMD-blue, released under the BSD 3-Clause License.
+
+#include "VectorVariant.h"
+#include <pybind11/stl.h>
+
+namespace hoomd
+    {
+//* Trampoline for classes inherited in python
+class VectorVariantBoxPy : public VectorVariantBox
+    {
+    public:
+    // Inherit the constructors
+    using VectorVariantBox::VectorVariantBox;
+
+    // trampoline method
+    array_type operator()(uint64_t timestep) override
+        {
+        PYBIND11_OVERLOAD_NAME(array_type,       // Return type
+                               VectorVariantBox, // Parent class
+                               "__call__",       // name of function in python
+                               operator(),       // Name of function in C++
+                               timestep          // Argument(s)
+        );
+        }
+    };
+
+namespace detail
+    {
+
+void export_VectorVariantBox(pybind11::module& m)
+    {
+    pybind11::class_<VectorVariantBox, VectorVariantBoxPy, std::shared_ptr<VectorVariantBox>>(
+        m,
+        "VectorVariantBox")
+        .def(pybind11::init<>())
+        .def("__call__", &VectorVariantBox::operator());
+
+    pybind11::class_<VectorVariantBoxConstant,
+                     VectorVariantBox,
+                     std::shared_ptr<VectorVariantBoxConstant>>(m, "VectorVariantBoxConstant")
+        .def(pybind11::init<std::shared_ptr<BoxDim>>())
+        .def_property("box", &VectorVariantBoxConstant::getBox, &VectorVariantBoxConstant::setBox)
+        /*
+        .def(
+            pybind11::pickle(
+                [](VectorVariantBoxConstant& variant)
+                {
+                    std::shared_ptr<BoxDim> box = variant.getBox();
+                    std::array<Scalar, 6> arr = {box->getL().x,
+                                                 box->getL().y,
+                                                 box->getL().z,
+                                                 box->getTiltFactorXY(),
+                                                 box->getTiltFactorXZ(),
+                                                 box->getTiltFactorYZ()};
+                    return pybind11::make_tuple(arr);
+                },
+                [](pybind11::tuple params)
+                {
+                    Scalar Lx = params[0][0].cast<Scalar>();
+                    Scalar Ly = params[0][1].cast<Scalar>();
+                    Scalar Lz = params[0][2].cast<Scalar>();
+                    Scalar xy = params[0][3].cast<Scalar>();
+                    Scalar xz = params[0][4].cast<Scalar>();
+                    Scalar yz = params[0][5].cast<Scalar>();
+                    std::shared_ptr<BoxDim> box(Lx, Ly, Lz);
+                    box->setTiltFactors(xy, xz, yz);
+                    return VectorVariantBoxConstant(box);
+                }));
+                */
+        ;
+
+    pybind11::class_<VectorVariantBoxLinear,
+                     VectorVariantBox,
+                     std::shared_ptr<VectorVariantBoxLinear>>(m, "VectorVariantBoxLinear")
+        .def(pybind11::init<std::shared_ptr<BoxDim>, std::shared_ptr<BoxDim>, std::shared_ptr<Variant>>())
+        .def_property("initial_box",
+                      &VectorVariantBoxLinear::getBox1,
+                      &VectorVariantBoxLinear::setBox1)
+        .def_property("final_box",
+                      &VectorVariantBoxLinear::getBox2,
+                      &VectorVariantBoxLinear::setBox2)
+        .def_property("variant",
+                      &VectorVariantBoxLinear::getVariant,
+                      &VectorVariantBoxLinear::setVariant);
+
+    pybind11::class_<VectorVariantBoxInverseVolumeRamp,
+                     VectorVariantBox,
+                     std::shared_ptr<VectorVariantBoxInverseVolumeRamp>>(
+        m,
+        "VectorVariantBoxInverseVolumeRamp")
+        .def(pybind11::init<std::shared_ptr<BoxDim>, Scalar, uint64_t, uint64_t>())
+        .def_property("box1",
+                      &VectorVariantBoxInverseVolumeRamp::getBox1,
+                      &VectorVariantBoxInverseVolumeRamp::setBox1)
+        .def_property("t_start",
+                      &VectorVariantBoxInverseVolumeRamp::getTStart,
+                      &VectorVariantBoxInverseVolumeRamp::setTStart)
+        .def_property("t_ramp",
+                      &VectorVariantBoxInverseVolumeRamp::getTRamp,
+                      &VectorVariantBoxInverseVolumeRamp::setTRamp);
+    }
+
+    } // end namespace detail
+
+    } // end namespace hoomd