Skip to content

job

analysis

AnalysisBase

Bases: ObjBase

This virtual class allows for the creation of technique-specific Analysis objects.

Source code in src/easyscience/job/analysis.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
class AnalysisBase(ObjBase, metaclass=ABCMeta):
    """This virtual class allows for the creation of technique-specific
    Analysis objects.
    """

    def __init__(self, name: str, interface=None, *args, **kwargs):
        super(AnalysisBase, self).__init__(name, *args, **kwargs)
        self.name = name
        self._calculator = None
        self._minimizer = None
        self._fitter = None
        self.interface = interface

    @abstractmethod
    def calculate_theory(self, x: np.ndarray, **kwargs) -> np.ndarray:
        raise NotImplementedError('calculate_theory not implemented')

    @abstractmethod
    def fit(self, x: np.ndarray, y: np.ndarray, e: np.ndarray, **kwargs) -> None:
        raise NotImplementedError('fit not implemented')

    @property
    def calculator(self) -> str:
        if self._calculator is None:
            self._calculator = self.interface.current_interface_name
        return self._calculator

    @calculator.setter
    def calculator(self, value) -> None:
        # TODO: check if the calculator is available for the given JobType
        self.interface.switch(value, fitter=self._fitter)

    @property
    def minimizer(self) -> MinimizerBase:
        return self._minimizer

    @minimizer.setter
    def minimizer(self, minimizer: MinimizerBase) -> None:
        self._minimizer = minimizer

    # required dunder methods
    def __str__(self):
        return f'Analysis: {self.name}'

experiment

ExperimentBase

Bases: ObjBase

This virtual class allows for the creation of technique-specific Experiment objects.

Source code in src/easyscience/job/experiment.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
class ExperimentBase(ObjBase):
    """This virtual class allows for the creation of technique-specific
    Experiment objects.
    """

    def __init__(self, name: str, *args, **kwargs):
        super(ExperimentBase, self).__init__(name, *args, **kwargs)
        self._name = name

    # required dunder methods
    def __str__(self):
        return f'Experiment: {self._name}'

job

JobBase

Bases: ObjBase

This virtual class allows for the creation of technique-specific Job objects.

Source code in src/easyscience/job/job.py 
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
class JobBase(ObjBase, metaclass=ABCMeta):
    """This virtual class allows for the creation of technique-specific
    Job objects.
    """

    def __init__(self, name: str, *args, **kwargs):
        super(JobBase, self).__init__(name, *args, **kwargs)
        self.name = name
        self._theory = None
        self._experiment = None
        self._analysis = None
        self._summary = None
        self._info = None

    """
    JobBase consists of Theory, Experiment, Analysis virtual classes.
    Summary and Info classes are included to store additional information.
    """

    @property
    def theorerical_model(self):
        return self._theory

    @theorerical_model.setter
    @abstractmethod
    def theoretical_model(self, theory: TheoreticalModelBase):
        raise NotImplementedError('theory setter not implemented')

    @property
    def experiment(self):
        return self._experiment

    @experiment.setter
    @abstractmethod
    def experiment(self, experiment: ExperimentBase):
        raise NotImplementedError('experiment setter not implemented')

    @property
    def analysis(self):
        return self._analysis

    @analysis.setter
    @abstractmethod
    def analysis(self, analysis: AnalysisBase):
        raise NotImplementedError('analysis setter not implemented')

    # TODO: extend derived classes to include Summary and Info
    # @property
    # def summary(self):
    #     return self._summary

    # @summary.setter
    # @abstractmethod
    # def summary(self, summary: SummaryBase):
    #     raise NotImplementedError("summary setter not implemented")

    # @property
    # def info(self):
    #     return self._info

    # @info.setter
    # @abstractmethod
    # def info(self, info: InfoBase):
    #     raise NotImplementedError("info setter not implemented")

    @abstractmethod
    def calculate_theory(self, *args, **kwargs):
        raise NotImplementedError('calculate_theory not implemented')

    @abstractmethod
    def fit(self, *args, **kwargs):
        raise NotImplementedError('fit not implemented')

theoreticalmodel

TheoreticalModelBase

Bases: ObjBase

This virtual class allows for the creation of technique-specific Theory objects.

Source code in src/easyscience/job/theoreticalmodel.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
class TheoreticalModelBase(ObjBase):
    """This virtual class allows for the creation of technique-specific
    Theory objects.
    """

    def __init__(self, name: str, *args, **kwargs):
        self._name = name
        super().__init__(name, *args, **kwargs)

    # required dunder methods
    def __str__(self):
        raise NotImplementedError('Copy not implemented')

    def as_dict(self, skip: list = []) -> dict:
        this_dict = super().as_dict(skip=skip)
        return this_dict