Pyberny addition

.gitignore

@@ -0,0 +1 @@
+__pycache__/

CMakeLists.txt

@@ -0,0 +1,62 @@
+cmake_minimum_required(VERSION 3.14)
+
+## Set Project and Version
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/version.txt" VERSION)
+project(structurefinder VERSION "${VERSION}" LANGUAGES CXX)
+
+## Get CMaize
+include(cmake/get_cmaize.cmake)
+
+## Paths ##
+set(${PROJECT_NAME}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
+set(${PROJECT_NAME}_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
+set(${PROJECT_NAME}_TESTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/tests")
+
+## Options ##
+cmaize_option_list(
+    BUILD_TESTING OFF "Should the tests be built?"
+)
+
+## Find or build dependencies ##
+cmaize_find_or_build_dependency(
+    simde
+    URL github.com/NWChemEx/SimDE
+    VERSION master
+    BUILD_TARGET simde
+    FIND_TARGET nwx::simde
+    CMAKE_ARGS BUILD_TESTING=OFF
+)
+
+## Add libraries ##
+cmaize_add_library(
+    ${PROJECT_NAME}
+    SOURCE_DIR "${${PROJECT_NAME}_SOURCE_DIR}/${PROJECT_NAME}"
+    INCLUDE_DIRS "${${PROJECT_NAME}_INCLUDE_DIR}/${PROJECT_NAME}"
+    DEPENDS simde
+)
+
+## Build tests ##
+if("${BUILD_TESTING}")
+    ## Find or build dependencies for tests
+    cmaize_find_or_build_dependency(
+        Catch2
+        URL github.com/catchorg/Catch2
+        BUILD_TARGET Catch2
+        FIND_TARGET Catch2::Catch2
+        VERSION v2.x
+    )
+
+    ## Add Tests ##
+    cmaize_add_tests(
+        test_${PROJECT_NAME}
+        SOURCE_DIR "${${PROJECT_NAME}_TESTS_DIR}/unit_tests"
+        INCLUDE_DIRS "${${PROJECT_NAME}_INCLUDE_DIR}/${PROJECT_NAME}"
+        DEPENDS Catch2 ${PROJECT_NAME}
+    )
+
+endif()
+
+## Add package ##
+cmaize_add_package(
+    ${PROJECT_NAME} NAMESPACE ${PROJECT_NAME}::
+)

cmake/get_cmaize.cmake

@@ -0,0 +1,35 @@
+function(get_cmaize)
+
+    if("${CMAIZE_VERSION}" STREQUAL "")
+        set(CMAIZE_VERSION v1.1.0 )
+    endif()
+
+    # Store whether we are building tests or not, then turn off the tests
+    if(BUILD_TESTING)
+        set(build_testing_old "${BUILD_TESTING}")
+    endif()
+    set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
+
+    # Download CMakePP and bring it into scope
+    include(FetchContent)
+    FetchContent_Declare(
+        cmaize
+        GIT_REPOSITORY https://github.com/CMakePP/CMaize
+        GIT_TAG ${CMAIZE_VERSION}
+    )
+    FetchContent_MakeAvailable(cmaize)
+
+    # Restore the previous value, if set
+    # Unset otherwise
+    if(build_testing_old)
+        set(BUILD_TESTING "${build_testing_old}" CACHE BOOL "" FORCE)
+    else()
+        unset(BUILD_TESTING CACHE)
+    endif()
+endfunction()
+
+# Call the function we just wrote to get CMaize
+get_cmaize()
+
+# Include CMaize
+include(cmaize/cmaize)

src/python/structurefinder/__init__.py

@@ -0,0 +1,8 @@
+import pluginplay as pp
+from simde import TotalEnergy
+
+def __init__(self):
+    pp.ModuleBase.__init__(self)
+    self.description("Geometry Optimizer Plugin")
+    self.satisfies_property_type(TotalEnergy())
+    self.add_input('molecule')

src/python/structurefinder/pybernyopt.py

@@ -0,0 +1,36 @@
+from nwchemex import chemist
+from berny import Berny, geomlib, optimize
+from berny.solvers import MopacSolver
+
+# Molecule for testing
+#h2 = chemist.Molecule()
+#a1       = chemist.Atom("H", 1, 1.0079, 0.0, 0.0, 0.0)
+#a2       = chemist.Atom("H", 1, 1.0079, 0.0, 0.0, 1.0)
+#h2.push_back(a1)
+#h2.push_back(a2)
+
+def optimize_pyberny(molecule):
+    """
+    This function takes a chemical system and uses PyBerny
+    to optimize the provided geometry (molecule) and 
+    returns the energy of the optimized system.
+    """
+    # Convert a Chemical System to an XYZ coordinate string
+    xyz = str(molecule.size()) + "\n\n" + str(molecule.nuclei)
+
+    # Loads the geometry string into the Berny optimizer
+    # object.
+    optimizer = Berny(geomlib.loads(xyz, fmt='xyz'))
+
+    # Uses MOPAC/OpenMOPAC to perform geometry optimization.
+    # The program "mopac" must be in system PATH
+    solver = MopacSolver()
+    next(solver)
+    for geom in optimizer:
+        energy, gradients = solver.send((list(geom), geom.lattice))
+        optimizer.send((energy, gradients))
+
+    relaxed = geom
+    xyz_opt = relaxed.dumps(fmt='xyz')
+    # Optimized energy is of type "float"
+    return energy, xyz_opt

version.txt

@@ -0,0 +1 @@
+0.0.0