1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 """Module for the multi-processor command system."""
26
27
28 import sys
29 from re import match
30
31
32 from maths_fns.mf import Mf
33 from minfx.generic import generic_minimise
34 from minfx.grid import grid, grid_point_array
35 from multi import Memo, Result_command, Slave_command
36
37
38
40 """Print out some header text for the spin.
41
42 @param spin_id: The spin ID string.
43 @type spin_id: str
44 @param verbosity: The amount of information to print. The higher the value, the greater the verbosity.
45 @type verbosity: int
46 """
47
48
49 if verbosity >= 2:
50 print("\n\n")
51
52
53 string = "Fitting to spin " + repr(spin_id)
54 print("\n\n" + string)
55 print(len(string) * '~')
56
57
58
60 """The model-free memo class.
61
62 Not quite a momento so a memo.
63 """
64
65 - def __init__(self, model_free=None, model_type=None, spin=None, sim_index=None, scaling=None, scaling_matrix=None):
66 """Initialise the model-free memo class.
67
68 This memo stores the model-free class instance so that the _disassemble_result() method can be called to store the optimisation results. The other args are those required by this method but not generated through optimisation.
69
70 @keyword model_free: The model-free class instance.
71 @type model_free: specific_fns.model_free.Model_free instance
72 @keyword spin: The spin data container. If this argument is supplied, then the spin_id argument will be ignored.
73 @type spin: SpinContainer instance
74 @keyword sim_index: The optional MC simulation index.
75 @type sim_index: int
76 @keyword scaling: If True, diagonal scaling is enabled.
77 @type scaling: bool
78 @keyword scaling_matrix: The diagonal, square scaling matrix.
79 @type scaling_matrix: numpy diagonal matrix
80 """
81
82
83 super(MF_memo, self).__init__()
84
85
86 self.model_free = model_free
87 self.model_type = model_type
88 self.spin = spin
89 self.sim_index = sim_index
90 self.scaling = scaling
91 self.scaling_matrix = scaling_matrix
92
93
94
96 """Command class for standard model-free minimisation."""
97
103
104
106 """Model-free optimisation.
107
108 @return: The optimisation results consisting of the parameter vector, function value, iteration count, function count, gradient count, Hessian count, and warnings.
109 @rtype: tuple of numpy array, float, int, int, int, int, str
110 """
111
112
113 results = generic_minimise(func=self.mf.func, dfunc=self.mf.dfunc, d2func=self.mf.d2func, args=(), x0=self.opt_params.param_vector, min_algor=self.opt_params.min_algor, min_options=self.opt_params.min_options, func_tol=self.opt_params.func_tol, grad_tol=self.opt_params.grad_tol, maxiter=self.opt_params.max_iterations, A=self.opt_params.A, b=self.opt_params.b, full_output=True, print_flag=self.opt_params.verbosity)
114
115
116 return results
117
118
119 - def run(self, processor, completed):
120 """Setup and perform the model-free optimisation."""
121
122
123 self.mf = Mf(init_params=self.opt_params.param_vector, model_type=self.data.model_type, diff_type=self.data.diff_type, diff_params=self.data.diff_params, scaling_matrix=self.data.scaling_matrix, num_spins=self.data.num_spins, equations=self.data.equations, param_types=self.data.param_types, param_values=self.data.param_values, relax_data=self.data.ri_data, errors=self.data.ri_data_err, bond_length=self.data.r, csa=self.data.csa, num_frq=self.data.num_frq, frq=self.data.frq, num_ri=self.data.num_ri, remap_table=self.data.remap_table, noe_r1_table=self.data.noe_r1_table, ri_labels=self.data.ri_types, gx=self.data.gx, gh=self.data.gh, h_bar=self.data.h_bar, mu0=self.data.mu0, num_params=self.data.num_params, vectors=self.data.xh_unit_vectors)
124
125
126 if self.opt_params.verbosity >= 1 and (self.data.model_type == 'mf' or self.data.model_type == 'local_tm'):
127 spin_print(self.data.spin_id, self.opt_params.verbosity)
128
129
130 results = self.optimise()
131
132
133 param_vector, func, iter, fc, gc, hc, warning = results
134
135 processor.return_object(MF_result_command(processor, self.memo_id, param_vector, func, iter, fc, gc, hc, warning, completed=False))
136
137
139 """Store all the data required for model-free optimisation.
140
141 @param data: The data used to initialise the model-free target function class.
142 @type data: class instance
143 @param opt_params: The parameters and data required for optimisation using minfx.
144 @type opt_params: class instance
145 """
146
147
148 self.data = data
149 self.opt_params = opt_params
150
151
152
154 """Command class for the model-free grid search."""
155
161
162
164 """Model-free grid search.
165
166 @return: The optimisation results consisting of the parameter vector, function value, iteration count, function count, gradient count, Hessian count, and warnings.
167 @rtype: tuple of numpy array, float, int, int, int, int, str
168 """
169
170
171 if not hasattr(self.opt_params, 'subdivision'):
172 results = grid(func=self.mf.func, args=(), num_incs=self.opt_params.inc, lower=self.opt_params.lower, upper=self.opt_params.upper, A=self.opt_params.A, b=self.opt_params.b, verbosity=self.opt_params.verbosity)
173
174
175 else:
176 results = grid_point_array(func=self.mf.func, args=(), points=self.opt_params.subdivision, verbosity=self.opt_params.verbosity)
177
178
179 param_vector, func, iter, warning = results
180 fc = iter
181 gc = 0.0
182 hc = 0.0
183
184
185 return param_vector, func, iter, fc, gc, hc, warning
186
187
188
190 """Class for processing the model-free results."""
191
192 - def __init__(self, processor, memo_id, param_vector, func, iter, fc, gc, hc, warning, completed):
193 """Set up the class, placing the minimisation results here."""
194
195
196 super(MF_result_command, self).__init__(processor=processor, completed=completed)
197
198
199 self.memo_id = memo_id
200 self.param_vector = param_vector
201 self.func = func
202 self.iter = iter
203 self.fc = fc
204 self.gc = gc
205 self.hc = hc
206 self.warning = warning
207
208
209 - def run(self, processor, memo):
210 """Disassemble the model-free optimisation results.
211
212 @param processor: Unused!
213 @type processor: None
214 @param memo: The model-free memo.
215 @type memo: memo
216 """
217
218
219 memo.model_free._disassemble_result(param_vector=self.param_vector, func=self.func, iter=self.iter, fc=self.fc, gc=self.gc, hc=self.hc, warning=self.warning, spin=memo.spin, sim_index=memo.sim_index, model_type=memo.model_type, scaling=memo.scaling, scaling_matrix=memo.scaling_matrix)
220