Skip to content

evaluators

Evaluators

Calls models to evaluate function and gradient functions.

Source code in process/core/solver/evaluators.py 
 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
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
class Evaluators:
    """Calls models to evaluate function and gradient functions."""

    def __init__(self, models, _x):
        """Instantiate Caller with model objects.

        :param models: physics and engineering model objects
        :type models: process.main.Models
        :param x: optimisation parameters
        :type x: np.ndarray
        """
        self.caller = Caller(models)

    def fcnvmc1(self, _n, m, xv, ifail):
        """Function evaluator for VMCON.

        This routine is the function evaluator for the VMCON
        maximisation/minimisation routine.

        It calculates the objective and constraint functions at the
        n-dimensional point of interest xv.
        Note that the equality constraints must precede the inequality
        constraints in conf.

        Parameters
        ----------
        _n : int
            number of variables
        m : int
            number of constraints
        xv : numpy.array
            scaled variable values, length n
        ifail : int
            ifail error flag

        Returns
        -------
        tuple
            tuple containing: objfn objective function, conf(m) constraint
            functions
        """
        # Output array for constraint functions
        conf = np.zeros(m, dtype=np.float64, order="F")

        # Evaluate machine parameters at xv
        objf, conf = self.caller.call_models(xv, m)

        # Verbose diagnostics
        if gv.verbose == 1:
            summ = 0.0
            for i in range(m):
                summ = summ + conf[i] ** 2

            sqsumconfsq = math.sqrt(summ)
            logger.debug("Key evaluator values:")
            logger.debug(f"{numerics.nviter = }")
            logger.debug(f"{(1 - (ifail % 7)) - 1 = }")
            logger.debug(f"{(numerics.nviter % 2) - 1 = }")
            logger.debug(f"{pv.temp_plasma_electron_vol_avg_kev = }")
            logger.debug(f"{cv.coe = }")
            logger.debug(f"{pv.rmajor = }")
            logger.debug(f"{pv.p_fusion_total_mw = }")
            logger.debug(f"{pv.b_plasma_toroidal_on_axis = }")
            logger.debug(f"{tv.t_plant_pulse_burn = }")
            logger.debug(f"{sqsumconfsq = }")
            logger.debug(f"{xv = }")

        return objf, conf

    def fcnvmc2(self, n, m, xv, lcnorm):
        """Gradient function evaluator for VMCON.

        This routine is the gradient function evaluator for the VMCON
        maximisation/minimisation routine. It calculates the gradients of the
        objective and constraint functions at the n-dimensional point of interest
        xv. Note that the equality constraints must precede the inequality
        constraints in conf. The constraint gradients or normals are returned as the
        columns of cnorm.

        Parameters
        ----------
        n : int
            number of variables
        m : int
            number of constraints
        xv : numpy.array
            scaled variable names, size n
        lcnorm : int
            number of columns in cnorm

        Returns
        -------
        tuple
            fgrdm (numpy.array (n)) gradient of the objective function
            cnorm (numpy.array (lcnorm, m)) constraint gradients, i.e. cnorm[i, j] is
            the derivative of constraint j w.r.t. variable i
        """
        xfor = np.zeros(n, dtype=np.float64, order="F")
        xbac = np.zeros(n, dtype=np.float64, order="F")
        cfor = np.zeros(m, dtype=np.float64, order="F")
        cbac = np.zeros(m, dtype=np.float64, order="F")
        fgrd = np.zeros(n, dtype=np.float64, order="F")
        cnorm = np.zeros((lcnorm, m), dtype=np.float64, order="F")

        ffor = 0.0
        fbac = 0.0

        for i in range(n):
            for j in range(n):
                xfor[j] = xv[j]
                xbac[j] = xv[j]
                if i == j:
                    xfor[i] = xv[j] * (1.0 + numerics.epsfcn)
                    xbac[i] = xv[j] * (1.0 - numerics.epsfcn)

            # Evaluate at (x+dx)
            ffor, cfor = self.caller.call_models(xfor, m)

            # Evaluate at (x-dx)
            fbac, cbac = self.caller.call_models(xbac, m)

            # Calculate finite difference gradients
            fgrd[i] = (ffor - fbac) / (xfor[i] - xbac[i])

            for j in range(m):
                cnorm[i, j] = (cfor[j] - cbac[j]) / (xfor[i] - xbac[i])

        # Additional evaluation call to ensure that final result is consistent
        # with the correct iteration variable values.
        # If this is not done, the value of the nth (i.e. final) iteration
        # variable in the solution vector is inconsistent with its value
        # shown elsewhere in the output file, which is a factor (1-epsfcn)
        # smaller (i.e. its xbac value above).
        self.caller.call_models(xv, m)

        return fgrd, cnorm

caller = Caller(models) instance-attribute

fcnvmc1(_n, m, xv, ifail)

Function evaluator for VMCON.

This routine is the function evaluator for the VMCON maximisation/minimisation routine.

It calculates the objective and constraint functions at the n-dimensional point of interest xv. Note that the equality constraints must precede the inequality constraints in conf.

Parameters:

Name Type Description Default
_n int

number of variables

 required
m int

number of constraints

 required
xv array

scaled variable values, length n

 required
ifail int

ifail error flag

 required

Returns:

