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

digichem/file/cube.py

@@ -3,11 +3,17 @@
 from pathlib import Path
 import subprocess
 import tempfile
-import shutil
+import asyncio
 import os
 
-from digichem.exception.base import File_maker_exception
+try:
+    from pyscf.tools import cubegen
+
+except ModuleNotFoundError:
+    # No PySCF.
+    cubegen = None
 
+from digichem.exception.base import File_maker_exception
 from digichem.file import File_converter
 import digichem.file.types as file_types
 import digichem.log
@@ -81,6 +87,7 @@ class Fchk_to_cube(File_converter):
             memory = None,
             cubegen_executable = "cubegen",
             sanitize = False,
+            multithreading = None,
             **kwargs):
         """
         Constructor for Fchk_to_cube objects.
@@ -104,12 +111,18 @@ class Fchk_to_cube(File_converter):
         memory = memory if memory is not None else "3 GB"
         self.memory = Memory(memory)
         # Default to number of CPUs of the system.
-        self.num_cpu = int(num_cpu) if num_cpu is not None else os.cpu_count()
+        # If we've not been asked to run multithreaded, use 1 CPU.
+        if multithreading is None or multithreading == "pool":
+            self.num_cpu = 1
+        
+        else:
+            self.num_cpu = int(num_cpu) if num_cpu is not None else os.cpu_count()
+        
         self.cubegen_executable = expand_path(cubegen_executable)
         self.sanitize = sanitize
         
     @classmethod
-    def from_options(self, output, *, fchk_file = None, cubegen_type = "MO", orbital = "HOMO", options, **kwargs):
+    def from_options(self, output, *, fchk_file = None, cubegen_type = "MO", orbital = "HOMO", num_cpu = None, options, **kwargs):
         """
         Constructor that takes a dictionary of config like options.
         """        
@@ -122,34 +135,115 @@ class Fchk_to_cube(File_converter):
             dont_modify = not options['render']['enable_rendering'],
             cubegen_executable = options['external']['cubegen'],
             sanitize = options['render']['safe_cubes'],
+            num_cpu = num_cpu,
+            multithreading = options['external']['cubegen_parallel'],
             **kwargs
         )
+    
+    def get_parallel(self, name = 'file', cpus = 1):
+        """
+        Generate the file represented by this object in a parallel context.
+
+        get_parallel() will be called by a higher level function as an argument to ThreadPoolExecutor.map() or similar,
+        to generate many files simultaneously. This is useful for slow operations (such as cube generation) that are
+        difficult to parallelise individually, but easy to parallelise across multiple files.
+
+        :param name: The file to generate.
+        :param cpus: The number of CPUs this operation should use, nearly always 1.
+        """
+        # Temporarily set CPUs to 1 (in-case it got changed somewhere else.)
+        old_cpus = self.num_cpu
+        self.num_cpu = cpus
+        try:
+            self.get_file(name = name)
             
-    def make_files(self):
+        finally:
+            self.num_cpu = old_cpus
+
+    @property
+    def signature(self):
         """
