digichem-core 6.1.0__py3-none-any.whl → 6.10.1__py3-none-any.whl

digichem/__init__.py

@@ -20,7 +20,7 @@ from digichem.datas import get_resource
 # development = prerelease is not None
 # # The full version number of this package.
 # __version__ = "{}.{}.{}{}".format(major_version, minor_version, revision, "-pre.{}".format(prerelease) if development else "")
-__version__ = "6.1.0"
+__version__ = "6.10.1"
 _v_parts = __version__.split("-")[0].split(".")
 major_version = int(_v_parts[0])
 minor_version = int(_v_parts[1])
@@ -39,7 +39,7 @@ __author__ = [
 ]
 
 # Program date (when we were last updated). This is changed automatically.
-_last_updated_string = "16/10/2024"
+_last_updated_string = "28/05/2025"
 last_updated = datetime.strptime(_last_updated_string, "%d/%m/%Y")
 
 # The sys attribute 'frozen' is our flag, '_MEIPASS' is the dir location.

digichem/config/base.py

@@ -33,6 +33,7 @@ class Digichem_options(Configurable):
         help = "Options specifying paths to various external programs that digichem may use. If no path is given, then these programs will simply be executed by name (so relying on OS path resolution to find the necessary executables, which is normally fine.)",
         formchk = Option(help = "Gaussian's formchk utility https://gaussian.com/formchk/", default = "formchk"),
         cubegen = Option(help = "Gaussian's cubegen utility https://gaussian.com/cubegen/", default = "cubegen"),
+        cubegen_parallel = Option(help = "What type of parallelism to use with cubegen, multithreaded runs a single instance of cubegen across multiple CPUs, pool runs multiple instances of cubegen", choices = [None, "multithreaded", "pool"], default = "pool")
     )
     
     skeletal_image = Options(
@@ -70,10 +71,11 @@ Possible options are:
             ),
         ),
         batoms = Options(help = "Beautiful Atoms/Blender specific options (only applies if engine == 'batoms'",
-            blender = Option(help = "Path to the blender executable, in which beautiful atoms should be installed", default = None),
+            blender = Option(help = "Path to the blender executable, in which beautiful atoms should be installed", default = "batoms-blender"),
             cpus = Option(help = "The number of CPUs/threads to use. This option is overridden if running in a calculation environemnt (where it uses the same number of CPUs as the calculation did)", type = int, default = 1),
-            render_samples = Option(help = "The number of render samples (or passes) to use. Higher values result in higher image quality and greater render times", type = int, default = 64),
-            perspective = Option(help = "The perspective mode", choices = ["orthographic", "perspective"], default = "orthographic")
+            render_samples = Option(help = "The number of render samples (or passes) to use. Higher values result in higher image quality and greater render times", type = int, default = 32),
+            perspective = Option(help = "The perspective mode", choices = ["orthographic", "perspective"], default = "perspective"),
+            stacking = Option(help = "The number of image copies to composite together to avoid transparency artifacts", type = int, default = 10)
             # TODO: Colour options.
         ),
         safe_cubes = Option(help = "Whether to sanitize cubes so older software can parse them (VMD < 1.9.2 etc)", type = bool, default = False),

digichem/data/batoms/batoms-renderer.py

@@ -7,6 +7,16 @@
 #
 # Where 'blender' is the path to the Beautiful Atoms Blender executable.
 
+
+# import debugpy
+# debugpy.listen(5678)
+# debugpy.wait_for_client()
+
+import addon_utils
+def handle_error(exception):
+    raise exception
+addon_utils.enable("batoms", handle_error = handle_error, default_set=True)
+
 import sys
 import argparse
 import itertools
@@ -19,6 +29,50 @@ import logging
 import ase.io
 from batoms import Batoms
 from batoms.utils.butils import object_mode