Type Description
tuple

tuple containing: objfn objective function, conf(m) constraint functions
Source code in process/core/solver/evaluators.py 
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
def fcnvmc1(self, _n, m, xv, ifail):
    """Function evaluator for VMCON.

    This routine is the function evaluator for the VMCON
    maximisation/minimisation routine.

    It calculates the objective and constraint functions at the
    n-dimensional point of interest xv.
    Note that the equality constraints must precede the inequality
    constraints in conf.

    Parameters
    ----------
    _n : int
        number of variables
    m : int
        number of constraints
    xv : numpy.array
        scaled variable values, length n
    ifail : int
        ifail error flag

    Returns
    -------
    tuple
        tuple containing: objfn objective function, conf(m) constraint
        functions
    """
    # Output array for constraint functions
    conf = np.zeros(m, dtype=np.float64, order="F")

    # Evaluate machine parameters at xv
    objf, conf = self.caller.call_models(xv, m)

    # Verbose diagnostics
    if gv.verbose == 1:
        summ = 0.0
        for i in range(m):
            summ = summ + conf[i] ** 2

        sqsumconfsq = math.sqrt(summ)
        logger.debug("Key evaluator values:")
        logger.debug(f"{numerics.nviter = }")
        logger.debug(f"{(1 - (ifail % 7)) - 1 = }")
        logger.debug(f"{(numerics.nviter % 2) - 1 = }")
        logger.debug(f"{pv.temp_plasma_electron_vol_avg_kev = }")
        logger.debug(f"{cv.coe = }")
        logger.debug(f"{pv.rmajor = }")
        logger.debug(f"{pv.p_fusion_total_mw = }")
        logger.debug(f"{pv.b_plasma_toroidal_on_axis = }")
        logger.debug(f"{tv.t_plant_pulse_burn = }")
        logger.debug(f"{sqsumconfsq = }")
        logger.debug(f"{xv = }")

    return objf, conf

fcnvmc2(n, m, xv, lcnorm)

Gradient function evaluator for VMCON.

This routine is the gradient function evaluator for the VMCON maximisation/minimisation routine. It calculates the gradients of the objective and constraint functions at the n-dimensional point of interest xv. Note that the equality constraints must precede the inequality constraints in conf. The constraint gradients or normals are returned as the columns of cnorm.

Parameters:

Name Type Description Default
n int

number of variables

 required
m int

number of constraints

 required
xv array

scaled variable names, size n

 required
lcnorm int

number of columns in cnorm

 required

Returns:

Type Description
tuple

fgrdm (numpy.array (n)) gradient of the objective function cnorm (numpy.array (lcnorm, m)) constraint gradients, i.e. cnorm[i, j] is the derivative of constraint j w.r.t. variable i
Source code in process/core/solver/evaluators.py 
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
def fcnvmc2(self, n, m, xv, lcnorm):
    """Gradient function evaluator for VMCON.

    This routine is the gradient function evaluator for the VMCON
    maximisation/minimisation routine. It calculates the gradients of the
    objective and constraint functions at the n-dimensional point of interest
    xv. Note that the equality constraints must precede the inequality
    constraints in conf. The constraint gradients or normals are returned as the
    columns of cnorm.

    Parameters
    ----------
    n : int
        number of variables
    m : int
        number of constraints
    xv : numpy.array
        scaled variable names, size n
    lcnorm : int
        number of columns in cnorm

    Returns
    -------
    tuple
        fgrdm (numpy.array (n)) gradient of the objective function
        cnorm (numpy.array (lcnorm, m)) constraint gradients, i.e. cnorm[i, j] is
        the derivative of constraint j w.r.t. variable i
    """
    xfor = np.zeros(n, dtype=np.float64, order="F")
    xbac = np.zeros(n, dtype=np.float64, order="F")
    cfor = np.zeros(m, dtype=np.float64, order="F")
    cbac = np.zeros(m, dtype=np.float64, order="F")
    fgrd = np.zeros(n, dtype=np.float64, order="F")
    cnorm = np.zeros((lcnorm, m), dtype=np.float64, order="F")

    ffor = 0.0
    fbac = 0.0

    for i in range(n):
        for j in range(n):
            xfor[j] = xv[j]
            xbac[j] = xv[j]
            if i == j:
                xfor[i] = xv[j] * (1.0 + numerics.epsfcn)
                xbac[i] = xv[j] * (1.0 - numerics.epsfcn)

        # Evaluate at (x+dx)
        ffor, cfor = self.caller.call_models(xfor, m)

        # Evaluate at (x-dx)
        fbac, cbac = self.caller.call_models(xbac, m)

        # Calculate finite difference gradients
        fgrd[i] = (ffor - fbac) / (xfor[i] - xbac[i])

        for j in range(m):
            cnorm[i, j] = (cfor[j] - cbac[j]) / (xfor[i] - xbac[i])

    # Additional evaluation call to ensure that final result is consistent
    # with the correct iteration variable values.
    # If this is not done, the value of the nth (i.e. final) iteration
    # variable in the solution vector is inconsistent with its value
    # shown elsewhere in the output file, which is a factor (1-epsfcn)
    # smaller (i.e. its xbac value above).
    self.caller.call_models(xv, m)

    return fgrd, cnorm