-        Make the files referenced by this object.
+        Get the call signature to run cubegen (as can be passed to Popen etc)
         """
-        # The signature we'll use to call cubegen.
-        signature = [
+        return [
             "{}".format(self.cubegen_executable),
-            #"{}".format(self.num_cpu),
-            "0", # Disable CPUs for now, cubegen does not respond well to >1.
+            # Some versions of cubegen respect this num_threads arg, some don't.
+            "{}".format(self.num_cpu),
             "{}={}".format(self.cubegen_type, self.orbital),
             str(self.input_file),
             str(self.output),
             str(self.npts)
         ]
+
+    @property
+    def env(self):
+        """
+        Get the environmental variables require to run cubegen (as can be passed to Popen etc).
+        """
+        return dict(
+            os.environ,
+            GAUSS_MEMDEF = str(self.memory),
+            # Some versions of cubegen only respect this way of changing threads.
+            OMP_NUM_THREADS = str(self.num_cpu)
+        )
+
+    async def make_files_async(self):
+        """
+        Make the files referenced by this object.
+        """        
+        try:
+            cubegen_proc =  await asyncio.create_subprocess_exec(
+                # Unless subprocess.run(), create_subprocess_exec() takes and expanded list as first arg...
+                *self.signature,
+                # Capture both stdout and stderr.
+                # It appears that cubegen writes everything (including error messages) to stdout, but it does return meaningful exit codes.
+                stdout = subprocess.PIPE,
+                stderr = subprocess.STDOUT,
+                env = self.env
+            )
+        except FileNotFoundError:
+            raise File_maker_exception(self, "Could not locate cubegen executable '{}'".format(self.cubegen_executable))
+        
+        stdout = ""
+        stderr = ""
+        # Wait for completion.
+        while cubegen_proc.returncode is None:
+            retval = await cubegen_proc.communicate()
+            stdout += retval[0].decode()
+            stderr += retval[1].decode()
+
+        # If something went wrong, dump output.
+        if cubegen_proc.returncode != 0:
+            # An error occured.
+            # Check if the input file exists, if not this is probably what went wrong.
+            message = "Cubegen did not exit successfully"
+            if not Path(str(self.input_file)).exists():
+                message += " (probably because the input file '{}' could not be found)".format(self.input_file)
+            message += ":\n{}".format(stdout)
+            raise File_maker_exception(self, message)
+        else:
+            # Everything appeared to go ok.
+            # Dump cubegen output if we're in debug.
+            digichem.log.get_logger().debug(stdout)
         
+        if self.sanitize:
+            sanitize_modern_cubes(self.output)
+
+            
+    def make_files(self):
+        """
+        Make the files referenced by this object.
+        """
         try:
             cubegen_proc =  subprocess.run(
-                signature,
+                self.signature,
                 # Capture both stdout and stderr.
                 # It appears that cubegen writes everything (including error messages) to stdout, but it does return meaningful exit codes.
                 stdout = subprocess.PIPE,
                 stderr = subprocess.STDOUT,
                 universal_newlines = True,
-                env = dict(os.environ, GAUSS_MEMDEF = str(self.memory))
-                )
+                env = self.env
+            )
         except FileNotFoundError:
             raise File_maker_exception(self, "Could not locate cubegen executable '{}'".format(self.cubegen_executable))
         
@@ -193,7 +287,7 @@ class Fchk_to_spin_cube(Fchk_to_cube):
         return super().__init__(*args, cubegen_type = "Spin", orbital = spin_density, **kwargs)
     
     @classmethod
-    def from_options(self, output, *, fchk_file = None, spin_density = "SCF", options, **kwargs):
+    def from_options(self, output, *, fchk_file = None, spin_density = "SCF", num_cpu = None, options, **kwargs):
         """
         Constructor that takes a dictionary of config like options.
         """        
@@ -205,6 +299,8 @@ class Fchk_to_spin_cube(Fchk_to_cube):
             dont_modify = not options['render']['enable_rendering'],
             cubegen_executable = options['external']['cubegen'],
             sanitize = options['render']['safe_cubes'],
+            num_cpu = num_cpu,
+            multithreading = options['external']['cubegen_parallel'],
             **kwargs
         )
 
@@ -231,7 +327,7 @@ class Fchk_to_density_cube(Fchk_to_cube):
         self.type = density_type
     
     @classmethod
-    def from_options(self, output, *, fchk_file = None, density_type = "SCF", options, **kwargs):
+    def from_options(self, output, *, fchk_file = None, density_type = "SCF", num_cpu = None, options, **kwargs):
         """
         Constructor that takes a dictionary of config like options.
         """        
@@ -243,6 +339,8 @@ class Fchk_to_density_cube(Fchk_to_cube):
             dont_modify = not options['render']['enable_rendering'],
             cubegen_executable = options['external']['cubegen'],
             sanitize = options['render']['safe_cubes'],
+            num_cpu = num_cpu,
+            multithreading = options['external']['cubegen_parallel'],
             **kwargs
         )
 
@@ -268,7 +366,7 @@ class Fchk_to_nto_cube(Fchk_to_cube):
         super().__init__(*args, cubegen_type = "MO", orbital = orbital, **kwargs)
     
     @classmethod
-    def from_options(self, output, *, fchk_file = None, orbital = "HOMO", options, **kwargs):
+    def from_options(self, output, *, fchk_file = None, orbital = "HOMO", num_cpu = None, options, **kwargs):
         """
         Constructor that takes a dictionary of config like options.
         """        
@@ -280,5 +378,76 @@ class Fchk_to_nto_cube(Fchk_to_cube):
             dont_modify = not options['render']['enable_rendering'],
             cubegen_executable = options['external']['cubegen'],
             sanitize = options['render']['safe_cubes'],
+            num_cpu = num_cpu,
+            multithreading = options['external']['cubegen_parallel'],
             **kwargs
         )
+
+class PySCF_to_cube(File_maker):
+    """
+    Generate cubes from a completed PySCF calculation result object.
+    """
+
+    def __init__(
+            self,
+            *args,
+            mol,
+            target,
+            target_type = "density",
+            npts = 80,
+            cube_file = None,
+            sanitize = False,
+            **kwargs):
+        """
+        Constructor for Fchk_to_cube objects.
+        
+        See Image_maker for a full signature.
+        
+        :param output: The filename/path to the cube file (this path doesn't need to point to a real file yet; we will use this path to write to).
+        :param npts: The number of points per side of the cube.
+        :param cube_file: An optional file path to an existing cube file to use. If this is given (and points to an actual file), then a new cube will not be made and this file will be used instead.
+        :param sanitize: Whether to modify the cube file to make it compatible with older software.
+        """
+        super().__init__(*args, existing_file = cube_file, **kwargs)
+        self.npts = npts
+        self.sanitize = sanitize
+        self.target_type = target_type
+        self.target = target
+        self.mol = mol
+        # TODO: Add some intelligence to this...
+        self.type = "SCF"
+        
+    @classmethod
+    def from_options(self, output, *, options, **kwargs):
+        """
+        Constructor that takes a dictionary of config like options.
+        """        
+        return self(
+            output,
+            npts = options['render']['orbital']['cube_grid_size'].translate("points"),
+            dont_modify = not options['render']['enable_rendering'],
+            sanitize = options['render']['safe_cubes'],
+            **kwargs
+        )
+    
+    def check_can_make(self):
+        super().check_can_make()
+
+        if cubegen is None:
+            raise File_maker_exception(self, "PySCF is not available")
+    
+    def make_files(self):
+        """
+        Make the files referenced by this object.
+        """
+        if self.target_type == "density":
+            cubegen.density(self.mol, self.output, self.target.make_rdm1(), nx=self.npts, ny=self.npts, nz=self.npts)
+
+        elif self.target_type == "orbital":
+            cubegen.orbital(self.mol, self.output, self.target, nx=self.npts, ny=self.npts, nz=self.npts)
+        
+        else:
+            raise ValueError("Unrecognised 'target_type': {}".format(self.target_type))
+        
+        if self.sanitize:
+            sanitize_modern_cubes(self.output)

digichem/file/types.py

@@ -74,6 +74,7 @@ gaussian_cube_file = File_type("cube", "gaussian", [".cub", ".cube"])
 
 orca_gbw_file = File_type("gbw", "orca", [".gbw"])
 orca_density_file = File_type("density", "orca", [".densities"])
+orca_density_info_file = File_type("density-info", "orca", [".densitiesinfo"])
 
 # A list of all our known types.
 known_types = [log_file, gaussian_chk_file, gaussian_fchk_file, gaussian_rwf_file, gaussian_cube_file, orca_gbw_file]

digichem/image/render.py

@@ -10,12 +10,17 @@ import subprocess
 import yaml
 from PIL import Image
 import math
+import numpy
+import warnings
+import json
 
+import digichem.log
 from digichem.exception.base import File_maker_exception
 from digichem.file.base import File_converter
 from digichem.image.base import Cropable_mixin
 from digichem.datas import get_resource
 
+
 class Render_maker(File_converter, Cropable_mixin):
     """
     ABC for classes that make 3D renders from cube files.
@@ -35,6 +40,7 @@ class Render_maker(File_converter, Cropable_mixin):
             resolution = 1024,
             also_make_png = True,
             isovalue = 0.2,
+            num_cpu = 1,
             **kwargs):
         """
         Constructor for Image_maker objects.
@@ -46,6 +52,7 @@ class Render_maker(File_converter, Cropable_mixin):
         :param resolution: The max width or height of the rendered images in pixels.
         :param also_make_png: If True, additional images will be rendered in PNG format. This option is useful to generate higher quality images alongside more portable formats.
         :param isovalue: The isovalue to use for rendering isosurfaces. Has no effect when rendering only atoms.
+        :param num_cpu: The number of CPUs for multithreading.
         :param blender_executable:
         """
         super().__init__(*args, input_file = cube_file, **kwargs)
