agox 2.2.2__tar.gz → 3.1.1__tar.gz

agox-3.1.1/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include agox/test *
+include agox/models/datasets/*.traj
+global-include *.pyx
+

agox-3.1.1/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: agox
+Version: 3.1.1
+Summary: Atomistic Global Optimziation X is a framework for structure optimization in materials science.
+Home-page: https://agox.gitlab.io/agox/
+Author: Mads-Peter V. Christiansen, Nikolaj Ronne, Bjork Hammer
+Author-email: hammer@phys.au.dk
+License: GNU GPLv3
+Project-URL: Source Code, https://gitlab.com/agox/agox
+Project-URL: Documentation, https://agox.gitlab.io/agox
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+Provides-Extra: full
+Provides-Extra: extras
+License-File: LICENSE.txt
+
+# Atomistic Global Optimization X (AGOX)
+
+AGOX is a package for global optimization of atomic system using e.g. the energy 
+calculated from density functional theory as the objective function. AGOX interfaces 
+with the Atomistic Simulation Environment (ASE) and as such supports any of 
+calculators in ASE as objectives for optimization. 
+
+AGOX is built to be flexible, consisting of modules that can be put together to 
+create an optimization algorithm, from simple random searches to Bayesian searches 
+guided by a surrogate model and many more. 
+
+Check out the documentation at 
+
+https://agox.gitlab.io/agox/
+
+# Contributions & Issues 
+
+Feel free to make a fork and submit a merge request! 
+
+If you have an issue or a question please post it on the issue board! 
+
+# Authors 
+
+The main AGOX framework has been written by 
+* Mads-Peter Verner Christiansen
+* Nikolaj Rønne
+* Bjørk Hammer
+
+with inspiration and help from current and previous members of the Hammer group at Aarhus University, Denmark.
+Parts of the code have been contributed by
+
+* Andreas Slavensky (Complementary Energy Generator)
+
+# License
+
+AGOX is released under the GPLv3 license. 
+
+

agox-3.1.1/README.md

@@ -0,0 +1,38 @@
+# Atomistic Global Optimization X (AGOX)
+
+AGOX is a package for global optimization of atomic system using e.g. the energy 
+calculated from density functional theory as the objective function. AGOX interfaces 
+with the Atomistic Simulation Environment (ASE) and as such supports any of 
+calculators in ASE as objectives for optimization. 
+
+AGOX is built to be flexible, consisting of modules that can be put together to 
+create an optimization algorithm, from simple random searches to Bayesian searches 
+guided by a surrogate model and many more. 
+
+Check out the documentation at 
+
+https://agox.gitlab.io/agox/
+
+# Contributions & Issues 
+
+Feel free to make a fork and submit a merge request! 
+
+If you have an issue or a question please post it on the issue board! 
+
+# Authors 
+
+The main AGOX framework has been written by 
+* Mads-Peter Verner Christiansen
+* Nikolaj Rønne
+* Bjørk Hammer
+
+with inspiration and help from current and previous members of the Hammer group at Aarhus University, Denmark.
+Parts of the code have been contributed by
+
+* Andreas Slavensky (Complementary Energy Generator)
+
+# License
+
+AGOX is released under the GPLv3 license. 
+
+

{agox-2.2.2 → agox-3.1.1}/agox/__version__.py

@@ -1,2 +1,2 @@
-__version_info__ = (2, 2, 2)
+__version_info__ = (3, 1, 1)
 __version__ = '{}.{}.{}'.format(*__version_info__)

{agox-2.2.2 → agox-3.1.1}/agox/acquisitors/ABC_acquisitor.py

@@ -144,23 +144,24 @@ class AcquisitonCalculatorBaseClass(Calculator, Module):
 
     name = 'AcqusitionCalculator'
 
-    def __init__(self, model_calculator, **kwargs):
-        super().__init__(**kwargs)
-        self.model_calculator = model_calculator
+    def __init__(self, model, **kwargs):
+        Calculator.__init__(self, **kwargs)
+        Module.__init__(self)
+        self.model = model
     
     @property
     def verbose(self):
-        return self.model_calculator.verbose
+        return self.model.verbose
 
     def get_model_parameters(self):
-        parameters = self.model_calculator.get_model_parameters()
+        parameters = self.model.get_model_parameters()
         return parameters
 
     def set_model_parameters(self, parameters):
-        self.model_calculator.set_model_parameters(parameters)
+        self.model.set_model_parameters(parameters)
 
     def set_verbosity(self, verbose):
-        self.model_calculator.set_verbosity(verbose)
+        self.model.set_verbosity(verbose)
 
     def get_iteration_number(self):
         if hasattr(self, 'get_iteration_counter'):
@@ -170,4 +171,4 @@ class AcquisitonCalculatorBaseClass(Calculator, Module):
 
     @property
     def ready_state(self):
-        return self.model_calculator.ready_state
+        return self.model.ready_state

{agox-2.2.2 → agox-3.1.1}/agox/acquisitors/LCB.py

@@ -6,19 +6,17 @@ class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
 
     name = 'LCBAcquisitor'
 
-    def __init__(self, model_calculator, kappa=1, **kwargs):
+    def __init__(self, model, kappa=1, **kwargs):
         super().__init__(**kwargs)
         self.kappa = kappa
-        self.model_calculator = model_calculator
+        self.model = model
 
     def calculate_acquisition_function(self, candidates):
         fitness = np.zeros(len(candidates))
         
         # Attach calculator and get model_energy
         for i, candidate in enumerate(candidates):
-            candidate.set_calculator(self.model_calculator)
-            E = candidate.get_potential_energy()
-            sigma = candidate.get_uncertainty()
+            E, sigma = self.model.predict_energy_and_uncertainty(candidate)
             fitness[i] = self.acquisition_function(E, sigma)
 
             # For printing:
@@ -28,7 +26,7 @@ class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
         return fitness
 
     def print_information(self, candidates, acquisition_values):
-        if self.model_calculator.ready_state:
+        if self.model.ready_state:
             for i, candidate in enumerate(candidates):
                 fitness = acquisition_values[i]
                 Emodel = candidate.get_meta_information('model_energy')
@@ -36,7 +34,7 @@ class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
                 self.writer('Candidate: E={:8.3f}, s={:8.3f}, F={:8.3f}'.format(Emodel, sigma, fitness))
 
     def get_acquisition_calculator(self):
-        return LowerConfidenceBoundCalculator(self.model_calculator, self.acquisition_function, self.acquisition_force)
+        return LowerConfidenceBoundCalculator(self.model, self.acquisition_function, self.acquisition_force)
 
     def acquisition_function(self, E, sigma):
         return E - self.kappa * sigma
@@ -45,14 +43,14 @@ class LowerConfidenceBoundAcquisitor(AcquisitorBaseClass):
         return F - self.kappa*sigma_force
 
     def do_check(self, **kwargs):
-        return self.model_calculator.ready_state
+        return self.model.ready_state
 
 class LowerConfidenceBoundCalculator(AcquisitonCalculatorBaseClass):
 
     implemented_properties = ['energy', 'forces']
 
-    def __init__(self, model_calculator, acquisition_function, acquisition_force, **kwargs):
-        super().__init__(model_calculator, **kwargs)
+    def __init__(self, model, acquisition_function, acquisition_force, **kwargs):
+        super().__init__(model, **kwargs)
         self.acquisition_function = acquisition_function
         self.acquisition_force = acquisition_force
 
@@ -61,13 +59,14 @@ class LowerConfidenceBoundCalculator(AcquisitonCalculatorBaseClass):
                   system_changes=all_changes):
         super().calculate(atoms, properties, system_changes)
 
-        if 'forces' in properties:
-            E, sigma = self.model_calculator.predict_energy(atoms, return_uncertainty=True)
-            F, sigma_force = self.model_calculator.predict_forces(atoms, return_uncertainty=True, acquisition_function=self.acquisition_function)
-            self.results['forces'] = self.acquisition_force(E, F, sigma, sigma_force)
-        else:
-            E, sigma = self.model_calculator.predict_energy(atoms, return_uncertainty=True)
-            
+        model_data = self.model.converter(atoms)
+        
+        E = self.model.predict_energy(atoms, **model_data)
+        sigma = self.model.predict_uncertainty(atoms, **model_data)
+        F = self.model.predict_forces(atoms, **model_data)
+        sigma_force = self.model.predict_uncertainty_forces(atoms, **model_data)
+        
+        self.results['forces'] = self.acquisition_force(E, F, sigma, sigma_force)
         self.results['energy'] = self.acquisition_function(E, sigma)
 
 

agox-3.1.1/agox/acquisitors/__init__.py

@@ -0,0 +1,25 @@
+"""
+Acquisitors are used to select the next candidate to evaluate among a number of
+candidates, usually by sorting according to some metric. 
+The concept of acquisitors comes from Bayesian search algorithms. 
+
+A common acquisitor is the Lower Confidence Bound (LCB) acquisitor, which 
+selects according to the expression
+
+.. math::
+    LCB(x) = E(x) - \kappa \sigma(x).
+
+Where E(x) is a prediction of the objective function at x, and :math:`\sigma(x)`
+is the uncertainty of the prediction. :math:`\kappa` is a parameter that 
+controls the trade-off between exploration and exploitation. 
+This lets an algorithm choose which candidates to evaluate, but 
+does require the generation of multiple candidates to choose from.
+"""
+
+
+
+
+from .ABC_acquisitor import AcquisitorBaseClass, AcquisitonCalculatorBaseClass
+from .LCB import LowerConfidenceBoundAcquisitor, LowerConfidenceBoundCalculator
+from .LCB_power import PowerLowerConfidenceBoundAcquisitor
+

{agox-2.2.2 → agox-3.1.1}/agox/candidates/ABC_candidate.py

@@ -2,14 +2,16 @@ from abc import ABC, abstractmethod
 from ase import Atoms
 import numpy as np
 
+import functools
 from copy import deepcopy
 from ase.calculators.singlepoint import SinglePointCalculator
 
 from agox.module import Module
-
+from agox.utils.cache import Cache
+    
 class CandidateBaseClass(ABC, Atoms, Module):
 
-    def __init__(self, template=None, template_indices=None, **kwargs):
+    def __init__(self, template=None, template_indices=None, use_cache=True, **kwargs):
         """
 
         Initialization method of the Candidate.
@@ -26,8 +28,11 @@ class CandidateBaseClass(ABC, Atoms, Module):
             cell, positions and numbers of ALL atoms - including template atoms. 
         """
         Atoms.__init__(self, **kwargs) # This means all Atoms-related stuff gets set. 
-        Module.__init__(self)
+        Module.__init__(self, use_cache=use_cache)
         self.meta_information = dict()
+        
+        self.use_cache = use_cache
+        self._cache = Cache()
 
         # Template stuff:        
         if template_indices is not None:
@@ -50,6 +55,54 @@ class CandidateBaseClass(ABC, Atoms, Module):
         # if len(template) > 0:            
         #     assert (self.positions[:len(template)] == template.positions).all(), 'Template and positions do not match'
 
+
+    @classmethod
+    def cache(cls, key):
+        def decorator(func):
+            @functools.wraps(func)
+            def wrapper(self, atoms, *args, **kwargs):
+                if not self.use_cache:
+                    return func(self, atoms, *args, **kwargs)
+                
+                full_key = self.cache_key + '/' + key
+                if isinstance(atoms, CandidateBaseClass):
+                    value = atoms.get_from_cache(full_key)
+                    if value is None:
+                        value = func(self, atoms, *args, **kwargs)
+                        if atoms.use_cache:
+                            atoms.set_to_cache(full_key, value)
+                else:
+                    value = func(self, atoms, *args, **kwargs)
+                    
+                return value
+            return wrapper
+        return decorator
+        
+    def get_from_cache(self, key):
+        if not self.use_cache:
+            return None
+        
+        identifier, value = self._cache.get(key, (None, None))
+        if identifier is not None:
+            if self.compare_identity(identifier):
+                return value
+        else:
+            return None
+
+    def set_to_cache(self, key, value):
+        self._cache.put(key, (self.get_identifier(), value))
+
+    def compare_identity(self, identifier):
+        for a,b in zip(identifier, self.get_identifier()):
+            equal = (a == b).all()
+            if not equal:
+                return equal
+        return equal
+
+    def get_identifier(self):
+        return (self.get_atomic_numbers(), self.get_positions(), self.get_cell())
+
+
     def add_meta_information(self, name, value):
         """
         Adds an entry to the meta_information dictionary
@@ -265,3 +318,31 @@ class CandidateBaseClass(ABC, Atoms, Module):
             return np.mean(self.positions, axis=0).reshape(1, 3)
         else:
             return np.mean(self.positions[self.get_optimize_indices()], axis=0).reshape(1, 3)
+
+    def set_calculator(self, calc):
+        """
+        "Old" ASE syntax for setting calculator, avoids the annoying warning and 
+        uses this better syntax.
+
+        Parameters
+        -----------
+        calc: calculator
+            Calculator to set.
+        """
+        self.calc = calc
+
+def disable_cache(candidate):
+    # Can be either Candidate or Atoms.
+    if isinstance(candidate, CandidateBaseClass):
+        candidate.use_cache = False
+
+def switch_cache(candidate, state):
+    prev_state = False
+    if isinstance(candidate, CandidateBaseClass):
+        prev_state = candidate.use_cache
+        candidate.use_cache = state
+    return prev_state
+
+
+
+

agox-3.1.1/agox/candidates/__init__.py

@@ -0,0 +1,8 @@
+"""
+A candidate is the basic piece of data being moved around in the algorithm. 
+Generators create candidates, and evaluators evaluate the objective function 
+at the coordinates described by the candidate. 
+"""
+
+from .ABC_candidate import CandidateBaseClass
+from .standard import StandardCandidate

{agox-2.2.2 → agox-3.1.1}/agox/collectors/ABC_collector.py

@@ -1,6 +1,6 @@
 import numpy as np
 from abc import ABC, abstractmethod
-from agox.module import Module
+from agox.module import Module, register_modules
 from agox.observer import Observer
 from agox.writer import Writer, agox_writer
 
@@ -47,6 +47,9 @@ class CollectorBaseClass(ABC, Observer, Writer):
                 if observer_method.method_name == 'generate':
                     generator.remove_observer_method(observer_method)
 
+        # Register the generators as attributes of the collector, so that they can be tracked.
+        register_modules(self, self.generators, 'generator')
+
     @abstractmethod
     def make_candidates(self):
         """

agox-3.1.1/agox/collectors/__init__.py

@@ -0,0 +1,7 @@
+"""
+Collectors are used to collect multiple candidates generated by generators. 
+This is a task that can be parallelized over the number of generated candidates, 
+and this is done using parallelization from Ray. 
+"""
+from agox.collectors.standard import StandardCollector
+from agox.collectors.ray_collector import ParallelCollector

agox-3.1.1/agox/databases/__init__.py

@@ -0,0 +1,12 @@
+"""
+A database records the candidates that have been evaluated during a search. 
+
+Further, because some things need to be trained, e.g. a ML potential model, 
+databases can be used to store the training data. The databases all implement
+a similar observer-pattern as the main AGOX class, so models can be trained 
+whenever data is added to the database.
+"""
+
+from .ABC_database import DatabaseBaseClass
+from agox.databases.database import Database 
+from agox.databases.database_concurrent import ConcurrentDatabase

{agox-2.2.2 → agox-3.1.1}/agox/databases/database.py

@@ -28,7 +28,8 @@ class Database(DatabaseBaseClass):
     forces blob, 
     pbc blob,
     template_indices blob,
-    iteration int
+    iteration int,
+    cache_key text
     )""", 
 
     """CREATE TABLE text_key_values (
@@ -66,12 +67,12 @@ class Database(DatabaseBaseClass):
     
     # Pack: Positions, energy, type, cell, forces, pbc, template_indices, iteration
     # Unpack: ID, time, -//-
-    pack_functions = [blob, nothing, blob, blob, blob, blob, blob, nothing]
-    unpack_functions = [nothing, nothing, deblob, nothing, deblob, deblob, deblob, deblob, deblob, nothing]
+    pack_functions = [blob, nothing, blob, blob, blob, blob, blob, nothing, nothing]
+    unpack_functions = [nothing, nothing, deblob, nothing, deblob, deblob, deblob, deblob, deblob, nothing, nothing]
 
     name = 'Database'
 
-    def __init__(self, filename='db.db', initialize=False, verbose=False, write_frequency=1, call_initialize=True, 
+    def __init__(self, filename='db.db', initialize=False, verbose=False, write_interval=1, call_initialize=True, 
                 store_meta_information=True, **kwargs):
         super().__init__(**kwargs)
 
@@ -80,10 +81,10 @@ class Database(DatabaseBaseClass):
         if initialize and os.path.exists(filename):
             os.remove(filename)
         self.con = sqlite3.connect(filename, timeout=600)
-        self.write_frequency = write_frequency
+        self.write_interval = write_interval
 
         # Important that this matches the init_statements list. 
-        self.storage_keys = ['positions', 'energy', 'type', 'cell', 'forces', 'pbc', 'template_indices', 'iteration']
+        self.storage_keys = ['positions', 'energy', 'type', 'cell', 'forces', 'pbc', 'template_indices', 'iteration', 'cache_key']
 
         # Memory-based stuff:        
         self.candidate_instanstiator = StandardCandidate
@@ -177,6 +178,7 @@ class Database(DatabaseBaseClass):
             self.storage_dict['pbc'].append(np.array(candidate.pbc.astype(int), dtype=np.float64))
             self.storage_dict['template_indices'].append(np.array(candidate.get_template_indices(), dtype=np.float64))
             self.storage_dict['iteration'].append(self.get_iteration_counter())
+            self.storage_dict['cache_key'].append(candidate.cache_key)
             self.number_of_rows += 1
 
             if self.store_meta_information:
@@ -203,7 +205,7 @@ class Database(DatabaseBaseClass):
         if not already_stored: 
             self.store_information(candidate)
 
-        if self.number_of_rows == self.write_frequency or force_write:
+        if self.number_of_rows == self.write_interval or force_write:
             try:
                 for row_index in range(self.number_of_rows):
                     cur = self.con.cursor()
@@ -264,6 +266,7 @@ class Database(DatabaseBaseClass):
         cell = structure['cell']
         pbc = structure.get('pbc', None)
         template_indices = structure.get('template_indices', None)
+        cache_key = structure.get('cache_key', None)
         
         if hasattr(self, 'template') and template_indices is None:
             template = self.template
@@ -271,6 +274,7 @@ class Database(DatabaseBaseClass):
             template = None            
 
         candidate = self.candidate_instanstiator(symbols = num, positions = pos, cell = cell, pbc=pbc, template=template, template_indices=template_indices)        
+        candidate.cache_key = cache_key
         calc = SinglePointCalculator(candidate, energy=e, forces=f)
         candidate.set_calculator(calc)
 

{agox-2.2.2 → agox-3.1.1}/agox/environments/ABC_environment.py

@@ -7,6 +7,9 @@ from ase.constraints import FixAtoms
 from agox.module import Module
 
 class EnvironmentBaseClass(ABC, Module):
+
+    name = 'Environment'
+
     """
     The Environment contains important properties about the envrionment (or conditions) of the global atomisation problem. 
     These are at least: 

agox-3.1.1/agox/environments/__init__.py

@@ -0,0 +1,12 @@
+"""
+An environment describes the search problem
+- How many and which types of atoms will the search place? 
+- What is the computational cell? 
+- Is there a fixed template, e.g. a surface to be decorated by the search? 
+- Is the search constrained to a certain region of space?
+
+These are settings that are not part of the search algorithm itself, but 
+rather describe the problem that the search is trying to solve.
+"""
+from .ABC_environment import EnvironmentBaseClass
+from agox.environments.environment import Environment

{agox-2.2.2 → agox-3.1.1}/agox/environments/environment.py

@@ -1,11 +1,15 @@
 import numpy as np
 from agox.environments.ABC_environment import EnvironmentBaseClass
+from ase import Atoms
 from ase.atoms import symbols2numbers
 from ase.symbols import Symbols
 
+
 class Environment(EnvironmentBaseClass):
 
-    def __init__(self, template, numbers=None, symbols=None, **kwargs):
+    def __init__(self, template, numbers=None, symbols=None, print_report=True,
+                 **kwargs):
+        
         super().__init__(**kwargs)
 
         # Both numbers and symbols cannot be specified:
@@ -17,8 +21,9 @@ class Environment(EnvironmentBaseClass):
             self._numbers = symbols2numbers(symbols)
         
         self._template = template
-
-        self.environment_report()
+        
+        if print_report:
+            self.environment_report()
 
 
     def get_template(self):
@@ -52,6 +57,14 @@ class Environment(EnvironmentBaseClass):
     def get_all_species(self):
         return list(Symbols(self.get_all_types()).species())
 
+    def get_species(self):
+        return list(np.unique(self.get_all_species()))
+
+    def get_atoms(self):
+        atoms = self.get_template()
+        atoms += Atoms(self.get_numbers())
+        return atoms
+    
     def match(self, candidate):
         cand_numbers = candidate.get_atomic_numbers()
         env_numbers = self.get_all_numbers()
@@ -100,4 +113,4 @@ class Environment(EnvironmentBaseClass):
                 pretty_print(tab + '{:4.2f} {:4.2f} {:4.2f}'.format(*cell_vec))
 
         header_print('')
-    
+    

agox-3.1.1/agox/evaluators/__init__.py

@@ -0,0 +1,11 @@
+"""
+Evaluators are responsible for evaluating the objective function of a candidate.
+The main two flavours of evaluators are single-point and local optimization.
+
+Single-point evaluators evaluate the objective function at a single point, 
+whereas local optimization evaluators perform a local optimization starting from 
+the candidate's coordinates.
+"""
+from .single_point import SinglePointEvaluator
+from .local_optimization import LocalOptimizationEvaluator
+from .rattle import RattleEvaluator

{agox-2.2.2 → agox-3.1.1}/agox/generators/ABC_generator.py

@@ -142,11 +142,26 @@ class GeneratorBaseClass(ABC, Observer, Writer, Confinement):
         state.add_to_cache(self, self.set_key, candidates, mode='a')
         
     def plot_confinement(self, environment):
-        from agox.helpers.plot_confinement import plot_confinement
+        if not self.confined:
+            return
+
         import matplotlib.pyplot as plt
-        from agox.utils.matplotlib_utils import use_agox_mpl_backend; use_agox_mpl_backend()
+        from agox.utils.matplotlib_utils import use_agox_mpl_backend
+        from agox.utils.plot import plot_atoms, plot_cell
+
+        use_agox_mpl_backend()
+
+        atoms = environment.get_template()
+
+        fig, axs = plt.subplots(1, 3, figsize=(15, 5))
+
+        for ax, plane in zip(axs, ['xy', 'xz', 'yz']):
+            plot_atoms(ax, atoms, plane=plane)
+            plot_cell(ax, atoms.cell, plane=plane,
+                      collection_kwargs=dict(edgecolors='black', linestyles='dotted'))
+            plot_cell(ax, self.confinement_cell, plane=plane, offset=self.confinement_corner,
+                      collection_kwargs=dict(edgecolors='red', linestyles='dashed'))
+            ax.autoscale_view()
 
-        if self.confined:
-            fig, ax = plot_confinement(environment.get_template(), self.confinement_cell, self.confinement_corner)
-            plt.savefig(f'confinement_plot_{self.name}.png')
-            plt.close()
+        fig.savefig(f'confinement_plot_{self.name}.png')
+        plt.close()

agox-3.1.1/agox/generators/__init__.py

@@ -0,0 +1,24 @@
+"""
+Generators are are responsible for generating new configurations. 
+Typically there are two types of generators: 
+- Those that can generate a candidate by modifying one or more configurations. 
+- Those that can generate a candidate without any input configurations.
+
+The first catagory of generators require a Sampler to sample the configurations
+that it uses as a basis for generating a new candidate. The second category of
+generators do not require a sampler.    
+
+The generators have to generate a candidate that follows the rules set by the
+environment, that is
+- The correct stoichoimetry
+- Inside the confinement box. 
+"""
+from agox.generators.random import RandomGenerator
+from agox.generators.rattle import RattleGenerator
+from agox.generators.replace import ReplaceGenerator
+from agox.generators.reuse import ReuseGenerator
+from agox.generators.permutation import PermutationGenerator
+from agox.generators.steepest_descent import SteepestDescentGenerator
+from agox.generators.cog import CenterOfGeometryGenerator
+from agox.generators.sampling import SamplingGenerator
+from agox.generators.ce_generator import ComplementaryEnergyGenerator