+from batoms.render import Render
+
+class Digichem_render(Render):
+    def set_viewport_distance_center(self, center=None, padding=0, canvas=None):
+        """
+        Calculate canvas and direction
+        """
+        batoms = self.batoms
+        if padding is None:
+            padding = max(batoms.size) + 0.5
+        if center is None:
+            center = batoms.get_center_of_geometry()
+        self.center = center
+        if canvas is None:
+            width, height, depth = batoms.get_canvas_box(
+                direction=self.viewport, padding=padding
+            )
+        else:
+            width = canvas[0]
+            height = canvas[1]
+            depth = canvas[2]
+        if self.distance < 0:
+            self.distance = max(10, depth)
+
+        self.update_camera(width, height, depth / 2)
+
+        # To auto centre the camera, we need to select the molecule as well as all isosurfaces that might be present.
+        # Select the molecule.
+        self.batoms.obj.select_set(True)
+
+        # Isosurfaces.
+        for obj in self.batoms.coll.all_objects:
+            if obj.batoms.type == "ISOSURFACE":
+                obj.select_set(True)
+
+        # Set camera as active.
+        bpy.context.scene.camera = self.camera.obj
+
+        # Manually set a focal point.
+        self.camera.lens = 50
+        # Auto centre.
+        bpy.ops.view3d.camera_to_view_selected()
+
+        self.update_light()
 
 def add_molecule(
         cube_file,
@@ -55,25 +109,41 @@ def add_molecule(
     mol = Batoms(name, from_ase = cube["atoms"])
     
     # Set some look and feel options.    
-    # Change molecule style.
-    mol.model_style = 1
     
     # Hide cell boundaries.
     mol.cell.hide = True
     
     # Colour tuning.
     # Carbon to 'black'.
-    try:
-        mol["C"].color = (0.095, 0.095, 0.095, 1)
-    except AttributeError:
-        pass
-    try:
-        mol["B"].color = (1.0, 0.396, 0.468, 1)
-    except AttributeError:
-        pass
+    new_colors = {
+        "C": (0.095, 0.095, 0.095, 1),
+        "B": (1.0, 0.396, 0.468, 1)
+    }
+
+    for atom, color in new_colors.items():
+        try:
+            mol[atom].color = color
+        except AttributeError:
+            pass
+
+    # And bonds.
+    for key, value in mol.bond.settings.items():
+        for atom, color in new_colors.items():
+            if key[0] == atom:
+                value['color1'] = color
+
+            if key[1] == "C":
+                value['color2'] = color
     
-    if not visible:
-        mol.hide = True
+    # Change molecule style.
+    mol.model_style = 1
+
+    # Slightly increase volume of all atoms.
+    for atom in mol.species.keys():
+        mol[atom].scale *= 1.25
+    
+    # Increase volume of H atoms
+    mol['H'].scale = 0.75
     
     # Add volumes.
     if len(surface_settings) != 0:
@@ -85,15 +155,9 @@ def add_molecule(
         mol.isosurface.draw()
     
     # Now move the entire molecule (isosurface and all) back to the origin.
-    mol.translate(cube["origin"][0:3])
-    
-    # Fix the origin point so we can still rotate properly.
-    # For some reason, this code moves the bond objects to a new location?
-#     object_mode()
-#     bpy.ops.object.select_all(action='DESELECT')
-#     mol.obj.select_set(True)
-#     bpy.context.view_layer.objects.active = mol.obj
-#     bpy.ops.object.origin_set(type='ORIGIN_CURSOR')
+    mol.obj.select_set(True)
+    bpy.ops.object.origin_set(type="ORIGIN_GEOMETRY", center='MEDIAN')
+    bpy.context.object.location = [0,0,0]
     
     # If we have any rotations, apply those.
     for axis, angle in rotations:
@@ -123,6 +187,9 @@ def add_molecule(
         bpy.ops.transform.rotate(value=angle, orient_axis=axis.upper(),
                                  center_override = (0,0,0))
     
+    if not visible:
+        mol.hide = True
+    
     return mol
 
 # Adapted from https://blender.stackexchange.com/questions/5898/how-can-i-create-a-cylinder-linking-two-points-with-python?newreg=f372ba9448694f5b97879a6dab963cee
@@ -173,7 +240,13 @@ def draw_primitive(start, end, radius, mesh_type, color, collection = None):
     bsdf = nodes["Principled BSDF"]
     bsdf.inputs["Base Color"].default_value = color
     bsdf.inputs["Metallic"].default_value = 0.1
-    bsdf.inputs["Specular"].default_value = 0.2
+    try:
+        # Blener 3.x
+        bsdf.inputs["Specular"].default_value = 0.2
+    except KeyError:
+        # Blender 4.x
+        bsdf.inputs["Specular IOR Level"].default_value = 0.2
+    
     bsdf.inputs["Roughness"].default_value = 0.2
     mat.diffuse_color = color
     
@@ -186,6 +259,8 @@ def draw_primitive(start, end, radius, mesh_type, color, collection = None):
     # Link each object to the target collection
     collection.objects.link(obj)
 
+    return obj
+
     
 def draw_arrow(start, end, radius, color, split = 0.9, collection = None):
     # Decide what proportion of the total vector to dedicate to the arrow stem and head.
@@ -195,8 +270,23 @@ def draw_arrow(start, end, radius, color, split = 0.9, collection = None):
     dist = math.sqrt(dx**2 + dy**2 + dz**2)
     
     join = (dx * split + start[0], dy * split + start[1], dz * split + start[2])
-    draw_primitive(start, join, radius, "cylinder", color, collection = collection)
-    draw_primitive(join, end, radius*2, "cone", color, collection = collection)
+    cylinder = draw_primitive(start, join, radius, "cylinder", color, collection = collection)
+    cone = draw_primitive(join, end, radius*2, "cone", color, collection = collection)
+
+    # Select the two objects and join them together.
+    bpy.ops.object.select_all(action='DESELECT')
+    cylinder.select_set(True)
+    cone.select_set(True)
+    bpy.ops.object.join()
+
+    arrow = cone
+
+    # Set the origin of the new combined object to the origin of the arrow.
+    bpy.context.scene.cursor.location = start
+    bpy.ops.object.origin_set(type='ORIGIN_CURSOR')
+
+    return arrow
+
 
 
 def main():
@@ -205,25 +295,25 @@ def main():
         description='Render images with BAtoms')
     
     parser.add_argument("cube_file", help = "Path to the cube file to read")
-    parser.add_argument("output", help = "File to write to")
+    parser.add_argument("output", help = "File to write to", nargs="?", default = None)
     parser.add_argument("--second_cube", help = "Optional second cube file to read additional isosurface data from", default = None)
     parser.add_argument("--isovalues", help = "List of isovalues to render", nargs = "*", type = float, default = [])
     parser.add_argument("--isotype", help = "Whether to render positive, negative or both isosurfaces for each isovalue", choices = ["positive", "negative", "both"], default = "both")
     parser.add_argument("--isocolor", help = "The colouring method to use for isosurfaces", choices = ["sign", "cube"], default = "sign")
-    parser.add_argument("--primary-color", help = "RGBA for one of the colors to use for isosurfaces", type = float, nargs = 4, default = [0.1, 0.1, 0.9, 0.65])
-    parser.add_argument("--secondary-color", help = "RGBA for the other color to use for isosurfaces", type = float, nargs = 4, default = [1, 0.058, 0.0, 0.65])
-    parser.add_argument("--style", help = "Material style for isosurfaces", choices = ('default', 'metallic', 'plastic', 'ceramic', 'mirror'), default = "default")
+    parser.add_argument("--primary-color", help = "RGBA for one of the colors to use for isosurfaces", type = float, nargs = 4, default = [0.1, 0.1, 0.9, 0.5])
+    parser.add_argument("--secondary-color", help = "RGBA for the other color to use for isosurfaces", type = float, nargs = 4, default = [1, 0.058, 0.0, 0.5])
+    parser.add_argument("--style", help = "Material style for isosurfaces", choices = ('default', 'metallic', 'plastic', 'ceramic', 'mirror'), default = "ceramic")
     parser.add_argument("--cpus", help = "Number of parallel CPUs to use for rendering", type = int, default = 1)
     parser.add_argument("--use-gpu", help = "Whether to enable GPU rendering", action = "store_true")
-    parser.add_argument("--orientation", help = "The orientation to render from, as x, y, z values", nargs = 3, type = float, default = [0, 0, 1])
+    parser.add_argument("--orientation", help = "The orientation to render from, as x, y, z values", nargs = 3, type = float, default = [0, 0, 0])
     parser.add_argument("--resolution", help = "The output resolution in px", type = int, default = 1024)
-    parser.add_argument("--render-samples", help = "The maximum number of render samples, more generally results in higher quality but longer render times", type = int, default = 256)
+    parser.add_argument("--render-samples", help = "The maximum number of render samples, more generally results in higher quality but longer render times", type = int, default = 64)# default = 256)
     parser.add_argument("--rotations", help = "A list of rotations (in JSON) to rotate the molecule to a given alignment. The first item in each list item is the axis to rotate about (0=x, 1=y, 2=z), the second is the angle to rotate by (in radians)", nargs = "*", default = [])
     parser.add_argument("--dipoles", help = "Draw dipoles from a list of the following data (in JSON): 0) start coord, 1) end coord, 2) RGBA color information", nargs = "*", default = [])
-    parser.add_argument("--alpha", help = "Override the opacity value for all molecule objects (but not dipoles) to this value, useful for showing dipole arrows more clearly", default = None, type = float)
+    parser.add_argument("--alpha", help = "Override the opacity value for all molecule objects (but not dipoles) to  1- this value, useful for showing dipole arrows more clearly", default = None, type = float)
     parser.add_argument("--perspective", help = "The perspective mode, either orthographic or perspective", default = "perspective", choices = ["perspective", "orthographic"])
     parser.add_argument("--padding", help = "Padding", type = float, default = 1.0)
-    
+    parser.add_argument("--multi", help = "Render multiple images, each of a different angle of the scene. Each argument should consist of 6 parts, the x y z position, the resolution, the samples, and the filename (which is appended to 'output')", nargs = 6, default =[], action="append")
     # Both blender and python share the same command line arguments.
     # They are separated by double dash ('--'), everything before is for blender,
     # everything afterwards is for python (except for the first argument, wich is
@@ -237,11 +327,21 @@ def main():
     
     # Batoms or blender will silently set the extension to png if it's not already.
     # This is surprising, so stop now before that happens.
-    if Path(args.output).suffix.lower() != ".png":
+    if args.output is not None and Path(args.output).suffix.lower() != ".png":
         raise ValueError("Output location must have a .png extension")
     
     if args.rotations is not None:
         rotations = [yaml.safe_load(rotation) for rotation in args.rotations]
+
+    if args.multi != []:
+        if args.orientation != [0, 0, 0]:
+            raise ValueError("You cannot set both --orientation and --multi!")
+
+        if args.resolution != 1024:
+            raise ValueError("You cannot set both --resolution and --multi!")
+        
+        if args.output is not None:
+            raise ValueError("You cannot set both 'output' and --multi!")
     
     # Remove the starting cube object.
     bpy.ops.object.select_all(action='SELECT')
@@ -250,7 +350,7 @@ def main():
     # Load the input data.
     mol = add_molecule(
         args.cube_file,
-        name = "molecule",
+        name = "first_mol",
         visible = True,
         rotations = rotations,
         isovalues = args.isovalues,
@@ -263,13 +363,14 @@ def main():
     # Uncomment to show atom labels.
     # Needs some tweaking to appear in render (viewport only by default).
     #mol.show_label = 'species'
+    mol2 = None
     
     # If we have a second cube, add that too.
     if args.second_cube is not None:
         mol2 = add_molecule(
             args.second_cube,
-            name = "molecule2",
-            visible = True,
+            name = "second_mol",
+            visible = False,
             rotations = rotations,
             isovalues = args.isovalues,
             isotype = args.isotype,
@@ -282,29 +383,27 @@ def main():
         # Set all materials transparent.
         for material in bpy.data.materials:
             try:
-                material.node_tree.nodes['Principled BSDF'].inputs['Alpha'].default_value = args.alpha
+                material.node_tree.nodes['Principled BSDF'].inputs['Alpha'].default_value = (1 - args.alpha)
             except Exception as e:
                 pass
         
     
     # Draw any dipoles.
+    arrows = []
     if args.dipoles is not None:
         
         dipoles = [yaml.safe_load(dipole) for dipole in args.dipoles]
         for start_coord, end_coord, rgba in dipoles:
-            draw_arrow(start_coord, end_coord, 0.08, rgba, collection = mol.coll)
+            arrows.append(draw_arrow(start_coord, end_coord, 0.1, rgba, collection = mol.coll))
         
     
     # Setup rendering settings.
 #     mol.render.engine = 'workbench'
 #     mol.render.engine = 'eevee'
     mol.render.engine = 'cycles'
-    mol.render.resolution = [args.resolution, args.resolution]
     # Set up cycles for good quality rendering.
     # Prevents early end to rendering (forces us to use the actual number of samples).
     bpy.context.scene.cycles.use_adaptive_sampling = False
-    # Quality control, more = better and slower.
-    bpy.context.scene.cycles.samples = args.render_samples
     # Post-processing to remove noise, works well for coloured backgrounds, useless for transparency.
     bpy.context.scene.cycles.use_denoising = True
     # Ray-tracing options
@@ -316,8 +415,23 @@ def main():
     # Use maximum compression.
     bpy.context.scene.render.image_settings.compression = 1000
     
+
     # Change light intensity.
-    bpy.data.lights["batoms_light_Default"].node_tree.nodes["Emission"].inputs[1].default_value = 0.5 #0.3
+    mol.render.lights["Default"].direction = [0.1, 0.1, 1]
+    mol.render.lights["Default"].obj.data.node_tree.nodes["Emission"].inputs[1].default_value = 0.2
+    mol.render.lights["Default"].obj.data.angle = 0.174533
+
+    # Add a second light for depth.
+    mol.render.lights.add("Accent1", direction = [1,0.5,0.75])
+    mol.render.lights.add("Accent2", direction = [0.5,1,0.75])
+
+    mol.render.lights["Accent1"].obj.data.angle = 0.0872665
+    mol.render.lights["Accent1"].obj.data.node_tree.nodes["Emission"].inputs[1].default_value = 0.25
+    mol.render.lights["Accent2"].obj.data.angle = 0.0872665
+    mol.render.lights["Accent2"].obj.data.node_tree.nodes["Emission"].inputs[1].default_value = 0.25
+
+    # bpy.data.lights["batoms_light_Default"].node_tree.nodes["Emission"].inputs[1].default_value = 0.45
+    # bpy.data.lights["batoms_light_Default"].angle
     #mol.render.lights["Default"].energy=10
     
     # Change view mode.
@@ -339,14 +453,40 @@ def main():
     bpy.context.scene.render.threads_mode = 'FIXED'
     bpy.context.scene.render.threads = args.cpus
     
-    mol.get_image(viewport = args.orientation, output = args.output, padding = args.padding)
-#     # Move the camera.
-#     mol.render.camera.location = (100,0,0)
-#     mol.render.camera.look_at = mol.get_center_of_geometry()
-#     bpy.ops.object.select_all(action='DESELECT')
-#     for obj in mol.coll.objects[:]:
-#         obj.select_set(True)
-#     #bpy.ops.view3d.camera_to_view_selected()
+    # Set our custom renderer so we can modify zoom etc.
+    mol.render = Digichem_render()
+
+    # We have two ways we can change which angle we render from.
+    # 1) the viewport keyword arg (which places the camera in a certain location).
+    # 2) rotate the molecule.
+    #
+    # We use option 2, because this gives us more control.
+
+    # Work out how many angles we're rendering from.
+    if args.multi == []:
+        # Just one.
+        targets = [[args.orientation[0], args.orientation[1], args.orientation[2], args.resolution, args.render_samples, args.output]]
+    
+    else:
+        # More than one.
+        targets = args.multi
+
+    for x, y, z, resolution, samples, full_file_name in targets:
+        # Add args.output and mini_file_name together (useful for --multi).
+        orientation = (float(x), float(y), float(z))
+
+        mol.render.resolution = [resolution, resolution]
+        # Quality control, more = better and slower.
+        bpy.context.scene.cycles.samples = int(samples)
+        mol.obj.delta_rotation_euler = orientation
+        
+        if mol2 is not None:
+            mol2.obj.delta_rotation_euler = orientation
+
+        for arrow in arrows:
+            arrow.delta_rotation_euler = orientation
+
+        mol.get_image(viewport = [0,0,1], output = full_file_name, padding = args.padding)
     
     return 0