@@ -61,6 +68,7 @@ class Render_maker(File_converter, Cropable_mixin):
         self.target_resolution = resolution
         self.also_make_png = also_make_png
         self.isovalue = isovalue
+        self.num_cpu = num_cpu
         
         # TODO: These.
         self.primary_colour = "red"
@@ -132,11 +140,13 @@ class Batoms_renderer(Render_maker):
             rotations = None,
             auto_crop = True,
             resolution = 1024,
-            render_samples = 256,
+            render_samples = 32,
+            stack = 3,
             also_make_png = True,
             isovalue = 0.02,
             blender_executable = None,
             cpus = 1,
+            num_cpu = 1,
             perspective = "perspective",
             logging = False,
             **kwargs):
@@ -149,12 +159,20 @@ class Batoms_renderer(Render_maker):
         :param auto_crop: If False, images will not have excess white space cropped.
         :param resolution: The max width or height of the rendered images in pixels.
         :param render_samples: The number of render samples, more results in longer render times but higher quality image.
+        :param stack: The number of copies of the image to composite together to avoid transparency artifacts.
         :param also_make_png: If True, additional images will be rendered in PNG format. This option is useful to generate higher quality images alongside more portable formats.
         :param isovalue: The isovalue to use for rendering isosurfaces. Has no effect when rendering only atoms.
         :param blender_executable: Bath to the blender executable (can be None to use a default).
