impedance-extend 1.0.0__tar.gz

impedance_extend-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 impedance.py developers.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

impedance_extend-1.0.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: impedance_extend
+Version: 1.0.0
+Summary: A package for analyzing electrochemical impedance data (with support for GA, PSO and least_squares or combinations thereof)
+Home-page: https://impedancepy.readthedocs.io/en/latest/
+Author: impedance_extend.py developers
+Author-email: prof.krishna.v@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: ~=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: altair>=3.0
+Requires-Dist: matplotlib>=3.5
+Requires-Dist: numpy>=1.22.4
+Requires-Dist: scipy>=1.0
+Requires-Dist: pandas
+Requires-Dist: pygad>=3.6.0
+Requires-Dist: pyswarms>=1.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[![DOI]]  ![GitHub release](https://img.shields.io/github/release/k-vijayaraghavan/impedance_extend.py)
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/impedance_extend?style=flat-square)  [![All Contributors](https://img.shields.io/badge/all_contributors-1-orange.svg?style=flat-square)](#contributors)
+
+[![Build Status](https://github.com/k-vijayaraghavan/impedance_extend.py/actions/workflows/ci.yml/badge.svg)](https://github.com/k-vijayaraghavan/impedance_extend.py/actions)  [![Documentation Status](https://readthedocs.org/projects/impedancepy/badge/?version=latest&kill_cache=1)](https://impedancepy.readthedocs.io/en/latest/?badge=latest) [![Coverage Status](https://coveralls.io/repos/github/ECSHackWeek/impedance.py/badge.svg?branch=master&kill_cache=1)](https://coveralls.io/github/ECSHackWeek/impedance.py?branch=master)
+
+impedance_extend.py
+------------
+
+`impedance_extend.py` is a Python package for making electrochemical impedance spectroscopy (EIS) analysis reproducible and easy-to-use. It extends [impedance.py](https://github.com/ECSHackWeek/impedance.py) by adding least_squares, GA (using pygad), and PSO (using pyswarms) as additional optimization methods. `impedance_extend.py` additionally supports sequential optimization (such as running GA/PSO followed by least_squares), and adding soft-constraints (such as ensure R1 < R2 or R1*C1 < 1 etc.). 
+
+Aiming to create a consistent, [scikit-learn-like API](https://arxiv.org/abs/1309.0238) for impedance analysis, impedance.py contains modules for data preprocessing, validation, model fitting, and visualization.
+
+For a little more in-depth discussion of the package background and capabilities, check out our [Journal of Open Source Software paper](https://joss.theoj.org/papers/10.21105/joss.02349).
+
+If you have a feature request or find a bug, please [file an issue](https://github.com/k-vijayaraghavan/impedance_extend.py/issues) or, better yet, make the code improvements and [submit a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)! The goal is to build an open-source tool that the entire impedance community can improve and use!
+
+### Installation
+
+The easiest way to install impedance_extend.py is from [PyPI](https://pypi.org/project/impedance_extend/) using pip.
+
+```bash
+pip install impedance_extend
+```
+
+See [Getting started with impedance.py](https://impedancepy.readthedocs.io/en/latest/getting-started.html) for instructions on getting started from scratch.
+
+#### Dependencies
+
+impedance.py requires:
+
+-   Python (>=3.10)
+-   SciPy (>=1.0)
+-   NumPy (>=1.22.4)
+-   Matplotlib (>=3.5)
+-   Altair (>=3.0)
+-   Pandas
+-   pygad>=3.6.0
+-   pyswarms>=1.3
+
+Several example notebooks are provided in the `docs/source/examples/` directory. Opening these will require Jupyter notebook or Jupyter lab.
+
+#### Examples and Documentation
+
+Several examples can be found in the `docs/source/examples/` directory (the [Fitting impedance spectra notebook](https://impedancepy.readthedocs.io/en/latest/examples/fitting_example.html) is a great place to start) and the documentation can be found at [impedancepy.readthedocs.io](https://impedancepy.readthedocs.io/en/latest/).
+
+## Citing impedance.py
+
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.02349/status.svg)](https://doi.org/10.21105/joss.02349)
+
+If you use impedance.py in published work, please consider citing https://joss.theoj.org/papers/10.21105/joss.02349 as
+
+```bash
+@article{Murbach2020,
+  doi = {10.21105/joss.02349},
+  url = {https://doi.org/10.21105/joss.02349},
+  year = {2020},
+  publisher = {The Open Journal},
+  volume = {5},
+  number = {52},
+  pages = {2349},
+  author = {Matthew D. Murbach and Brian Gerwe and Neal Dawson-Elli and Lok-kun Tsui},
+  title = {impedance.py: A Python package for electrochemical impedance analysis},
+  journal = {Journal of Open Source Software}
+}
+```
+
+## Contributors ✨
+
+This project was adapted from a fork of [impedance.py] (https://github.com/k-vijayaraghavan/impedance_extend.py). [Impedance.py] (https://github.com/k-vijayaraghavan/impedance_extend.py) was started at the [2018 Electrochemical Society (ECS) Hack Week in Seattle](https://www.electrochem.org/233/hack-week) and has benefited from a community of users and contributors since. Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+  <tbody>
+    <tr>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/k-vijayaraghavan"><img src="https://avatars.githubusercontent.com/u/62916263?v=4" width="100px;" alt="Krishna Vijayaraghavan"/><br /><sub><b>Krishna Vijayaraghavan</b></sub></a><br /><a href="https://github.com/k-vijayaraghavan/impedance_extend.py/commits?author=k-vijayaraghavan" title="Code">💻</a></td>
+    </tr>
+    <tr>
+  </tbody>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

impedance_extend-1.0.0/README.md

@@ -0,0 +1,89 @@
+[![DOI]]  ![GitHub release](https://img.shields.io/github/release/k-vijayaraghavan/impedance_extend.py)
+
+![PyPI - Downloads](https://img.shields.io/pypi/dm/impedance_extend?style=flat-square)  [![All Contributors](https://img.shields.io/badge/all_contributors-1-orange.svg?style=flat-square)](#contributors)
+
+[![Build Status](https://github.com/k-vijayaraghavan/impedance_extend.py/actions/workflows/ci.yml/badge.svg)](https://github.com/k-vijayaraghavan/impedance_extend.py/actions)  [![Documentation Status](https://readthedocs.org/projects/impedancepy/badge/?version=latest&kill_cache=1)](https://impedancepy.readthedocs.io/en/latest/?badge=latest) [![Coverage Status](https://coveralls.io/repos/github/ECSHackWeek/impedance.py/badge.svg?branch=master&kill_cache=1)](https://coveralls.io/github/ECSHackWeek/impedance.py?branch=master)
+
+impedance_extend.py
+------------
+
+`impedance_extend.py` is a Python package for making electrochemical impedance spectroscopy (EIS) analysis reproducible and easy-to-use. It extends [impedance.py](https://github.com/ECSHackWeek/impedance.py) by adding least_squares, GA (using pygad), and PSO (using pyswarms) as additional optimization methods. `impedance_extend.py` additionally supports sequential optimization (such as running GA/PSO followed by least_squares), and adding soft-constraints (such as ensure R1 < R2 or R1*C1 < 1 etc.). 
+
+Aiming to create a consistent, [scikit-learn-like API](https://arxiv.org/abs/1309.0238) for impedance analysis, impedance.py contains modules for data preprocessing, validation, model fitting, and visualization.
+
+For a little more in-depth discussion of the package background and capabilities, check out our [Journal of Open Source Software paper](https://joss.theoj.org/papers/10.21105/joss.02349).
+
+If you have a feature request or find a bug, please [file an issue](https://github.com/k-vijayaraghavan/impedance_extend.py/issues) or, better yet, make the code improvements and [submit a pull request](https://help.github.com/articles/creating-a-pull-request-from-a-fork/)! The goal is to build an open-source tool that the entire impedance community can improve and use!
+
+### Installation
+
+The easiest way to install impedance_extend.py is from [PyPI](https://pypi.org/project/impedance_extend/) using pip.
+
+```bash
+pip install impedance_extend
+```
+
+See [Getting started with impedance.py](https://impedancepy.readthedocs.io/en/latest/getting-started.html) for instructions on getting started from scratch.
+
+#### Dependencies
+
+impedance.py requires:
+
+-   Python (>=3.10)
+-   SciPy (>=1.0)
+-   NumPy (>=1.22.4)
+-   Matplotlib (>=3.5)
+-   Altair (>=3.0)
+-   Pandas
+-   pygad>=3.6.0
+-   pyswarms>=1.3
+
+Several example notebooks are provided in the `docs/source/examples/` directory. Opening these will require Jupyter notebook or Jupyter lab.
+
+#### Examples and Documentation
+
+Several examples can be found in the `docs/source/examples/` directory (the [Fitting impedance spectra notebook](https://impedancepy.readthedocs.io/en/latest/examples/fitting_example.html) is a great place to start) and the documentation can be found at [impedancepy.readthedocs.io](https://impedancepy.readthedocs.io/en/latest/).
+
+## Citing impedance.py
+
+[![DOI](https://joss.theoj.org/papers/10.21105/joss.02349/status.svg)](https://doi.org/10.21105/joss.02349)
+
+If you use impedance.py in published work, please consider citing https://joss.theoj.org/papers/10.21105/joss.02349 as
+
+```bash
+@article{Murbach2020,
+  doi = {10.21105/joss.02349},
+  url = {https://doi.org/10.21105/joss.02349},
+  year = {2020},
+  publisher = {The Open Journal},
+  volume = {5},
+  number = {52},
+  pages = {2349},
+  author = {Matthew D. Murbach and Brian Gerwe and Neal Dawson-Elli and Lok-kun Tsui},
+  title = {impedance.py: A Python package for electrochemical impedance analysis},
+  journal = {Journal of Open Source Software}
+}
+```
+
+## Contributors ✨
+
+This project was adapted from a fork of [impedance.py] (https://github.com/k-vijayaraghavan/impedance_extend.py). [Impedance.py] (https://github.com/k-vijayaraghavan/impedance_extend.py) was started at the [2018 Electrochemical Society (ECS) Hack Week in Seattle](https://www.electrochem.org/233/hack-week) and has benefited from a community of users and contributors since. Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
+
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable -->
+<table>
+  <tbody>
+    <tr>
+      <td align="center" valign="top" width="14.28%"><a href="https://github.com/k-vijayaraghavan"><img src="https://avatars.githubusercontent.com/u/62916263?v=4" width="100px;" alt="Krishna Vijayaraghavan"/><br /><sub><b>Krishna Vijayaraghavan</b></sub></a><br /><a href="https://github.com/k-vijayaraghavan/impedance_extend.py/commits?author=k-vijayaraghavan" title="Code">💻</a></td>
+    </tr>
+    <tr>
+  </tbody>
+</table>
+
+<!-- markdownlint-restore -->
+<!-- prettier-ignore-end -->
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

impedance_extend-1.0.0/impedance_extend/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

impedance_extend-1.0.0/impedance_extend/models/circuits/__init__.py

@@ -0,0 +1,2 @@
+# move the circuits file up a namespace for readability
+from .circuits import *  # noqa: F401, F403

impedance_extend-1.0.0/impedance_extend/models/circuits/circuits.py

@@ -0,0 +1,440 @@
+from .fitting import circuit_fit, buildCircuit
+from .fitting import calculateCircuitLength, check_and_eval
+from impedance_extend.visualization import plot_altair, plot_bode, \
+                                                    plot_nyquist
+from .elements import circuit_elements, get_element_from_name
+
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+import warnings
+
+
+class BaseCircuit:
+    """ Base class for equivalent circuit models """
+    def __init__(self, initial_guess=[], constants=None, name=None):
+        """ Base constructor for any equivalent circuit model
+
+        Parameters
+        ----------
+        initial_guess: numpy array
+            Initial guess of the circuit values
+
+        constants : dict, optional
+            Parameters and values to hold constant during fitting
+            (e.g. {"R0": 0.1})
+
+        name : str, optional
+            Name for the circuit
+        """
+
+        # if supplied, check that initial_guess is valid and store
+        initial_guess = [x for x in initial_guess if x is not None]
+        for i in initial_guess:
+            if not isinstance(i, (float, int, np.int32, np.float64)):
+                raise TypeError(f'value {i} in initial_guess is not a number')
+
+        # initalize class attributes
+        self.initial_guess = initial_guess
+        if constants is not None:
+            self.constants = constants
+        else:
+            self.constants = {}
+        self.name = name
+
+        # initialize fit parameters and confidence intervals
+        self.parameters_ = None
+        self.conf_ = None
+
+    def __eq__(self, other):
+        if self.__class__ == other.__class__:
+            matches = []
+            for key, value in self.__dict__.items():
+                if isinstance(value, np.ndarray):
+                    matches.append((value == other.__dict__[key]).all())
+                else:
+                    matches.append(value == other.__dict__[key])
+            return np.array(matches).all()
+        else:
+            raise TypeError('Comparing object is not of the same type.')
+
+    def fit(self, frequencies, impedance, bounds=None,
+            weight_by_modulus=False, **kwargs):
+        """ Fit the circuit model
+
+        Parameters
+        ----------
+        frequencies: numpy array
+            Frequencies
+
+        impedance: numpy array of dtype 'complex128'
+            Impedance values to fit
+
+        bounds: 2-tuple of array_like, optional
+            Lower and upper bounds on parameters. Defaults to bounds on all
+            parameters of 0 and np.inf, except the CPE alpha
+            which has an upper bound of 1
+
+        weight_by_modulus : bool, optional
+            Uses the modulus of each data (|Z|) as the weighting factor.
+            Standard weighting scheme when experimental variances are
+            unavailable. Only applicable when global_opt = False
+
+        kwargs :
+            Keyword arguments passed to
+            impedance_extend.models.circuits.fitting.circuit_fit,
+            and subsequently to scipy.optimize.curve_fit
+            or scipy.optimize.basinhopping
+
+        Returns
+        -------
+        self: returns an instance of self
+
+        """
+        frequencies = np.array(frequencies, dtype=float)
+        impedance = np.array(impedance, dtype=complex)
+
+        if len(frequencies) != len(impedance):
+            raise TypeError('length of frequencies and impedance do not match')
+
+        if self.initial_guess != []:
+            parameters, conf = circuit_fit(frequencies, impedance,
+                                           self.circuit, self.initial_guess,
+                                           constants=self.constants,
+                                           bounds=bounds,
+                                           weight_by_modulus=weight_by_modulus,
+                                           **kwargs)
+            self.parameters_ = parameters
+            if conf is not None:
+                self.conf_ = conf
+        else:
+            raise ValueError('No initial guess supplied')
+
+        return self
+
+    def _is_fit(self):
+        """ check if model has been fit (parameters_ is not None) """
+        if self.parameters_ is not None:
+            return True
+        else:
+            return False
+
+    def predict(self, frequencies, use_initial=False):
+        """ Predict impedance using an equivalent circuit model
+
+        Parameters
+        ----------
+        frequencies: array-like of numeric type
+        use_initial: boolean
+            If true and the model was previously fit use the initial
+            parameters instead
+
+        Returns
+        -------
+        impedance: ndarray of dtype 'complex128'
+            Predicted impedance at each frequency
+        """
+        frequencies = np.array(frequencies, dtype=float)
+        buildCircuit_text = buildCircuit(
+            self.circuit, constants=self.constants, eval_string='', index=0)[0]
+        builtCircuit = eval('lambda frequencies,parameters : ' +
+                            buildCircuit_text, circuit_elements)
+        if self._is_fit() and not use_initial:
+            return builtCircuit(frequencies, self.parameters_)
+        else:
+            warnings.warn("Simulating circuit based on initial parameters")
+            return builtCircuit(frequencies, self.initial_guess)
+
+    def get_param_names(self):
+        """ Converts circuit string to names and units """
+
+        # parse the element names from the circuit string
+        names = self.circuit.replace('p', '').replace('(', '').replace(')', '')
+        names = names.replace(',', '-').replace(' ', '').split('-')
+
+        full_names, all_units = [], []
+        for name in names:
+            elem = get_element_from_name(name)
+            num_params = check_and_eval(elem).num_params
+            units = check_and_eval(elem).units
+            if num_params > 1:
+                for j in range(num_params):
+                    full_name = '{}_{}'.format(name, j)
+                    if full_name not in self.constants.keys():
+                        full_names.append(full_name)
+                        all_units.append(units[j])
+            else:
+                if name not in self.constants.keys():
+                    full_names.append(name)
+                    all_units.append(units[0])
+
+        return full_names, all_units
+
+    def __str__(self):
+        """ Defines the pretty printing of the circuit"""
+
+        to_print = '\n'
+        if self.name is not None:
+            to_print += 'Name: {}\n'.format(self.name)
+        to_print += 'Circuit string: {}\n'.format(self.circuit)
+        to_print += "Fit: {}\n".format(self._is_fit())
+
+        if len(self.constants) > 0:
+            to_print += '\nConstants:\n'
+            for name, value in self.constants.items():
+                elem = get_element_from_name(name)
+                units = check_and_eval(elem).units
+                if '_' in name and len(units) > 1:
+                    unit = units[int(name.split('_')[-1])]
+                else:
+                    unit = units[0]
+                to_print += '  {:>5} = {:.2e} [{}]\n'.format(name, value, unit)
+
+        names, units = self.get_param_names()
+        to_print += '\nInitial guesses:\n'
+        for name, unit, param in zip(names, units, self.initial_guess):
+            to_print += '  {:>5} = {:.2e} [{}]\n'.format(name, param, unit)
+        if self._is_fit():
+            params, confs = self.parameters_, self.conf_
+            to_print += '\nFit parameters:\n'
+            for name, unit, param, conf in zip(names, units, params, confs):
+                to_print += '  {:>5} = {:.2e}'.format(name, param)
+                to_print += '  (+/- {:.2e}) [{}]\n'.format(conf, unit)
+
+        return to_print
+
+    def plot(self, ax=None, f_data=None, Z_data=None, kind='altair', **kwargs):
+        """ visualizes the model and optional data as a nyquist,
+            bode, or altair (interactive) plots
+
+        Parameters
+        ----------
+        ax: matplotlib.axes
+            axes to plot on
+        f_data: np.array of type float
+            Frequencies of input data (for Bode plots)
+        Z_data: np.array of type complex
+            Impedance data to plot
+        kind: {'altair', 'nyquist', 'bode'}
+            type of plot to visualize
+
+        Other Parameters
+        ----------------
+        **kwargs : optional
+            If kind is 'nyquist' or 'bode', used to specify additional
+             `matplotlib.pyplot.Line2D` properties like linewidth,
+             line color, marker color, and labels.
+            If kind is 'altair', used to specify nyquist height as `size`
+
+        Returns
+        -------
+        ax: matplotlib.axes
+            axes of the created nyquist plot
+        """
+
+        if kind == 'nyquist':
+            if ax is None:
+                _, ax = plt.subplots(figsize=(5, 5))
+
+            if Z_data is not None:
+                ax = plot_nyquist(Z_data, ls='', marker='s', ax=ax, **kwargs)
+
+            if self._is_fit():
+                if f_data is not None:
+                    f_pred = f_data
+                else:
+                    f_pred = np.logspace(5, -3)
+
+                Z_fit = self.predict(f_pred)
+                ax = plot_nyquist(Z_fit, ls='-', marker='', ax=ax, **kwargs)
+            return ax
+        elif kind == 'bode':
+            if ax is None:
+                _, ax = plt.subplots(nrows=2, figsize=(5, 5))
+
+            if f_data is not None:
+                f_pred = f_data
+            else:
+                f_pred = np.logspace(5, -3)
+
+            if Z_data is not None:
+                if f_data is None:
+                    raise ValueError('f_data must be specified if' +
+                                     ' Z_data for a Bode plot')
+                ax = plot_bode(f_data, Z_data, ls='', marker='s',
+                               axes=ax, **kwargs)
+
+            if self._is_fit():
+                Z_fit = self.predict(f_pred)
+                ax = plot_bode(f_pred, Z_fit, ls='-', marker='',
+                               axes=ax, **kwargs)
+            return ax
+        elif kind == 'altair':
+            plot_dict = {}
+
+            if Z_data is not None and f_data is not None:
+                plot_dict['data'] = {'f': f_data, 'Z': Z_data}
+
+            if self._is_fit():
+                if f_data is not None:
+                    f_pred = f_data
+                else:
+                    f_pred = np.logspace(5, -3)
+
+                Z_fit = self.predict(f_pred)
+                if self.name is not None:
+                    name = self.name
+                else:
+                    name = 'fit'
+                plot_dict[name] = {'f': f_pred, 'Z': Z_fit, 'fmt': '-'}
+
+            chart = plot_altair(plot_dict, **kwargs)
+            return chart
+        else:
+            raise ValueError("Kind must be one of 'altair'," +
+                             f"'nyquist', or 'bode' (received {kind})")
+
+    def save(self, filepath):
+        """ Exports a model to JSON
+
+        Parameters
+        ----------
+        filepath: str
+            Destination for exporting model object
+        """
+
+        model_string = self.circuit
+        model_name = self.name
+
+        initial_guess = self.initial_guess
+
+        if self._is_fit():
+            parameters_ = list(self.parameters_)
+            model_conf_ = list(self.conf_)
+
+            data_dict = {"Name": model_name,
+                         "Circuit String": model_string,
+                         "Initial Guess": initial_guess,
+                         "Constants": self.constants,
+                         "Fit": True,
+                         "Parameters": parameters_,
+                         "Confidence": model_conf_,
+                         }
+        else:
+            data_dict = {"Name": model_name,
+                         "Circuit String": model_string,
+                         "Initial Guess": initial_guess,
+                         "Constants": self.constants,
+                         "Fit": False}
+
+        with open(filepath, 'w') as f:
+            json.dump(data_dict, f)
+
+    def load(self, filepath, fitted_as_initial=False):
+        """ Imports a model from JSON
+
+        Parameters
+        ----------
+        filepath: str
+            filepath to JSON file to load model from
+
+        fitted_as_initial: bool
+            If true, loads the model's fitted parameters
+            as initial guesses
+
+            Otherwise, loads the model's initial and
+            fitted parameters as a completed model
+        """
+
+        json_data_file = open(filepath, 'r')
+        json_data = json.load(json_data_file)
+
+        model_name = json_data["Name"]
+        model_string = json_data["Circuit String"]
+        model_initial_guess = json_data["Initial Guess"]
+        model_constants = json_data["Constants"]
+
+        self.initial_guess = model_initial_guess
+        self.circuit = model_string
+        print(self.circuit)
+        self.constants = model_constants
+        self.name = model_name
+
+        if json_data["Fit"]:
+            if fitted_as_initial:
+                self.initial_guess = np.array(json_data['Parameters'])
+            else:
+                self.parameters_ = np.array(json_data["Parameters"])
+                self.conf_ = np.array(json_data["Confidence"])
+
+
+class Randles(BaseCircuit):
+    """ A Randles circuit model class """
+    def __init__(self, CPE=False, **kwargs):
+        """ Constructor for the Randles' circuit class
+
+        Parameters
+        ----------
+        initial_guess: numpy array
+            Initial guess of the circuit values
+
+        CPE: boolean
+            Use a constant phase element instead of a capacitor
+        """
+        super().__init__(**kwargs)
+
+        if CPE:
+            self.name = 'Randles w/ CPE'
+            self.circuit = 'R0-p(R1-Wo1,CPE1)'
+        else:
+            self.name = 'Randles'
+            self.circuit = 'R0-p(R1-Wo1,C1)'
+
+        circuit_len = calculateCircuitLength(self.circuit)
+
+        if len(self.initial_guess) + len(self.constants) != circuit_len:
+            raise ValueError('The number of initial guesses ' +
+                             f'({len(self.initial_guess)}) + ' +
+                             'the number of constants ' +
+                             f'({len(self.constants)})' +
+                             ' must be equal to ' +
+                             f'the circuit length ({circuit_len})')
+
+
+class CustomCircuit(BaseCircuit):
+    def __init__(self, circuit='', **kwargs):
+        """ Constructor for a customizable equivalent circuit model
+
+        Parameters
+        ----------
+        initial_guess: numpy array
+            Initial guess of the circuit values
+
+        circuit: string
+            A string that should be interpreted as an equivalent circuit
+
+        Notes
+        -----
+        A custom circuit is defined as a string comprised of elements in series
+        (separated by a `-`) and elements in parallel (grouped as (x,y)).
+        Each element can be appended with an integer (e.g. R0) or an underscore
+        and an integer (e.g. CPE_1) to make keeping track of multiple elements
+        of the same type easier.
+
+        Example:
+            Randles circuit is given by 'R0-p(R1-Wo1,C1)'
+
+        """
+
+        super().__init__(**kwargs)
+        self.circuit = circuit.replace(" ", "")
+
+        circuit_len = calculateCircuitLength(self.circuit)
+
+        if len(self.initial_guess) + len(self.constants) != circuit_len:
+            raise ValueError('The number of initial guesses ' +
+                             f'({len(self.initial_guess)}) + ' +
+                             'the number of constants ' +
+                             f'({len(self.constants)})' +
+                             ' must be equal to ' +
+                             f'the circuit length ({circuit_len})')