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
26
27
28
29
30
31
32
33
34
35
36
37
38 package ffx.ui;
39
40 import static java.lang.String.format;
41
42 import ffx.algorithms.AlgorithmFunctions;
43 import ffx.algorithms.AlgorithmListener;
44 import ffx.algorithms.AlgorithmUtils;
45 import ffx.numerics.Potential;
46 import ffx.potential.ForceFieldEnergy;
47 import ffx.potential.MolecularAssembly;
48 import ffx.potential.bonded.RotamerLibrary;
49 import ffx.potential.parameters.ForceField;
50 import ffx.potential.parsers.ForceFieldFilter;
51 import ffx.potential.parsers.PDBFilter;
52 import ffx.potential.parsers.PDBFilter.Mutation;
53 import ffx.potential.parsers.SystemFilter;
54 import ffx.utilities.Keyword;
55 import java.io.File;
56 import java.util.List;
57 import java.util.Optional;
58 import java.util.logging.Level;
59 import org.apache.commons.configuration2.CompositeConfiguration;
60 import org.apache.commons.io.FilenameUtils;
61
62
63
64
65
66
67
68
69
70
71
72
73 public class UIUtils extends AlgorithmUtils implements AlgorithmFunctions {
74
75 private final ModelingShell modelingShell;
76 private final MainPanel mainPanel;
77 private SystemFilter lastFilter;
78
79 public UIUtils(ModelingShell modelingShell, MainPanel mainPanel) {
80 this.modelingShell = modelingShell;
81 this.mainPanel = mainPanel;
82 }
83
84 @Override
85 public void close(MolecularAssembly assembly) {
86 Optional<FFXSystem> origSys = switchTo(assembly);
87 mainPanel.closeWait();
88 origSys.ifPresent(this::switchBack);
89 }
90
91 @Override
92 public void closeAll(MolecularAssembly[] assemblies) {
93 mainPanel.closeAll();
94 }
95
96 @Override
97 public ForceFieldEnergy energy(MolecularAssembly molecularAssembly) {
98 Optional<FFXSystem> origSys = switchTo(molecularAssembly);
99 ForceFieldEnergy forceFieldEnergy = modelingShell.energy();
100 origSys.ifPresent(this::switchBack);
101 return forceFieldEnergy;
102 }
103
104 @Override
105 public MolecularAssembly getActiveAssembly() {
106 return mainPanel.getHierarchy().getActive();
107 }
108
109 @Override
110 public List<String> getArguments() {
111 return modelingShell.getArgs();
112 }
113
114 @Override
115 public AlgorithmListener getDefaultListener() {
116 return modelingShell;
117 }
118
119 @Override
120 public SystemFilter getFilter() {
121 return lastFilter;
122 }
123
124 @Override
125 public boolean isLocal() {
126 return false;
127 }
128
129 @Override
130 public void md(
131 MolecularAssembly assembly,
132 int nStep,
133 double timeStep,
134 double printInterval,
135 double saveInterval,
136 double temperature,
137 boolean initVelocities,
138 File dyn) {
139 Optional<FFXSystem> origSys = switchTo(assembly);
140 modelingShell.md(
141 nStep, timeStep, printInterval, saveInterval, temperature, initVelocities, dyn);
142 origSys.ifPresent(this::switchBack);
143 }
144
145 @Override
146 public Potential minimize(MolecularAssembly assembly, double eps) {
147 Optional<FFXSystem> origSys = switchTo(assembly);
148 Potential pot = modelingShell.minimize(eps);
149
150 origSys.ifPresent(this::switchBack);
151 return pot;
152 }
153
154 @Override
155 public FFXSystem[] open(String[] files, int nThreads) {
156 FFXSystem[] systems = mainPanel.openWait(files, nThreads);
157 lastFilter = mainPanel.getFilter();
158 return systems;
159 }
160
161 @Override
162 public FFXSystem open(String file) {
163 FFXSystem[] systems = mainPanel.openWait(file);
164 lastFilter = mainPanel.getFilter();
165 if (systems == null) {
166 return null;
167 }
168 return systems[0];
169 }
170
171 @Override
172 public FFXSystem[] openAll(String file) {
173 FFXSystem[] systems = mainPanel.openWait(file);
174 lastFilter = mainPanel.getFilter();
175 return systems;
176 }
177
178 @Override
179 public FFXSystem[] openAll(String[] files) {
180 FFXSystem[] systems = mainPanel.openWait(files);
181 lastFilter = mainPanel.getFilter();
182 return systems;
183 }
184
185 @Override
186 public FFXSystem[] openAll(String file, int nThreads) {
187 FFXSystem[] systems = mainPanel.openWait(file, nThreads);
188 lastFilter = mainPanel.getFilter();
189 return systems;
190 }
191
192
193
194
195
196
197
198
199
200 @Override
201 public MolecularAssembly openWithMutations(File file, List<Mutation> mutations) {
202 file = new File(FilenameUtils.normalize(file.getAbsolutePath()));
203
204 mainPanel.setCWD(file.getParentFile());
205
206
207 CompositeConfiguration properties = Keyword.loadProperties(file);
208
209 FFXSystem newSystem = new FFXSystem(file, "Open with mutations", properties);
210
211 ForceFieldFilter forceFieldFilter = new ForceFieldFilter(properties);
212 ForceField forceField = forceFieldFilter.parse();
213 String[] patches = properties.getStringArray("patch");
214 for (String patch : patches) {
215 logger.info(" Attempting to read force field patch from " + patch + ".");
216 CompositeConfiguration patchConfiguration = new CompositeConfiguration();
217 patchConfiguration.addProperty("parameters", patch);
218 forceFieldFilter = new ForceFieldFilter(patchConfiguration);
219 ForceField patchForceField = forceFieldFilter.parse();
220 forceField.append(patchForceField);
221 if (RotamerLibrary.addRotPatch(patch)) {
222 logger.info(format(" Loaded rotamer definitions from patch %s.", patch));
223 }
224 }
225 newSystem.setForceField(forceField);
226
227 PDBFilter pdbFilter = new PDBFilter(file, newSystem, forceField, properties);
228 pdbFilter.mutate(mutations);
229 UIFileOpener opener = new UIFileOpener(pdbFilter, mainPanel);
230 opener.run();
231 lastFilter = pdbFilter;
232 if (opener.getAllAssemblies().length > 1) {
233 logger.log(
234 Level.WARNING, "Found multiple assemblies in file {0}, opening first.", file.getName());
235 }
236 return opener.getAssembly();
237 }
238
239 @Override
240 public double returnEnergy(MolecularAssembly assembly) {
241 Optional<FFXSystem> origSys = switchTo(assembly);
242 double e = modelingShell.returnEnergy();
243 origSys.ifPresent(this::switchBack);
244 return e;
245 }
246
247 @Override
248 public void save(MolecularAssembly assembly, File file) {
249 saveAsXYZ(assembly, file);
250 }
251
252 @Override
253 public void saveAsXYZinP1(MolecularAssembly assembly, File file) {
254 Optional<FFXSystem> origSys = switchTo(assembly);
255 mainPanel.saveAsP1(file);
256 lastFilter = mainPanel.getFilter();
257 origSys.ifPresent(this::switchBack);
258 }
259
260 @Override
261 public void saveAsPDB(MolecularAssembly assembly, File file) {
262 Optional<FFXSystem> origSys = switchTo(assembly);
263 mainPanel.saveAsPDB(file);
264 lastFilter = mainPanel.getFilter();
265 origSys.ifPresent(this::switchBack);
266 }
267
268 @Override
269 public void saveAsPDB(MolecularAssembly assembly, File file, boolean writeEnd, boolean append) {
270 Optional<FFXSystem> origSys = switchTo(assembly);
271 mainPanel.saveAsPDB(file, false, append);
272 lastFilter = mainPanel.getFilter();
273 origSys.ifPresent(this::switchBack);
274 }
275
276 @Override
277 public void saveAsPDB(MolecularAssembly[] assemblies, File file) {
278 mainPanel.saveAsPDB(assemblies, file);
279 lastFilter = mainPanel.getFilter();
280 }
281
282 @Override
283 public void saveAsXYZ(MolecularAssembly assembly, File file) {
284 Optional<FFXSystem> origSys = switchTo(assembly);
285 mainPanel.saveAsXYZ(file);
286 lastFilter = mainPanel.getFilter();
287 origSys.ifPresent(this::switchBack);
288 }
289
290 @Override
291 public void saveAsPDBinP1(MolecularAssembly assembly, File file) {
292 Optional<FFXSystem> origSys = switchTo(assembly);
293 mainPanel.savePDBasP1(file);
294 lastFilter = mainPanel.getFilter();
295 origSys.ifPresent(this::switchBack);
296 }
297
298 @Override
299 public double time() {
300 return modelingShell.time();
301 }
302
303
304
305
306
307
308
309
310
311 private Optional<FFXSystem> switchTo(MolecularAssembly assembly) {
312 Optional<FFXSystem> origSystem;
313 if (!(assembly instanceof FFXSystem)) {
314 origSystem = Optional.empty();
315 return origSystem;
316 }
317
318 Hierarchy hierarchy = mainPanel.getHierarchy();
319 FFXSystem activeSys = hierarchy.getActive();
320 FFXSystem assemblySys = (FFXSystem) assembly;
321
322 for (FFXSystem sys : hierarchy.getSystems()) {
323 if (sys == assemblySys) {
324 origSystem = Optional.of(activeSys);
325 hierarchy.setActive(assemblySys);
326 return origSystem;
327 }
328 }
329
330 origSystem = Optional.empty();
331 return origSystem;
332 }
333
334
335
336
337
338
339 private void switchBack(FFXSystem origSystem) {
340 if (origSystem != null) {
341 Hierarchy hierarchy = mainPanel.getHierarchy();
342 hierarchy.setActive(origSystem);
343 }
344 }
345 }