-        :param cpus: Number of parallel threads to render with.
+        :param cpus: DEPREACTED: Number of parallel threads to render with (use num_cpu instead)
+        :param num_cpu: Number of parallel threads to render with.
         :param perspective: Perspective mode (orthographic or perspective)
         """
+        if cpus != 1:
+            warnings.warn("cpus is deprecated, use num_cpu instead", DeprecationWarning)
+        
+        if num_cpu == 1 and cpus != 1:
+            num_cpu = cpus
+        
         super().__init__(
             *args,
             cube_file = cube_file,
@@ -163,14 +181,15 @@ class Batoms_renderer(Render_maker):
             resolution = resolution,
             also_make_png = also_make_png,
             isovalue = math.fabs(isovalue),
+            num_cpu = num_cpu,
             **kwargs
         )
         
         # Blender specific options.
         self.render_samples = render_samples
-        self.cpus = cpus
         self.perspective = perspective
-        
+        self.stack = stack
+
         self.logging = logging
         
         # Use explicit blender location if given.
@@ -182,7 +201,7 @@ class Batoms_renderer(Render_maker):
             self.blender_executable = get_resource('data/batoms/blender/blender')
             
     @classmethod
-    def from_options(self, output, *, cube_file = None, rotations = None, cpus = None, options, **kwargs):
+    def from_options(self, output, *, cube_file = None, rotations = None, cpus = None, num_cpu = 1, options, **kwargs):
         """
         Constructor that takes a dictionary of config like options.
         """        
@@ -193,17 +212,20 @@ class Batoms_renderer(Render_maker):
             auto_crop = options['render']['auto_crop'],
             resolution = options['render']['resolution'],
             render_samples = options['render']['batoms']['render_samples'],
+            stack = options['render']['batoms']['stacking'],
             isovalue = options['render'][self.options_name]['isovalue'],
             use_existing = options['render']['use_existing'],
             dont_modify = not options['render']['enable_rendering'],
             blender_executable = options['render']['batoms']['blender'],
+            # Deprecated...
             cpus = cpus if cpus is not None else options['render']['batoms']['cpus'],
+            num_cpu = num_cpu,
             perspective = options['render']['batoms']['perspective'],
             logging = options['logging']['render_logging'],
             **kwargs
         )
         
-    def blender_signature(self, output, resolution, samples, orientation, padding = 1.0):
+    def blender_signature(self, *targets, padding = 1.0):
         """
         The signature passed to subprocess.run used to call Blender. Inheriting classes should write their own implementation.
         """
@@ -217,44 +239,77 @@ class Batoms_renderer(Render_maker):
             "--",
             # Script specific args.
             f"{self.input_file}",
-            f"{output}",
+            # f"{output}",
             # Keywords.
-            "--cpus", f"{self.cpus}",
-            "--orientation", "{}".format(orientation[0]), "{}".format(orientation[1]), "{}".format(orientation[2]),
-            "--resolution", f"{resolution}",
-            "--render-samples", f"{samples}",
+            "--cpus", f"{self.num_cpu}",
+            # "--orientation", "{}".format(orientation[0]), "{}".format(orientation[1]), "{}".format(orientation[2]),
+            # "--resolution", f"{resolution}",
+            # "--render-samples", f"{samples}",
             "--perspective", f"{self.perspective}",
             "--padding", f"{padding}",
             "--rotations",
         ]
+        for orientation, resolution, samples, mini_file_name in targets:
+            args.extend([
+                "--multi",
+                "{}".format(orientation[0]), "{}".format(orientation[1]), "{}".format(orientation[2]),
+                f"{resolution}",
+                f"{samples}",
+                mini_file_name
+            ])
+
         # Add rotations.
         for rotation in self.rotations:
-            args.append(yaml.safe_dump(rotation))
+            args.append(json.dumps(rotation))
         
         return args
     
-    def run_blender(self, output, resolution, samples, orientation):
+    #def run_blender(self, output, resolution, samples, orientation):
+
+    def run_blender(self, *targets):
+        """
+        Render a (number of) images with blender.
+
+        :param samples: How many render samples to use.
+        :param *targets: Images to render, each is a tuple if (orientation, resolution, samples, path).
+        """
         # Render with batoms.
         env = dict(os.environ)
         
         # Disabling the user dir helps prevent conflicting installs of certain packages
         env["PYTHONNOUSERSITE"] = "1"
         #env["PYTHONPATH"] = ":" + env["PYTHONPATH"]
+        blender_process = None
         
         # Run Blender, which renders our image for us.
         try:
-            subprocess.run(
-                self.blender_signature(output, resolution, samples, orientation),
+            blender_process = subprocess.run(
+                self.blender_signature(*targets),
                 stdin = subprocess.DEVNULL,
-                stdout = subprocess.DEVNULL if not self.logging else None,
+                stdout = subprocess.PIPE if not self.logging else None,
                 stderr = subprocess.STDOUT,
                 universal_newlines = True,
                 check = True,
                 env = env,
             )
+            
+            for target in targets:
+                if not target[3].exists():
+                    raise File_maker_exception(self, "Could not find render file '{}'".format(target[3]))
+
         except FileNotFoundError:
             raise File_maker_exception(self, "Could not locate blender executable '{}'".format(self.blender_executable))
         
+        except subprocess.CalledProcessError as e:
+            if not self.logging:
+                digichem.log.get_logger().error("Blender did not exit successfully, dumping output:\n{}".format(e.stdout))
+
+        except Exception:
+            if not self.logging and blender_process is not None:
+                digichem.log.get_logger().error("Blender did not exit successfully, dumping output:\n{}".format(blender_process.stdout))
+            
+            raise
+        
     
     def make_files(self):
         """
@@ -263,23 +318,42 @@ class Batoms_renderer(Render_maker):
         The new image will be written to file.
         """
         # TODO: This mechanism is clunky and inefficient if only one image is needed because its based off the old VMD renderer. With batoms we can do much better.
-        for image_name, orientation in [
-                ('x0y0z0', (0,0,1)),
-                ('x90y0z0', (1,0,0)),
-                ('x0y90z0', (0,1,0)),
-                ('x45y45z45',(1,1,1))
-            ]:
-            image_path = self.file_path[image_name]
-            try:
-                # First we'll render a test image at a lower resolution. We'll then crop it, and use the decrease in final resolution to know how much bigger we need to render in our final image to hit our target resolution.
-                # Unless of course auto_crop is False, in which case we use our target resolution immediately.
-                resolution = self.test_resolution if self.auto_crop else self.target_resolution
-                samples = self.test_samples if self.auto_crop else self.render_samples
-                self.run_blender(image_path.with_suffix(".tmp.png"), resolution, samples, orientation)
-                
-                if self.auto_crop:
-                    # Load the test image and autocrop it.
-                    with Image.open(image_path.with_suffix(".tmp.png"), "r") as test_im:
+        angles = {
+            "x0y0z0": [
+                (0,0,0),
+                self.test_resolution if self.auto_crop else self.target_resolution,
+                self.test_samples if self.auto_crop else self.render_samples,
+                self.file_path['x0y0z0'].with_suffix(".tmp.png")
+            ],
+            "x90y0z0": [
+                (1.5708, 0, 0),
+                self.test_resolution if self.auto_crop else self.target_resolution,
+                self.test_samples if self.auto_crop else self.render_samples,
+                self.file_path['x90y0z0'].with_suffix(".tmp.png")
+            ],
+            "x0y90z0": [
+                (0, 1.5708, 0),
+                self.test_resolution if self.auto_crop else self.target_resolution,
+                self.test_samples if self.auto_crop else self.render_samples,
+                self.file_path['x0y90z0'].with_suffix(".tmp.png")
+            ],
+            "x45y45z45": [
+                (0.785398, 0.785398, 0.785398),
+                self.test_resolution if self.auto_crop else self.target_resolution,
+                self.test_samples if self.auto_crop else self.render_samples,
+                self.file_path['x45y45z45'].with_suffix(".tmp.png")
+            ],
+        }
+        
+        try:
+            # First we'll render a test image at a lower resolution. We'll then crop it, and use the decrease in final resolution to know how much bigger we need to render in our final image to hit our target resolution.
+            # Unless of course auto_crop is False, in which case we use our target resolution immediately.
+            self.run_blender(*list(angles.values()))
+            
+            if self.auto_crop:
+                # Load the test image and autocrop it.
+                for angle, target in angles.items():
+                    with Image.open(target[3], "r") as test_im:
                         small_test_im = self.auto_crop_image(test_im)
                         
                     # Get the cropped size. We're interested in the largest dimension, as this is what we'll output as.
@@ -287,15 +361,28 @@ class Batoms_renderer(Render_maker):
                     
                     # From this we can work out the ratio between our true resolution and the resolution we've been asked for.
                     resolution_ratio = cropped_resolution / self.test_resolution
+
+                    # Update the target properties.
+                    angles[angle] = [
+                        # Orientation is the same.
+                        angles[angle][0],
+                        # New resolution.
+                        int(self.target_resolution / resolution_ratio),
+                        # New samples.
+                        self.render_samples,
+                        # New filename,
+                        angles[angle][3]
+                    ]
                     
-                    self.run_blender(image_path.with_suffix(".tmp.png"), int(self.target_resolution / resolution_ratio), self.render_samples, orientation)
-                
-            except Exception:
-                raise File_maker_exception(self, "Error in blender rendering")
+                self.run_blender(*list(angles.values()))
             
-            # Convert to a better set of formats.
-            # Open the file we just rendered.
-            with Image.open(image_path.with_suffix(".tmp.png"), "r") as im:
+        except Exception:
+            raise File_maker_exception(self, "Error in blender rendering")
+        
+        # Convert to a better set of formats.
+        # Open the files we just rendered.
+        for angle, target in angles.items():
+            with Image.open(target[3], "r") as im:
                 
                 # If we've been asked to autocrop, do so.
                 if self.auto_crop:
@@ -305,10 +392,21 @@ class Batoms_renderer(Render_maker):
                         raise File_maker_exception(self, "Error in post-rendering auto-crop")
                 else:
                     cropped_image = im
+
+                # Transparency stacking.
+                # This 'hack' takes several copies of the same transparent image and layers them atop each other.
+                # This avoids problems with isosurfaces being too transparent with respect to the background (and
+                # thus loosing definition).
+                stacked = cropped_image.copy()
+
+                for _ in range(self.stack):
+                    stacked.alpha_composite(cropped_image)
+
+                cropped_image = stacked
                 
                 # Save as a higher quality png if we've been asked to.
                 if self.also_make_png:
-                    cropped_image.save(self.file_path[image_name + "_big"])
+                    cropped_image.save(self.file_path[angle + "_big"])
                     
                 # Remove transparency, which isn't supported by JPEG (which is essentially the only format we write here).
                 # TODO: Check if the output format can support transparency or not.
@@ -317,10 +415,10 @@ class Batoms_renderer(Render_maker):
                 cropped_image = new_image.convert('RGB')
                 
                 # Now save in our main output format.
-                cropped_image.save(image_path)
+                cropped_image.save(self.file_path[angle])
                 
                 # And delete the old .png.
-                os.remove(image_path.with_suffix(".tmp.png"))
+                os.remove(target[3])
 
 
 class Structure_image_maker(Batoms_renderer):
@@ -540,8 +638,9 @@ class Dipole_image_maker(Structure_image_maker):
         sig = super().blender_signature(output, resolution, samples, orientation)
         sig.append("--dipoles")
         for dipole in self.get_dipoles():
-            sig.append(yaml.safe_dump(dipole))
-        sig.extend(["--alpha", "0.5"])
+            #sig.append(yaml.safe_dump(dipole))
+            sig.append(json.dumps(dipole))
+        sig.extend(["--alpha", "0.75"])
         return sig