1 /////////////////////////////////////////////////////////////////////////////
2 // Name: inputbuilder.cpp
3 // Purpose:
4 // Author: Brett Bode
5 // Modified by:
6 // Created: Mon 12 Jun 2006 09:37:31 AM CDT
7 // RCS-ID:
8 // Copyright: (c) 2006 Iowa State University
9 // Licence:
10 /////////////////////////////////////////////////////////////////////////////
11
12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
13 #pragma implementation "inputbuilder.h"
14 #endif
15 #include "Globals.h"
16
17 // For compilers that support precompilation, includes "wx/wx.h".
18 #include "wx/wxprec.h"
19
20 #ifdef __BORLANDC__
21 #pragma hdrstop
22 #endif
23
24 #ifndef WX_PRECOMP
25 #include "wx/wx.h"
26 #endif
27 #include <wx/listctrl.h>
28 #include <wx/listbook.h>
29 #include <wx/filename.h>
30
31 ////@begin includes
32 #include "wx/imaglist.h"
33 ////@end includes
34
35 #include "MolDisplayWin.h"
36 #include "AtomTypeList.h"
37 #include "inputbuilder.h"
38 #include "Frame.h"
39 #include "fmofragmentationdialog.h"
40 #include <sstream>
41
42 ////@begin XPM images
43 ////@end XPM images
44
45 /*!
46 * InputBuilderWindow type definition
47 */
48
IMPLEMENT_CLASS(InputBuilderWindow,wxFrame)49 IMPLEMENT_CLASS( InputBuilderWindow, wxFrame )
50
51 /*!
52 * InputBuilderWindow event table definition
53 */
54
55 BEGIN_EVENT_TABLE( InputBuilderWindow, wxFrame )
56
57 ////@begin InputBuilderWindow event table entries
58 EVT_CLOSE( InputBuilderWindow::OnCloseWindow )
59 EVT_LISTBOOK_PAGE_CHANGED( ID_IBNOTEBOOK, InputBuilderWindow::OnIblistbookPageChanged )
60 EVT_CHOICE( ID_BASIS_CHOICE, InputBuilderWindow::OnBasisChoiceSelected )
61 EVT_CHOICE( ID_ECPT_CHOICE, InputBuilderWindow::OnEcptChoiceSelected )
62 EVT_CHOICE( ID_NUMD_CHOICE, InputBuilderWindow::OnNumdChoiceSelected )
63 EVT_CHOICE( ID_NUMF_CHOICE, InputBuilderWindow::OnNumfChoiceSelected )
64 EVT_CHOICE( ID_NUMP_CHOICE, InputBuilderWindow::OnNumpChoiceSelected )
65 EVT_CHOICE( ID_POLAR_CHOICE, InputBuilderWindow::OnPolarChoiceSelected )
66 EVT_CHECKBOX( ID_DIFFL_CHECKBOX, InputBuilderWindow::OnDifflCheckboxClick )
67 EVT_CHECKBOX( ID_DIFFS_CHECKBOX, InputBuilderWindow::OnDiffsCheckboxClick )
68 EVT_CHECKBOX( ID_SPHERE_CHECK, InputBuilderWindow::OnSphereCheckClick )
69 EVT_CHOICE( ID_RUN_CHOICE, InputBuilderWindow::OnRunChoiceSelected )
70 EVT_CHOICE( ID_SCF_CHOICE, InputBuilderWindow::OnScfChoiceSelected )
71 EVT_CHOICE( ID_LOCAL_CHOICE, InputBuilderWindow::OnLocalChoiceSelected )
72 EVT_TEXT( ID_MCHARGE_TEXTCTRL, InputBuilderWindow::OnMchargeTextctrlUpdated )
73 EVT_TEXT( ID_MULT_TEXTCTRL, InputBuilderWindow::OnMultTextctrlUpdated )
74 EVT_CHOICE( ID_EXE_CHOICE, InputBuilderWindow::OnExeChoiceSelected )
75 EVT_TEXT( ID_MAXIT_TEXTCTRL, InputBuilderWindow::OnMaxitTextctrlUpdated )
76 EVT_CHECKBOX( ID_MP2_CHECKBOX, InputBuilderWindow::OnMp2CheckboxClick )
77 EVT_CHECKBOX( ID_DFT_CHECKBOX, InputBuilderWindow::OnDftCheckboxClick )
78 EVT_CHOICE( ID_CI_CHOICE, InputBuilderWindow::OnCiChoiceSelected )
79 EVT_CHOICE( ID_CC_CHOICE, InputBuilderWindow::OnCcChoiceSelected )
80 EVT_TEXT( ID_TITLE_TEXTCTRL, InputBuilderWindow::OnTitleTextctrlUpdated )
81 EVT_CHOICE( ID_COORD_CHOICE, InputBuilderWindow::OnCoordChoiceSelected )
82 EVT_CHOICE( ID_UNIT_CHOICE, InputBuilderWindow::OnUnitChoiceSelected )
83 EVT_TEXT( ID_ZMAT_VARS_TEXT, InputBuilderWindow::OnZmatVarsTextUpdated )
84 EVT_CHOICE( ID_POINTGROUP_CHOICE, InputBuilderWindow::OnPointgroupChoiceSelected )
85 EVT_CHOICE( ID_ORDER_CHOICE, InputBuilderWindow::OnOrderChoiceSelected )
86 EVT_CHECKBOX( ID_SYMMETRY_CHECKBOX, InputBuilderWindow::OnSymmetryCheckboxClick )
87 EVT_TEXT( ID_TIMELIMIT_TEXT, InputBuilderWindow::OnTimelimitTextUpdated )
88 EVT_CHOICE( ID_TIMELIMITUNITS_CHOICE, InputBuilderWindow::OnTimelimitunitsChoiceSelected )
89 EVT_TEXT( ID_MEMORY_TEXT, InputBuilderWindow::OnMemoryTextUpdated )
90 EVT_CHOICE( ID_MEMORYUNITS_CHOICE, InputBuilderWindow::OnMemoryunitsChoiceSelected )
91 EVT_TEXT( ID_MEMDDI_EDIT, InputBuilderWindow::OnMemddiEditUpdated )
92 EVT_CHOICE( ID_MEMDDICHOICE, InputBuilderWindow::OnMemddichoiceSelected )
93 EVT_CHOICE( ID_DIAGONALIZATION_CHOICE, InputBuilderWindow::OnDiagonalizationChoiceSelected )
94 EVT_CHECKBOX( ID_CORE_CHECKBOX, InputBuilderWindow::OnCoreCheckboxClick )
95 EVT_RADIOBOX( ID_PLBALANCE_RADIOBOX, InputBuilderWindow::OnPlbalanceRadioboxSelected )
96 EVT_CHECKBOX( ID_EXTERNDATAREP_CHECKBOX, InputBuilderWindow::OnExterndatarepCheckboxClick )
97 EVT_CHECKBOX( ID_PARALL_CHECK, InputBuilderWindow::OnParallCheckClick )
98 EVT_TEXT( ID_GVB_NCOEDIT, InputBuilderWindow::OnGVBNCOEditTextUpdated )
99 EVT_TEXT( ID_GVB_PAIRSEDIT, InputBuilderWindow::OnGVBPairsEditTextUpdated )
100 EVT_TEXT( ID_GVB_NSETOEDIT, InputBuilderWindow::OnGVBNSetOeditTextUpdated )
101 EVT_TEXT( ID_GVB_NOEDIT, InputBuilderWindow::OnGVBNOeditTextUpdated )
102 EVT_CHOICE( ID_DFTMETHOD_CHOICE, InputBuilderWindow::OnDftmethodChoiceSelected )
103 EVT_CHOICE( ID_GRID_FUNCTIONAL_CHOICE, InputBuilderWindow::OnGridFunctionalChoiceSelected )
104 EVT_CHOICE( ID_GRIDFREE_FUNCTIONAL_CHOICE, InputBuilderWindow::OnGridfreeFunctionalChoiceSelected )
105 EVT_CHECKBOX( ID_FMOACTIVECHECK, InputBuilderWindow::OnFMOActiveCheckClick )
106 EVT_TEXT( ID_FMOFRAGCOUNT, InputBuilderWindow::OnFMOFragCountTextUpdated )
107 #if wxCHECK_VERSION(3, 0, 0)
108 EVT_GRID_CELL_CHANGED( InputBuilderWindow::OnFMOFragIdCellChange )
109 #else
110 EVT_GRID_CELL_CHANGE( InputBuilderWindow::OnFMOFragIdCellChange )
111 #endif
112 EVT_BUTTON( ID_FMOFRAGBUTTON, InputBuilderWindow::OnFMOFragButtonClick )
113 EVT_CHOICE( ID_INITGUESS_CHOICE, InputBuilderWindow::OnInitguessChoiceSelected )
114 EVT_CHOICE( ID_MOGUESS_VECSOURCE_CHOICE, InputBuilderWindow::OnMoguessVecsourceChoiceSelected )
115 EVT_TEXT( ID_MOGUESS_VECORBCOUNT_TEXT, InputBuilderWindow::OnMoguessVecorbcountTextUpdated )
116 EVT_CHECKBOX( ID_PRINTINITGUESS_CHECKBOX, InputBuilderWindow::OnPrintinitguessCheckboxClick )
117 EVT_CHECKBOX( ID_ROTORBITALS_CHECKBOX, InputBuilderWindow::OnRotorbitalsCheckboxClick )
118 EVT_RADIOBOX( ID_HESSMETHOD_RADIO, InputBuilderWindow::OnHessmethodRadioSelected )
119 EVT_TEXT( ID_FORCEDISPLACE_EDIT, InputBuilderWindow::OnForcedisplaceEditUpdated )
120 EVT_CHECKBOX( ID_HESSDOUBLEDIFFCHECK, InputBuilderWindow::OnHessdoublediffcheckClick )
121 EVT_CHECKBOX( ID_HESSPURIFYCHECK, InputBuilderWindow::OnHesspurifycheckClick )
122 EVT_CHECKBOX( ID_HESSPRTINTFC_CHECK, InputBuilderWindow::OnHessprtintfcCheckClick )
123 EVT_CHECKBOX( ID_HESSVIBANL_CHECK, InputBuilderWindow::OnHessvibanlCheckClick )
124 EVT_TEXT( ID_HESSFREQSCALE_EDIT, InputBuilderWindow::OnHessfreqscaleEditUpdated )
125 EVT_CHECKBOX( ID_MOLPLT_CHECK, InputBuilderWindow::OnMolpltCheckClick )
126 EVT_CHECKBOX( ID_PLTORB_CHECK, InputBuilderWindow::OnPltorbCheckClick )
127 EVT_CHECKBOX( ID_AIMPAC_CHECK, InputBuilderWindow::OnAimpacCheckClick )
128 EVT_CHECKBOX( ID_RPAC_CHECK, InputBuilderWindow::OnRpacCheckClick )
129 EVT_RADIOBOX( ID_MISC_PROG_RADIO, InputBuilderWindow::OnMiscProgRadioSelected )
130 EVT_TEXT( ID_MP2_CORE_EDIT, InputBuilderWindow::OnMp2CoreEditUpdated )
131 EVT_TEXT( ID_MP2MEM_EDIT, InputBuilderWindow::OnMp2memEditUpdated )
132 EVT_TEXT( ID_MP2INTCUTOFF_EDIT, InputBuilderWindow::OnMp2intcutoffEditUpdated )
133 EVT_CHECKBOX( ID_LMOMP2_CHECK, InputBuilderWindow::OnLmomp2CheckClick )
134 EVT_CHECKBOX( ID_MP2PROP_CHECK, InputBuilderWindow::OnMp2propCheckClick )
135 EVT_RADIOBOX( ID_MP2TRANS_RADIO, InputBuilderWindow::OnMp2transRadioSelected )
136 EVT_RADIOBOX( ID_MP2AOSTORAGE_RADIO, InputBuilderWindow::OnMp2aostorageRadioSelected )
137 EVT_CHECKBOX( ID_DIRECTSCF_CHECK, InputBuilderWindow::OnDirectscfCheckClick )
138 EVT_CHECKBOX( ID_FDIFF_CHECK, InputBuilderWindow::OnFdiffCheckClick )
139 EVT_CHECKBOX( ID_UHF_NO_CHECK, InputBuilderWindow::OnUhfNoCheckClick )
140 EVT_SPINCTRL( ID_SCF_CONV_SPIN, InputBuilderWindow::OnScfConvSpinUpdated )
141 EVT_TEXT( ID_MAXSTEPCOUNT_EDIT, InputBuilderWindow::OnMaxstepcountEditUpdated )
142 EVT_TEXT( ID_GRADCONVCRITERIA_EDIT, InputBuilderWindow::OnGradconvcriteriaEditUpdated )
143 EVT_CHOICE( ID_OPTMETHOD_CHOICE, InputBuilderWindow::OnOptmethodChoiceSelected )
144 EVT_TEXT( ID_INITSTEPSIZE_EDIT, InputBuilderWindow::OnInitstepsizeEditUpdated )
145 EVT_TEXT( ID_MINSTEPSIZE_EDIT, InputBuilderWindow::OnMinstepsizeEditUpdated )
146 EVT_TEXT( ID_MAXSTEPSIZE_CHECK, InputBuilderWindow::OnMaxstepsizeEditUpdated )
147 EVT_CHECKBOX( ID_UPDATESTEPSIZE_CHECK, InputBuilderWindow::OnUpdatestepsizeCheckClick )
148 EVT_CHECKBOX( ID_STATPT_CHECK, InputBuilderWindow::OnStatptCheckClick )
149 EVT_TEXT( ID_STATPT_JUMP_EDIT, InputBuilderWindow::OnStatptJumpEditUpdated )
150 EVT_RADIOBOX( ID_INIT_HESS_RADIO, InputBuilderWindow::OnInitHessRadioSelected )
151 EVT_TEXT( ID_HESS_RECALC_EDIT, InputBuilderWindow::OnHessRecalcEditUpdated )
152 EVT_TEXT( ID_STATPT_MODE_EDIT, InputBuilderWindow::OnStatptModeEditUpdated )
153 EVT_CHECKBOX( ID_PRINTORBS_CHECK, InputBuilderWindow::OnPrintorbsCheckClick )
154 EVT_CHECKBOX( ID_HESSEND_CHECK, InputBuilderWindow::OnHessendCheckClick )
155 EVT_BUTTON( ID_DEFAULTSBUTTON, InputBuilderWindow::OnDefaultsbuttonClick )
156 EVT_BUTTON( ID_REVERTBUTTON, InputBuilderWindow::OnRevertbuttonClick )
157 EVT_BUTTON( ID_WRITEFILEBUTTON, InputBuilderWindow::OnWritefilebuttonClick )
158 EVT_BUTTON( ID_WRITE_EDIT_BUTTON, InputBuilderWindow::OnWriteEditButtonClick )
159
160 EVT_BUTTON( ID_ADVANCEDBUTTON, InputBuilderWindow::OnAdvancedButtonClicked )
161 EVT_BUTTON( wxID_CANCEL, InputBuilderWindow::OnCancelClick )
162 EVT_BUTTON( wxID_OK, InputBuilderWindow::OnOkClick )
163 ////@end InputBuilderWindow event table entries
164 EVT_ACTIVATE(InputBuilderWindow::OnActivate)
165 EVT_BUTTON( ID_ENQUEUEBUTTON, InputBuilderWindow::OnEnqueueButtonClick )
166 END_EVENT_TABLE()
167
168 /*!
169 * InputBuilderWindow constructors
170 */
171
172 InputBuilderWindow::InputBuilderWindow( )
173 {
174 }
175
InputBuilderWindow(wxWindow * parent,wxWindowID id,const wxString & caption,const wxPoint & pos,const wxSize & size,long style)176 InputBuilderWindow::InputBuilderWindow( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
177 {
178 Create( parent, id, caption, pos, size, style );
179 }
180
~InputBuilderWindow()181 InputBuilderWindow::~InputBuilderWindow() {
182 delete TmpInputRec;
183 }
184
185 /*!
186 * InputBuilder creator
187 */
188
Create(wxWindow * parent,wxWindowID id,const wxString & caption,const wxPoint & pos,const wxSize & size,long style)189 bool InputBuilderWindow::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
190 {
191 ////@begin InputBuilderWindow member initialisation
192 listBook = NULL;
193 basisChoice = NULL;
194 ecpTypeLabel = NULL;
195 ecpTypeChoice = NULL;
196 numDChoice = NULL;
197 numFChoice = NULL;
198 numPChoice = NULL;
199 polarLabel = NULL;
200 polarChoice = NULL;
201 diffuseLCheck = NULL;
202 diffuseSCheck = NULL;
203 spherHarmCheck = NULL;
204 runChoice = NULL;
205 scfChoice = NULL;
206 localChoice = NULL;
207 mchargeText = NULL;
208 multText = NULL;
209 exeChoice = NULL;
210 scfIterText = NULL;
211 mp2Check = NULL;
212 dftCheck = NULL;
213 ciLabel = NULL;
214 ciChoice = NULL;
215 ccLabel = NULL;
216 ccChoice = NULL;
217 titleText = NULL;
218 coordTypeChoice = NULL;
219 unitChoice = NULL;
220 zmatrixVarsText = NULL;
221 pointGroupChoice = NULL;
222 paxisOrderText = NULL;
223 paxisOrderChoice = NULL;
224 symmetryCheck = NULL;
225 timeLimitText = NULL;
226 timeLimitUnitChoice = NULL;
227 memoryText = NULL;
228 memoryUnitChoice = NULL;
229 memddiText = NULL;
230 memddiUnitChoice = NULL;
231 diagChoice = NULL;
232 coreCheck = NULL;
233 plBalanceRadio = NULL;
234 externDataRepCheck = NULL;
235 mSGParallCheck = NULL;
236 mGVB_NCOEdit = NULL;
237 mGVB_PairsEdit = NULL;
238 mGVB_NSETOEdit = NULL;
239 mGVB_NOStatic = NULL;
240 mGVB_NOEdit = NULL;
241 dftMethodChoice = NULL;
242 funcSizer = NULL;
243 dftGridFuncChoice = NULL;
244 dftGridFreeFuncChoice = NULL;
245 mFMOCheck = NULL;
246 mNumFragsEdit = NULL;
247 mFMOFragList = NULL;
248 mFMOGenFragsButton = NULL;
249 initGuessChoice = NULL;
250 mMOSourceChoice = NULL;
251 mVecOrbCountText = NULL;
252 printInitGuessCheck = NULL;
253 rotOrbitalsCheck = NULL;
254 mHessMethodRadio = NULL;
255 mHESSDisplaceEdit = NULL;
256 mHessDblDiffCheck = NULL;
257 mHessPurifyCheck = NULL;
258 mHessPrintIntFCCheck = NULL;
259 mHessVibAnlCheck = NULL;
260 mHessFreqScaleEdit = NULL;
261 mMolPltCheck = NULL;
262 mPltOrbCheck = NULL;
263 aimpacCheck = NULL;
264 rpacCheck = NULL;
265 mMiscProgRadio = NULL;
266 mMP2CoreEleEdit = NULL;
267 mMP2MemEdit = NULL;
268 mMP2IntCutoffEdit = NULL;
269 mLMOMP2Check = NULL;
270 mMP2PropCheck = NULL;
271 mMP2TransRadio = NULL;
272 mMP2AOStorageRadio = NULL;
273 mDirectSCFCheck = NULL;
274 mFDiffCheck = NULL;
275 mUHFNOCheck = NULL;
276 mSCFConvSpin = NULL;
277 mMaxStepCountEdit = NULL;
278 mGradConvEdit = NULL;
279 mOptMethodChoice = NULL;
280 mInitStepSizeEdit = NULL;
281 mMinStepSizeEdit = NULL;
282 mMaxStepSizeEdit = NULL;
283 mUpdateStepSizeCheck = NULL;
284 mIsStatPtCheck = NULL;
285 mStatPtJumpSizeEdit = NULL;
286 mInitHessRadio = NULL;
287 mHessRecalcEdit = NULL;
288 mStatPtModeEdit = NULL;
289 mPrintOrbsCheck = NULL;
290 mTitleText = NULL;
291 mBasisSetText = NULL;
292 mSCFTypeText = NULL;
293 mRunTypeText = NULL;
294 mPointGroupText = NULL;
295 mElectronCorr = NULL;
296 defaultsBtn = NULL;
297 revertBtn = NULL;
298 writeBtn = NULL;
299 advanced_button = NULL;
300 ////@end InputBuilderWindow member initialisation
301
302 TmpInputRec = new InputData(((MolDisplayWin *)parent)->GetData()->GetInputData());
303 MoleculeData * MainData = ((MolDisplayWin *)parent)->GetData();
304 if (MainData->GetFMOFragmentId(0)>0) { //copy them over if setup
305 Frame * cFrame = MainData->GetCurrentFramePtr();
306 FMOFragmentIds.reserve(cFrame->GetNumAtoms());
307 for (long i=0; i<cFrame->GetNumAtoms(); i++) {
308 FMOFragmentIds.push_back(MainData->GetFMOFragmentId(i));
309 }
310 }
311
312 ////@begin InputBuilderWindow creation
313 wxFrame::Create( parent, id, caption, pos, size, style );
314
315 CreateControls();
316 if (GetSizer())
317 {
318 GetSizer()->SetSizeHints(this);
319 }
320 Centre();
321 ////@end InputBuilderWindow creation
322 UpdateWindowTitle();
323
324 SetupItems();
325
326 return true;
327 }
328
329 /*!
330 * Update the Window title in the event the file is saved
331 */
UpdateWindowTitle(void)332 void InputBuilderWindow::UpdateWindowTitle(void) {
333 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
334 wxString foo = parent->GetTitle();
335 foo += wxString(_(" ")) + wxString(SYMBOL_INPUTBUILDERWINDOW_TITLE);
336 SetTitle(foo);
337 }
338
339 /*!
340 * Control creation for InputBuilder
341 */
342
CreateControls()343 void InputBuilderWindow::CreateControls()
344 {
345
346 // visibleTab has to be initialized before any calls AddPage(), since
347 // page change events will be triggered that read visibleTab.
348 for(int i = NUM_PANES - 1; i >= 0; i--) {
349 visibleTab[i] = true;
350 }
351
352 ////@begin InputBuilderWindow content construction
353 InputBuilderWindow* itemFrame1 = this;
354
355 wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);
356 itemFrame1->SetSizer(itemBoxSizer2);
357
358 wxPanel* itemPanel3 = new wxPanel( itemFrame1, ID_PANEL6, wxDefaultPosition, wxDefaultSize, wxNO_BORDER|wxTAB_TRAVERSAL );
359 itemBoxSizer2->Add(itemPanel3, 1, wxGROW, 0);
360
361 wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxVERTICAL);
362 itemPanel3->SetSizer(itemBoxSizer4);
363
364 listBook = new wxListbook( itemPanel3, ID_IBNOTEBOOK, wxDefaultPosition, wxDefaultSize, wxLB_DEFAULT|wxLB_LEFT|wxSUNKEN_BORDER );
365
366 wxPanel* itemPanel6 = new wxPanel( listBook, ID_IBBASISPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
367 wxBoxSizer* itemBoxSizer7 = new wxBoxSizer(wxVERTICAL);
368 itemPanel6->SetSizer(itemBoxSizer7);
369
370 wxBoxSizer* itemBoxSizer8 = new wxBoxSizer(wxHORIZONTAL);
371 itemBoxSizer7->Add(itemBoxSizer8, 0, wxGROW, 5);
372 wxStaticText* itemStaticText9 = new wxStaticText( itemPanel6, wxID_STATIC, _("Basis Set:"), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT );
373 itemBoxSizer8->Add(itemStaticText9, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
374
375 wxArrayString basisChoiceStrings;
376 basisChoiceStrings.Add(_("MINI"));
377 basisChoiceStrings.Add(_("MIDI"));
378 basisChoiceStrings.Add(_("STO-2G"));
379 basisChoiceStrings.Add(_("STO-3G"));
380 basisChoiceStrings.Add(_("STO-4G"));
381 basisChoiceStrings.Add(_("STO-5G"));
382 basisChoiceStrings.Add(_("STO-6G"));
383 basisChoiceStrings.Add(_("3-21G"));
384 basisChoiceStrings.Add(_("6-21G"));
385 basisChoiceStrings.Add(_("4-31G"));
386 basisChoiceStrings.Add(_("5-31G"));
387 basisChoiceStrings.Add(_("6-31G"));
388 basisChoiceStrings.Add(_("6-311G"));
389 basisChoiceStrings.Add(_("Double Zeta Valance"));
390 basisChoiceStrings.Add(_("Dunning/Hay DZ"));
391 basisChoiceStrings.Add(_("Triple Zeta Valence"));
392 basisChoiceStrings.Add(_("McLean/Chandler"));
393 basisChoiceStrings.Add(wxEmptyString);
394 basisChoiceStrings.Add(_("Dunning cc-pVDZ"));
395 basisChoiceStrings.Add(_("Dunning cc-pVTZ"));
396 basisChoiceStrings.Add(_("Dunning cc-pVQZ"));
397 basisChoiceStrings.Add(_("Dunning cc-pV5Z"));
398 basisChoiceStrings.Add(_("Dunning cc-pV6Z"));
399 basisChoiceStrings.Add(_("Dunning aug-cc-pVDZ"));
400 basisChoiceStrings.Add(_("Dunning aug-cc-pVTZ"));
401 basisChoiceStrings.Add(_("Dunning aug-cc-pVQZ"));
402 basisChoiceStrings.Add(_("Dunning aug-cc-pV5Z"));
403 basisChoiceStrings.Add(_("Dunning aug-cc-pV6Z"));
404 basisChoiceStrings.Add(_("Dunning cc-pCVDZ"));
405 basisChoiceStrings.Add(_("Dunning cc-pCVTZ"));
406 basisChoiceStrings.Add(_("Dunning cc-pCVQZ"));
407 basisChoiceStrings.Add(_("Dunning cc-pCV5Z"));
408 basisChoiceStrings.Add(_("Dunning cc-pCV6Z"));
409 basisChoiceStrings.Add(_("Dunning aug-cc-pCVDZ"));
410 basisChoiceStrings.Add(_("Dunning aug-cc-pCVTZ"));
411 basisChoiceStrings.Add(_("Dunning aug-cc-pCVQZ"));
412 basisChoiceStrings.Add(_("Dunning aug-cc-pCV5Z"));
413 basisChoiceStrings.Add(_("Dunning aug-cc-pCV6Z"));
414 basisChoiceStrings.Add(_("Jensen PC0"));
415 basisChoiceStrings.Add(_("Jensen PC1"));
416 basisChoiceStrings.Add(_("Jensen PC2"));
417 basisChoiceStrings.Add(_("Jensen PC3"));
418 basisChoiceStrings.Add(_("Jensen PC4"));
419 basisChoiceStrings.Add(_("Jensen aug-PC0"));
420 basisChoiceStrings.Add(_("Jensen aug-PC1"));
421 basisChoiceStrings.Add(_("Jensen aug-PC2"));
422 basisChoiceStrings.Add(_("Jensen aug-PC3"));
423 basisChoiceStrings.Add(_("Jensen aug-PC4"));
424 basisChoiceStrings.Add(_("Sapporo non-relativistic SPK-DZP"));
425 basisChoiceStrings.Add(_("Sapporo non-relativistic SPK-TZP"));
426 basisChoiceStrings.Add(_("Sapporo non-relativistic SPK-QZP"));
427 basisChoiceStrings.Add(_("Sapporo non-relativistic SPK-ADZP"));
428 basisChoiceStrings.Add(_("Sapporo non-relativistic SPK-ATZP"));
429 basisChoiceStrings.Add(_("Sapporo non-relativistic SPK-AQZP"));
430 basisChoiceStrings.Add(_("Sapporo relativistic SPKrDZP"));
431 basisChoiceStrings.Add(_("Sapporo relativistic SPKrTZP"));
432 basisChoiceStrings.Add(_("Sapporo relativistic SPKrQZP"));
433 basisChoiceStrings.Add(_("Sapporo relativistic SPKrADZP"));
434 basisChoiceStrings.Add(_("Sapporo relativistic SPKrATZP"));
435 basisChoiceStrings.Add(_("Sapporo relativistic SPKrAQZP"));
436 basisChoiceStrings.Add(_("Karlsruhe valence triple zeta KTZV"));
437 basisChoiceStrings.Add(_("Karlsruhe valence triple zeta KTZVP"));
438 basisChoiceStrings.Add(_("Karlsruhe valence triple zeta KTZVPP"));
439 basisChoiceStrings.Add(wxEmptyString);
440 basisChoiceStrings.Add(_("SBKJC Valance"));
441 basisChoiceStrings.Add(_("Hay/Wadt Valance"));
442 basisChoiceStrings.Add(wxEmptyString);
443 basisChoiceStrings.Add(_("MCP-DZP"));
444 basisChoiceStrings.Add(_("MCP-TZP"));
445 basisChoiceStrings.Add(_("MCP-QZP"));
446 basisChoiceStrings.Add(_("MCP-ATZP"));
447 basisChoiceStrings.Add(_("MCP-AQZP"));
448 basisChoiceStrings.Add(_("MCPCDZP"));
449 basisChoiceStrings.Add(_("MCPCTZP"));
450 basisChoiceStrings.Add(_("MCPCQZP"));
451 basisChoiceStrings.Add(_("MCPCADZP"));
452 basisChoiceStrings.Add(_("MCPCATZP"));
453 basisChoiceStrings.Add(_("MCPCAQZP"));
454 basisChoiceStrings.Add(_("IMCP-SR1"));
455 basisChoiceStrings.Add(_("IMCP-SR2"));
456 basisChoiceStrings.Add(_("IMCP-NR1"));
457 basisChoiceStrings.Add(_("IMCP-NR2"));
458 basisChoiceStrings.Add(_("ZFK3-DK3"));
459 basisChoiceStrings.Add(_("ZFK4-DK3"));
460 basisChoiceStrings.Add(_("ZFK5-DK3"));
461 basisChoiceStrings.Add(_("ZFK3LDK3"));
462 basisChoiceStrings.Add(_("ZFK4LDK3"));
463 basisChoiceStrings.Add(_("ZFK5LDK3"));
464 basisChoiceStrings.Add(wxEmptyString);
465 basisChoiceStrings.Add(_("MNDO"));
466 basisChoiceStrings.Add(_("AM1"));
467 basisChoiceStrings.Add(_("PM3"));
468 basisChoiceStrings.Add(_("RM1"));
469 basisChoice = new wxUglyChoice( itemPanel6, ID_BASIS_CHOICE, wxDefaultPosition, wxSize(200, -1), basisChoiceStrings, 0 );
470 basisChoice->SetStringSelection(_("MINI"));
471 itemBoxSizer8->Add(basisChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
472
473 itemBoxSizer8->Add(5, 5, 0, wxGROW|wxALL, 5);
474
475 ecpTypeLabel = new wxStaticText( itemPanel6, wxID_STATIC, _("ECP Type:"), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT );
476 ecpTypeLabel->Enable(false);
477 itemBoxSizer8->Add(ecpTypeLabel, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
478
479 wxArrayString ecpTypeChoiceStrings;
480 ecpTypeChoiceStrings.Add(_("None"));
481 ecpTypeChoiceStrings.Add(_("Read"));
482 ecpTypeChoiceStrings.Add(_("SBKJC"));
483 ecpTypeChoiceStrings.Add(_("Hay-Wadt"));
484 ecpTypeChoice = new wxUglyChoice( itemPanel6, ID_ECPT_CHOICE, wxDefaultPosition, wxDefaultSize, ecpTypeChoiceStrings, 0 );
485 ecpTypeChoice->SetStringSelection(_("None"));
486 ecpTypeChoice->Enable(false);
487 itemBoxSizer8->Add(ecpTypeChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
488
489 wxFlexGridSizer* itemFlexGridSizer14 = new wxFlexGridSizer(0, 2, 0, 0);
490 itemBoxSizer7->Add(itemFlexGridSizer14, 0, wxGROW, 5);
491 wxStaticText* itemStaticText15 = new wxStaticText( itemPanel6, wxID_STATIC, _("# D heavy atom polarization functions:"), wxDefaultPosition, wxDefaultSize, 0 );
492 itemFlexGridSizer14->Add(itemStaticText15, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
493
494 wxArrayString numDChoiceStrings;
495 numDChoiceStrings.Add(_("0"));
496 numDChoiceStrings.Add(_("1"));
497 numDChoiceStrings.Add(_("2"));
498 numDChoiceStrings.Add(_("3"));
499 numDChoice = new wxUglyChoice( itemPanel6, ID_NUMD_CHOICE, wxDefaultPosition, wxDefaultSize, numDChoiceStrings, 0 );
500 numDChoice->SetStringSelection(_("0"));
501 itemFlexGridSizer14->Add(numDChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
502
503 wxStaticText* itemStaticText17 = new wxStaticText( itemPanel6, wxID_STATIC, _("# F heavy atom polarization functions:"), wxDefaultPosition, wxDefaultSize, 0 );
504 itemFlexGridSizer14->Add(itemStaticText17, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
505
506 wxArrayString numFChoiceStrings;
507 numFChoiceStrings.Add(_("0"));
508 numFChoiceStrings.Add(_("1"));
509 numFChoiceStrings.Add(_("2"));
510 numFChoiceStrings.Add(_("3"));
511 numFChoice = new wxUglyChoice( itemPanel6, ID_NUMF_CHOICE, wxDefaultPosition, wxDefaultSize, numFChoiceStrings, 0 );
512 numFChoice->SetStringSelection(_("0"));
513 itemFlexGridSizer14->Add(numFChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
514
515 wxStaticText* itemStaticText19 = new wxStaticText( itemPanel6, wxID_STATIC, _("# light atom polarization functions:"), wxDefaultPosition, wxDefaultSize, 0 );
516 itemFlexGridSizer14->Add(itemStaticText19, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
517
518 wxArrayString numPChoiceStrings;
519 numPChoiceStrings.Add(_("0"));
520 numPChoiceStrings.Add(_("1"));
521 numPChoiceStrings.Add(_("2"));
522 numPChoiceStrings.Add(_("3"));
523 numPChoice = new wxUglyChoice( itemPanel6, ID_NUMP_CHOICE, wxDefaultPosition, wxDefaultSize, numPChoiceStrings, 0 );
524 numPChoice->SetStringSelection(_("0"));
525 itemFlexGridSizer14->Add(numPChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
526
527 wxBoxSizer* itemBoxSizer21 = new wxBoxSizer(wxHORIZONTAL);
528 itemBoxSizer7->Add(itemBoxSizer21, 0, wxGROW, 5);
529 polarLabel = new wxStaticText( itemPanel6, wxID_STATIC, _("Polar:"), wxDefaultPosition, wxDefaultSize, 0 );
530 polarLabel->Enable(false);
531 itemBoxSizer21->Add(polarLabel, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
532
533 wxArrayString polarChoiceStrings;
534 polarChoiceStrings.Add(_("Common"));
535 polarChoiceStrings.Add(_("Pople N31"));
536 polarChoiceStrings.Add(_("Pople N311"));
537 polarChoiceStrings.Add(_("Dunning"));
538 polarChoiceStrings.Add(_("Huzinaga"));
539 polarChoiceStrings.Add(_("Hondo7"));
540 polarChoice = new wxUglyChoice( itemPanel6, ID_POLAR_CHOICE, wxDefaultPosition, wxDefaultSize, polarChoiceStrings, 0 );
541 polarChoice->SetStringSelection(_("Huzinaga"));
542 polarChoice->Enable(false);
543 itemBoxSizer21->Add(polarChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
544
545 diffuseLCheck = new wxCheckBox( itemPanel6, ID_DIFFL_CHECKBOX, _("Diffuse L-shell on heavy atoms"), wxDefaultPosition, wxDefaultSize, 0 );
546 diffuseLCheck->SetValue(false);
547 itemBoxSizer7->Add(diffuseLCheck, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
548
549 diffuseSCheck = new wxCheckBox( itemPanel6, ID_DIFFS_CHECKBOX, _("Diffuse s-shell on hydrogens"), wxDefaultPosition, wxDefaultSize, 0 );
550 diffuseSCheck->SetValue(false);
551 itemBoxSizer7->Add(diffuseSCheck, 0, wxGROW|wxALL, 5);
552
553 spherHarmCheck = new wxCheckBox( itemPanel6, ID_SPHERE_CHECK, _("Use spherical harmonic functions (ie 5D, 7F, etc)"), wxDefaultPosition, wxDefaultSize, 0 );
554 spherHarmCheck->SetValue(false);
555 spherHarmCheck->SetHelpText(_("$CONTRL:ISPHER - GAMESS defaults to using cartesian gaussians. Some basis sets should only be used with spherical harmonics."));
556 if (InputBuilderWindow::ShowToolTips())
557 spherHarmCheck->SetToolTip(_("$CONTRL:ISPHER - GAMESS defaults to using cartesian gaussians. Some basis sets should only be used with spherical harmonics."));
558 itemBoxSizer7->Add(spherHarmCheck, 0, wxGROW|wxALL, 5);
559
560 listBook->AddPage(itemPanel6, _("Basis"));
561
562 wxPanel* itemPanel27 = new wxPanel( listBook, ID_IBCONTROLPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
563 wxBoxSizer* itemBoxSizer28 = new wxBoxSizer(wxVERTICAL);
564 itemPanel27->SetSizer(itemBoxSizer28);
565
566 wxStaticBox* itemStaticBoxSizer29Static = new wxStaticBox(itemPanel27, wxID_ANY, wxEmptyString);
567 wxStaticBoxSizer* itemStaticBoxSizer29 = new wxStaticBoxSizer(itemStaticBoxSizer29Static, wxVERTICAL);
568 itemBoxSizer28->Add(itemStaticBoxSizer29, 0, wxALIGN_LEFT|wxALL, 5);
569 wxFlexGridSizer* itemFlexGridSizer30 = new wxFlexGridSizer(0, 2, 0, 0);
570 itemStaticBoxSizer29->Add(itemFlexGridSizer30, 0, wxGROW, 5);
571 wxStaticText* itemStaticText31 = new wxStaticText( itemPanel27, wxID_STATIC, _("Run Type:"), wxDefaultPosition, wxDefaultSize, 0 );
572 itemFlexGridSizer30->Add(itemStaticText31, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
573
574 wxArrayString runChoiceStrings;
575 runChoiceStrings.Add(_("Energy"));
576 runChoiceStrings.Add(_("Gradient"));
577 runChoiceStrings.Add(_("Hessian"));
578 runChoiceStrings.Add(_("Optimization"));
579 runChoiceStrings.Add(_("Trudge"));
580 runChoiceStrings.Add(_("Saddle Point"));
581 runChoiceStrings.Add(_("Min. Energy Crossing"));
582 runChoiceStrings.Add(_("IRC"));
583 runChoiceStrings.Add(_("Molecular Dynamics"));
584 runChoiceStrings.Add(_("Gradient Extremal"));
585 runChoiceStrings.Add(_("DRC"));
586 runChoiceStrings.Add(_("Energy Surface"));
587 runChoiceStrings.Add(_("G3MP2"));
588 runChoiceStrings.Add(_("Properties"));
589 runChoiceStrings.Add(_("Morokuma"));
590 runChoiceStrings.Add(_("Radiative Transition mom."));
591 runChoiceStrings.Add(_("Spin Orbit"));
592 runChoiceStrings.Add(_("Finite Electric Field"));
593 runChoiceStrings.Add(_("TDHF"));
594 runChoiceStrings.Add(_("extended TDHF"));
595 runChoiceStrings.Add(_("Global Optimization"));
596 runChoiceStrings.Add(_("VSCF"));
597 runChoiceStrings.Add(_("FMO Optimization"));
598 runChoiceStrings.Add(_("Raman Intensities"));
599 runChoiceStrings.Add(_("NMR"));
600 runChoiceStrings.Add(_("Make EFP"));
601 runChoiceStrings.Add(_("Free state FMO"));
602 runChoice = new wxUglyChoice( itemPanel27, ID_RUN_CHOICE, wxDefaultPosition, wxDefaultSize, runChoiceStrings, 0 );
603 runChoice->SetStringSelection(_("Energy"));
604 itemFlexGridSizer30->Add(runChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
605
606 wxStaticText* itemStaticText33 = new wxStaticText( itemPanel27, wxID_STATIC, _("SCF Type:"), wxDefaultPosition, wxDefaultSize, 0 );
607 itemFlexGridSizer30->Add(itemStaticText33, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
608
609 wxArrayString scfChoiceStrings;
610 scfChoiceStrings.Add(_("RHF"));
611 scfChoiceStrings.Add(_("UHF"));
612 scfChoiceStrings.Add(_("ROHF"));
613 scfChoiceStrings.Add(_("GVB"));
614 scfChoiceStrings.Add(_("MCSCF"));
615 scfChoiceStrings.Add(_("None (CI)"));
616 scfChoice = new wxUglyChoice( itemPanel27, ID_SCF_CHOICE, wxDefaultPosition, wxDefaultSize, scfChoiceStrings, 0 );
617 scfChoice->SetStringSelection(_("RHF"));
618 itemFlexGridSizer30->Add(scfChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
619
620 wxStaticText* itemStaticText35 = new wxStaticText( itemPanel27, wxID_STATIC, _("Localization Method:"), wxDefaultPosition, wxDefaultSize, 0 );
621 itemFlexGridSizer30->Add(itemStaticText35, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
622
623 wxArrayString localChoiceStrings;
624 localChoiceStrings.Add(_("None"));
625 localChoiceStrings.Add(_("Foster-Boys"));
626 localChoiceStrings.Add(_("Edmiston-Ruedenberg"));
627 localChoiceStrings.Add(_("Pipek-Mezey"));
628 localChoiceStrings.Add(_("SVD"));
629 localChoice = new wxUglyChoice( itemPanel27, ID_LOCAL_CHOICE, wxDefaultPosition, wxDefaultSize, localChoiceStrings, 0 );
630 localChoice->SetStringSelection(_("None"));
631 itemFlexGridSizer30->Add(localChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
632
633 wxBoxSizer* itemBoxSizer37 = new wxBoxSizer(wxHORIZONTAL);
634 itemBoxSizer28->Add(itemBoxSizer37, 0, wxGROW, 5);
635 wxBoxSizer* itemBoxSizer38 = new wxBoxSizer(wxVERTICAL);
636 itemBoxSizer37->Add(itemBoxSizer38, 0, wxGROW, 5);
637 wxStaticBox* itemStaticBoxSizer39Static = new wxStaticBox(itemPanel27, wxID_ANY, wxEmptyString);
638 wxStaticBoxSizer* itemStaticBoxSizer39 = new wxStaticBoxSizer(itemStaticBoxSizer39Static, wxVERTICAL);
639 itemBoxSizer38->Add(itemStaticBoxSizer39, 0, wxGROW|wxALL, 5);
640 wxFlexGridSizer* itemFlexGridSizer40 = new wxFlexGridSizer(0, 2, 0, 0);
641 itemStaticBoxSizer39->Add(itemFlexGridSizer40, 0, wxGROW, 5);
642 wxStaticText* itemStaticText41 = new wxStaticText( itemPanel27, wxID_STATIC, _("Molecule Charge:"), wxDefaultPosition, wxDefaultSize, 0 );
643 itemFlexGridSizer40->Add(itemStaticText41, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
644
645 mchargeText = new wxTextCtrl( itemPanel27, ID_MCHARGE_TEXTCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
646 if (InputBuilderWindow::ShowToolTips())
647 mchargeText->SetToolTip(_("$CONTRL:ICHARG - Enter an integer value for the molecular charge."));
648 itemFlexGridSizer40->Add(mchargeText, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
649
650 wxStaticText* itemStaticText43 = new wxStaticText( itemPanel27, wxID_STATIC, _("Multiplicity:"), wxDefaultPosition, wxDefaultSize, 0 );
651 itemFlexGridSizer40->Add(itemStaticText43, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
652
653 multText = new wxTextCtrl( itemPanel27, ID_MULT_TEXTCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
654 if (InputBuilderWindow::ShowToolTips())
655 multText->SetToolTip(_("$CONTRL:MULT - Enter an integer value for the spin state."));
656 itemFlexGridSizer40->Add(multText, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
657
658 wxStaticBox* itemStaticBoxSizer45Static = new wxStaticBox(itemPanel27, wxID_ANY, wxEmptyString);
659 wxStaticBoxSizer* itemStaticBoxSizer45 = new wxStaticBoxSizer(itemStaticBoxSizer45Static, wxVERTICAL);
660 itemBoxSizer38->Add(itemStaticBoxSizer45, 0, wxGROW|wxALL, 5);
661 wxFlexGridSizer* itemFlexGridSizer46 = new wxFlexGridSizer(0, 2, 0, 0);
662 itemStaticBoxSizer45->Add(itemFlexGridSizer46, 0, wxGROW, 5);
663 wxStaticText* itemStaticText47 = new wxStaticText( itemPanel27, wxID_STATIC, _("Exe. Type:"), wxDefaultPosition, wxDefaultSize, 0 );
664 itemFlexGridSizer46->Add(itemStaticText47, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
665
666 wxArrayString exeChoiceStrings;
667 exeChoiceStrings.Add(_("Normal Run"));
668 exeChoiceStrings.Add(_("Check"));
669 exeChoiceStrings.Add(_("Debug"));
670 exeChoiceStrings.Add(_("Other..."));
671 exeChoice = new wxUglyChoice( itemPanel27, ID_EXE_CHOICE, wxDefaultPosition, wxDefaultSize, exeChoiceStrings, 0 );
672 exeChoice->SetStringSelection(_("Normal Run"));
673 itemFlexGridSizer46->Add(exeChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
674
675 wxStaticText* itemStaticText49 = new wxStaticText( itemPanel27, wxID_STATIC, _("Max # SCF Iterations:"), wxDefaultPosition, wxDefaultSize, 0 );
676 itemFlexGridSizer46->Add(itemStaticText49, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
677
678 scfIterText = new wxTextCtrl( itemPanel27, ID_MAXIT_TEXTCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
679 if (InputBuilderWindow::ShowToolTips())
680 scfIterText->SetToolTip(_("$CONTRL:MAXIT - Enter the maximum number of SCF iterations. If the wavefunction is not converged at this point the run will be aborted."));
681 itemFlexGridSizer46->Add(scfIterText, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
682
683 wxStaticBox* itemStaticBoxSizer51Static = new wxStaticBox(itemPanel27, wxID_ANY, wxEmptyString);
684 wxStaticBoxSizer* itemStaticBoxSizer51 = new wxStaticBoxSizer(itemStaticBoxSizer51Static, wxVERTICAL);
685 itemBoxSizer37->Add(itemStaticBoxSizer51, 0, wxALIGN_TOP|wxALL, 5);
686 mp2Check = new wxCheckBox( itemPanel27, ID_MP2_CHECKBOX, _("Use MP2"), wxDefaultPosition, wxDefaultSize, 0 );
687 mp2Check->SetValue(false);
688 if (InputBuilderWindow::ShowToolTips())
689 mp2Check->SetToolTip(_("$CONTRL:MPLEVL - Click to use 2nd order Moller-Plesset perturbation theory. Implemented for RHF, UHF, ROHF and MCSCF energies and RHF, UHF, and ROHF gradients."));
690 itemStaticBoxSizer51->Add(mp2Check, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
691
692 dftCheck = new wxCheckBox( itemPanel27, ID_DFT_CHECKBOX, _("Use DFT"), wxDefaultPosition, wxDefaultSize, 0 );
693 dftCheck->SetValue(false);
694 itemStaticBoxSizer51->Add(dftCheck, 0, wxGROW|wxALL, 5);
695
696 wxFlexGridSizer* itemFlexGridSizer54 = new wxFlexGridSizer(0, 2, 0, 0);
697 itemStaticBoxSizer51->Add(itemFlexGridSizer54, 0, wxGROW, 5);
698 ciLabel = new wxStaticText( itemPanel27, wxID_STATIC, _("CI:"), wxDefaultPosition, wxDefaultSize, 0 );
699 if (InputBuilderWindow::ShowToolTips())
700 ciLabel->SetToolTip(_("$CONTRL:CITYP Choose the type of CI to perform on top of the base wavefunction or on the supplied $VEC group for SCFTYP=NONE."));
701 itemFlexGridSizer54->Add(ciLabel, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
702
703 wxArrayString ciChoiceStrings;
704 ciChoiceStrings.Add(_("None"));
705 ciChoiceStrings.Add(_("GUGA"));
706 ciChoiceStrings.Add(_("Ames Lab. Determinant"));
707 ciChoiceStrings.Add(_("Occupation Restricted Multiple Active Space"));
708 ciChoiceStrings.Add(_("CI Singles"));
709 ciChoiceStrings.Add(_("Full Second Order CI"));
710 ciChoiceStrings.Add(_("General CI"));
711 ciChoice = new wxUglyChoice( itemPanel27, ID_CI_CHOICE, wxDefaultPosition, wxDefaultSize, ciChoiceStrings, 0 );
712 ciChoice->SetStringSelection(_("None"));
713 itemFlexGridSizer54->Add(ciChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
714
715 ccLabel = new wxStaticText( itemPanel27, wxID_STATIC, _("CC:"), wxDefaultPosition, wxDefaultSize, 0 );
716 itemFlexGridSizer54->Add(ccLabel, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
717
718 wxArrayString ccChoiceStrings;
719 ccChoiceStrings.Add(_("None"));
720 ccChoiceStrings.Add(_("LCCD: linearized CC"));
721 ccChoiceStrings.Add(_("CCD: CC with doubles"));
722 ccChoiceStrings.Add(_("CCSD: CC with singles and doubles"));
723 ccChoiceStrings.Add(_("CCSD(T)"));
724 ccChoiceStrings.Add(_("R-CC"));
725 ccChoiceStrings.Add(_("CR-CC"));
726 ccChoiceStrings.Add(_("CR-CCL"));
727 ccChoiceStrings.Add(_("CCSD(TQ)"));
728 ccChoiceStrings.Add(_("CR-CC(Q)"));
729 ccChoiceStrings.Add(_("EOM-CCSD"));
730 ccChoiceStrings.Add(_("CR-EOM"));
731 ccChoiceStrings.Add(_("CR-EOML"));
732 ccChoiceStrings.Add(_("IP-EOM2"));
733 ccChoiceStrings.Add(_("IP-EOM3A"));
734 ccChoiceStrings.Add(_("EA-EOM2"));
735 ccChoiceStrings.Add(_("EA-EOM3A"));
736 ccChoice = new wxUglyChoice( itemPanel27, ID_CC_CHOICE, wxDefaultPosition, wxDefaultSize, ccChoiceStrings, 0 );
737 ccChoice->SetStringSelection(_("None"));
738 itemFlexGridSizer54->Add(ccChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
739
740 listBook->AddPage(itemPanel27, _("Control"));
741
742 wxPanel* itemPanel59 = new wxPanel( listBook, ID_IBDATAPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
743 wxBoxSizer* itemBoxSizer60 = new wxBoxSizer(wxVERTICAL);
744 itemPanel59->SetSizer(itemBoxSizer60);
745
746 wxBoxSizer* itemBoxSizer61 = new wxBoxSizer(wxVERTICAL);
747 itemBoxSizer60->Add(itemBoxSizer61, 0, wxALIGN_LEFT, 5);
748 titleText = new wxTextCtrl( itemPanel59, ID_TITLE_TEXTCTRL, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
749 if (InputBuilderWindow::ShowToolTips())
750 titleText->SetToolTip(_("$DATA - You may enter a one line title which may help you identify this input deck in the future."));
751 itemBoxSizer61->Add(titleText, 0, wxGROW|wxALL, 5);
752
753 wxStaticBox* itemStaticBoxSizer63Static = new wxStaticBox(itemPanel59, wxID_ANY, wxEmptyString);
754 wxStaticBoxSizer* itemStaticBoxSizer63 = new wxStaticBoxSizer(itemStaticBoxSizer63Static, wxVERTICAL);
755 itemBoxSizer61->Add(itemStaticBoxSizer63, 0, wxALIGN_LEFT|wxALL, 5);
756 wxFlexGridSizer* itemFlexGridSizer64 = new wxFlexGridSizer(0, 2, 0, 0);
757 itemStaticBoxSizer63->Add(itemFlexGridSizer64, 0, wxGROW, 5);
758 wxStaticText* itemStaticText65 = new wxStaticText( itemPanel59, wxID_STATIC, _("Coord. Type:"), wxDefaultPosition, wxDefaultSize, 0 );
759 itemFlexGridSizer64->Add(itemStaticText65, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
760
761 wxArrayString coordTypeChoiceStrings;
762 coordTypeChoiceStrings.Add(_("Unique cartesian Coords."));
763 coordTypeChoiceStrings.Add(_("Hilderbrant internals"));
764 coordTypeChoiceStrings.Add(_("Cartesian coordinates"));
765 coordTypeChoiceStrings.Add(_("Z-Matrix"));
766 coordTypeChoiceStrings.Add(_("MOPAC Z-Matrix"));
767 coordTypeChoice = new wxUglyChoice( itemPanel59, ID_COORD_CHOICE, wxDefaultPosition, wxDefaultSize, coordTypeChoiceStrings, 0 );
768 coordTypeChoice->SetStringSelection(_("Unique cartesian Coords."));
769 itemFlexGridSizer64->Add(coordTypeChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
770
771 wxStaticText* itemStaticText67 = new wxStaticText( itemPanel59, wxID_STATIC, _("Units:"), wxDefaultPosition, wxDefaultSize, 0 );
772 itemFlexGridSizer64->Add(itemStaticText67, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
773
774 wxArrayString unitChoiceStrings;
775 unitChoiceStrings.Add(_("Angstroms"));
776 unitChoiceStrings.Add(_("Bohr"));
777 unitChoice = new wxUglyChoice( itemPanel59, ID_UNIT_CHOICE, wxDefaultPosition, wxDefaultSize, unitChoiceStrings, 0 );
778 unitChoice->SetStringSelection(_("Angstroms"));
779 itemFlexGridSizer64->Add(unitChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
780
781 wxBoxSizer* itemBoxSizer69 = new wxBoxSizer(wxHORIZONTAL);
782 itemStaticBoxSizer63->Add(itemBoxSizer69, 0, wxGROW, 5);
783 wxStaticText* itemStaticText70 = new wxStaticText( itemPanel59, wxID_STATIC, _("# of Z-Matrix Variables:"), wxDefaultPosition, wxDefaultSize, 0 );
784 itemBoxSizer69->Add(itemStaticText70, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
785
786 zmatrixVarsText = new wxTextCtrl( itemPanel59, ID_ZMAT_VARS_TEXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
787 if (InputBuilderWindow::ShowToolTips())
788 zmatrixVarsText->SetToolTip(_("$CONTRL:NZVAR - Enter an integer number representing the number of internal coordinates for your molecule. Normally this will be 3N-6 (3N-5 for linear molecules) where N is the number of atoms. A value of 0 selects cartesian coordinates. If set and a set of internal coordinates are defined a $ZMAT group will be punched out."));
789 itemBoxSizer69->Add(zmatrixVarsText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
790
791 wxStaticBox* itemStaticBoxSizer72Static = new wxStaticBox(itemPanel59, wxID_ANY, wxEmptyString);
792 wxStaticBoxSizer* itemStaticBoxSizer72 = new wxStaticBoxSizer(itemStaticBoxSizer72Static, wxVERTICAL);
793 itemBoxSizer61->Add(itemStaticBoxSizer72, 0, wxALIGN_LEFT|wxALL, 5);
794 wxFlexGridSizer* itemFlexGridSizer73 = new wxFlexGridSizer(0, 2, 0, 0);
795 itemStaticBoxSizer72->Add(itemFlexGridSizer73, 0, wxGROW, 5);
796 wxStaticText* itemStaticText74 = new wxStaticText( itemPanel59, wxID_STATIC, _("Point Group:"), wxDefaultPosition, wxDefaultSize, 0 );
797 itemFlexGridSizer73->Add(itemStaticText74, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
798
799 wxArrayString pointGroupChoiceStrings;
800 pointGroupChoiceStrings.Add(_("C1"));
801 pointGroupChoiceStrings.Add(_("CS"));
802 pointGroupChoiceStrings.Add(_("CI"));
803 pointGroupChoiceStrings.Add(_("CnH"));
804 pointGroupChoiceStrings.Add(_("CnV"));
805 pointGroupChoiceStrings.Add(_("Cn"));
806 pointGroupChoiceStrings.Add(_("S2n"));
807 pointGroupChoiceStrings.Add(_("DnD"));
808 pointGroupChoiceStrings.Add(_("DnH"));
809 pointGroupChoiceStrings.Add(_("Dn"));
810 pointGroupChoiceStrings.Add(_("TD"));
811 pointGroupChoiceStrings.Add(_("TH"));
812 pointGroupChoiceStrings.Add(_("T"));
813 pointGroupChoiceStrings.Add(_("OH"));
814 pointGroupChoiceStrings.Add(_("O"));
815 pointGroupChoice = new wxUglyChoice( itemPanel59, ID_POINTGROUP_CHOICE, wxDefaultPosition, wxDefaultSize, pointGroupChoiceStrings, 0 );
816 itemFlexGridSizer73->Add(pointGroupChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
817
818 paxisOrderText = new wxStaticText( itemPanel59, wxID_STATIC, _("Order of Principle Axis:"), wxDefaultPosition, wxDefaultSize, 0 );
819 paxisOrderText->Enable(false);
820 itemFlexGridSizer73->Add(paxisOrderText, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
821
822 wxArrayString paxisOrderChoiceStrings;
823 paxisOrderChoiceStrings.Add(_("2"));
824 paxisOrderChoiceStrings.Add(_("3"));
825 paxisOrderChoiceStrings.Add(_("4"));
826 paxisOrderChoiceStrings.Add(_("5"));
827 paxisOrderChoiceStrings.Add(_("6"));
828 paxisOrderChoiceStrings.Add(_("7"));
829 paxisOrderChoiceStrings.Add(_("8"));
830 paxisOrderChoice = new wxUglyChoice( itemPanel59, ID_ORDER_CHOICE, wxDefaultPosition, wxDefaultSize, paxisOrderChoiceStrings, 0 );
831 if (InputBuilderWindow::ShowToolTips())
832 paxisOrderChoice->SetToolTip(_("Replaces the 'n' above."));
833 paxisOrderChoice->Enable(false);
834 itemFlexGridSizer73->Add(paxisOrderChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
835
836 symmetryCheck = new wxCheckBox( itemPanel59, ID_SYMMETRY_CHECKBOX, _("Use Symmetry During Calculation"), wxDefaultPosition, wxDefaultSize, 0 );
837 symmetryCheck->SetValue(true);
838 if (InputBuilderWindow::ShowToolTips())
839 symmetryCheck->SetToolTip(_("$CONTRL:NOSYM - When checked symmetry will be used as much as possible in the caluclation of integrals, gradients, etc. (This is the normal setting)"));
840 itemStaticBoxSizer72->Add(symmetryCheck, 0, wxALIGN_LEFT|wxALL, 5);
841
842 listBook->AddPage(itemPanel59, _("Data"));
843
844 wxPanel* itemPanel79 = new wxPanel( listBook, ID_IBSYSTEMPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
845 wxBoxSizer* itemBoxSizer80 = new wxBoxSizer(wxVERTICAL);
846 itemPanel79->SetSizer(itemBoxSizer80);
847
848 wxFlexGridSizer* itemFlexGridSizer81 = new wxFlexGridSizer(0, 3, 0, 0);
849 itemBoxSizer80->Add(itemFlexGridSizer81, 0, wxGROW, 5);
850 wxStaticText* itemStaticText82 = new wxStaticText( itemPanel79, wxID_STATIC, _("Time Limit:"), wxDefaultPosition, wxDefaultSize, 0 );
851 itemFlexGridSizer81->Add(itemStaticText82, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
852
853 timeLimitText = new wxTextCtrl( itemPanel79, ID_TIMELIMIT_TEXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
854 if (InputBuilderWindow::ShowToolTips())
855 timeLimitText->SetToolTip(_("$SYSTEM:TIMLIM - Enter a value for the time limit. When the time limit is reached GAMESS will stop the run. The number entered here will have the units given at the right."));
856 itemFlexGridSizer81->Add(timeLimitText, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
857
858 wxArrayString timeLimitUnitChoiceStrings;
859 timeLimitUnitChoiceStrings.Add(_("Seconds"));
860 timeLimitUnitChoiceStrings.Add(_("Minutes"));
861 timeLimitUnitChoiceStrings.Add(_("Hours"));
862 timeLimitUnitChoiceStrings.Add(_("Days"));
863 timeLimitUnitChoiceStrings.Add(_("Weeks"));
864 timeLimitUnitChoiceStrings.Add(_("Years"));
865 timeLimitUnitChoiceStrings.Add(_("Millenia"));
866 timeLimitUnitChoice = new wxUglyChoice( itemPanel79, ID_TIMELIMITUNITS_CHOICE, wxDefaultPosition, wxDefaultSize, timeLimitUnitChoiceStrings, 0 );
867 timeLimitUnitChoice->SetStringSelection(_("Minutes"));
868 itemFlexGridSizer81->Add(timeLimitUnitChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
869
870 wxStaticText* itemStaticText85 = new wxStaticText( itemPanel79, wxID_STATIC, _("Memory:"), wxDefaultPosition, wxDefaultSize, 0 );
871 itemFlexGridSizer81->Add(itemStaticText85, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
872
873 memoryText = new wxTextCtrl( itemPanel79, ID_MEMORY_TEXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
874 if (InputBuilderWindow::ShowToolTips())
875 memoryText->SetToolTip(_("$SYSTEM:MEMORY - Enter the amount of memory (in the units at the right) that GAMESS will request for its dynamic memory pool. You should not normally request more memory than the RAM size."));
876 itemFlexGridSizer81->Add(memoryText, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
877
878 wxArrayString memoryUnitChoiceStrings;
879 memoryUnitChoiceStrings.Add(_("Words"));
880 memoryUnitChoiceStrings.Add(_("Bytes"));
881 memoryUnitChoiceStrings.Add(_("MegaWords"));
882 memoryUnitChoiceStrings.Add(_("MegaBytes"));
883 memoryUnitChoice = new wxUglyChoice( itemPanel79, ID_MEMORYUNITS_CHOICE, wxDefaultPosition, wxDefaultSize, memoryUnitChoiceStrings, 0 );
884 memoryUnitChoice->SetStringSelection(_("Words"));
885 itemFlexGridSizer81->Add(memoryUnitChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
886
887 wxStaticText* itemStaticText88 = new wxStaticText( itemPanel79, wxID_STATIC, _("MemDDI:"), wxDefaultPosition, wxDefaultSize, 0 );
888 itemFlexGridSizer81->Add(itemStaticText88, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
889
890 memddiText = new wxTextCtrl( itemPanel79, ID_MEMDDI_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
891 if (InputBuilderWindow::ShowToolTips())
892 memddiText->SetToolTip(_("$SYSTEM:MEMDDI - The size of the pseudo global shared memory pool. This is most often needed for certain parallel computations, but certain sequential algorithms also use it (such as ROMP2). Default is 0."));
893 itemFlexGridSizer81->Add(memddiText, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
894
895 wxArrayString memddiUnitChoiceStrings;
896 memddiUnitChoiceStrings.Add(_("MegaWords"));
897 memddiUnitChoiceStrings.Add(_("MegaBytes"));
898 memddiUnitChoiceStrings.Add(_("GigaWords"));
899 memddiUnitChoiceStrings.Add(_("GigaBytes"));
900 memddiUnitChoice = new wxUglyChoice( itemPanel79, ID_MEMDDICHOICE, wxDefaultPosition, wxDefaultSize, memddiUnitChoiceStrings, 0 );
901 memddiUnitChoice->SetStringSelection(_("MegaWords"));
902 itemFlexGridSizer81->Add(memddiUnitChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
903
904 wxBoxSizer* itemBoxSizer91 = new wxBoxSizer(wxHORIZONTAL);
905 itemBoxSizer80->Add(itemBoxSizer91, 0, wxGROW, 5);
906 wxStaticText* itemStaticText92 = new wxStaticText( itemPanel79, wxID_STATIC, _("Diagonalization Method:"), wxDefaultPosition, wxDefaultSize, 0 );
907 itemBoxSizer91->Add(itemStaticText92, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
908
909 wxArrayString diagChoiceStrings;
910 diagChoiceStrings.Add(_("default"));
911 diagChoiceStrings.Add(_("EVVRSP"));
912 diagChoiceStrings.Add(_("GIVEIS"));
913 diagChoiceStrings.Add(_("JACOBI"));
914 diagChoice = new wxUglyChoice( itemPanel79, ID_DIAGONALIZATION_CHOICE, wxDefaultPosition, wxDefaultSize, diagChoiceStrings, 0 );
915 diagChoice->SetStringSelection(_("default"));
916 itemBoxSizer91->Add(diagChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
917
918 coreCheck = new wxCheckBox( itemPanel79, ID_CORE_CHECKBOX, _("Produce \"core\" file upon abort"), wxDefaultPosition, wxDefaultSize, 0 );
919 coreCheck->SetValue(false);
920 itemBoxSizer80->Add(coreCheck, 0, wxALIGN_LEFT|wxALL, 5);
921
922 wxArrayString plBalanceRadioStrings;
923 plBalanceRadioStrings.Add(_("Loop"));
924 plBalanceRadioStrings.Add(_("Next Value"));
925 plBalanceRadio = new wxRadioBox( itemPanel79, ID_PLBALANCE_RADIOBOX, _("Parallel Load Balance Type"), wxDefaultPosition, wxDefaultSize, plBalanceRadioStrings, 1, wxRA_SPECIFY_COLS );
926 plBalanceRadio->SetSelection(0);
927 if (InputBuilderWindow::ShowToolTips())
928 plBalanceRadio->SetToolTip(_("$SYSTEM:BALTYP - Select the type of load balancing to use. Only applicable to runs on parallel computers."));
929 itemBoxSizer80->Add(plBalanceRadio, 0, wxALIGN_LEFT|wxALL, 5);
930
931 externDataRepCheck = new wxCheckBox( itemPanel79, ID_EXTERNDATAREP_CHECKBOX, _("Use External Data Representation for messages"), wxDefaultPosition, wxDefaultSize, 0 );
932 externDataRepCheck->SetValue(false);
933 if (InputBuilderWindow::ShowToolTips())
934 externDataRepCheck->SetToolTip(_("$SYSTEM:XDR= Click to cause messages to be converted into a generic data format to pass between nodes from different vendors."));
935 itemBoxSizer80->Add(externDataRepCheck, 0, wxALIGN_LEFT|wxALL, 5);
936
937 mSGParallCheck = new wxCheckBox( itemPanel79, ID_PARALL_CHECK, _("Force parallel methods"), wxDefaultPosition, wxDefaultSize, 0 );
938 mSGParallCheck->SetValue(false);
939 if (InputBuilderWindow::ShowToolTips())
940 mSGParallCheck->SetToolTip(_("$SYSTEM:PARALL - Forces the use of parallel methods even when running on 1 processor. This is necessary to a check run on the parallel MP2 code for example."));
941 itemBoxSizer80->Add(mSGParallCheck, 0, wxALIGN_LEFT|wxALL, 5);
942
943 listBook->AddPage(itemPanel79, _("System"));
944
945 wxPanel* itemPanel98 = new wxPanel( listBook, ID_GVBPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
946 wxBoxSizer* itemBoxSizer99 = new wxBoxSizer(wxVERTICAL);
947 itemPanel98->SetSizer(itemBoxSizer99);
948
949 wxFlexGridSizer* itemFlexGridSizer100 = new wxFlexGridSizer(0, 2, 0, 0);
950 itemBoxSizer99->Add(itemFlexGridSizer100, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
951 wxStaticText* itemStaticText101 = new wxStaticText( itemPanel98, wxID_STATIC, _("Number of Closed Shell Orbitals:"), wxDefaultPosition, wxDefaultSize, 0 );
952 itemFlexGridSizer100->Add(itemStaticText101, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
953
954 mGVB_NCOEdit = new wxTextCtrl( itemPanel98, ID_GVB_NCOEDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
955 if (InputBuilderWindow::ShowToolTips())
956 mGVB_NCOEdit->SetToolTip(_("$SCF:NCO You almost certainly need to change this from the default!"));
957 itemFlexGridSizer100->Add(mGVB_NCOEdit, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
958
959 wxStaticText* itemStaticText103 = new wxStaticText( itemPanel98, wxID_STATIC, _("Number of Geminal Pairs:"), wxDefaultPosition, wxDefaultSize, 0 );
960 itemFlexGridSizer100->Add(itemStaticText103, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
961
962 mGVB_PairsEdit = new wxTextCtrl( itemPanel98, ID_GVB_PAIRSEDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
963 if (InputBuilderWindow::ShowToolTips())
964 mGVB_PairsEdit->SetToolTip(_("$SCF:NPAIR"));
965 itemFlexGridSizer100->Add(mGVB_PairsEdit, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
966
967 wxStaticText* itemStaticText105 = new wxStaticText( itemPanel98, wxID_STATIC, _("Number of Sets of Open Shells:"), wxDefaultPosition, wxDefaultSize, 0 );
968 itemFlexGridSizer100->Add(itemStaticText105, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
969
970 mGVB_NSETOEdit = new wxTextCtrl( itemPanel98, ID_GVB_NSETOEDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
971 if (InputBuilderWindow::ShowToolTips())
972 mGVB_NSETOEdit->SetToolTip(_("$SCF:NSETO"));
973 itemFlexGridSizer100->Add(mGVB_NSETOEdit, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
974
975 mGVB_NOStatic = new wxStaticText( itemPanel98, wxID_STATIC, _("Degeneracy of Each Open Shell:"), wxDefaultPosition, wxDefaultSize, 0 );
976 itemFlexGridSizer100->Add(mGVB_NOStatic, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
977
978 mGVB_NOEdit = new wxTextCtrl( itemPanel98, ID_GVB_NOEDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
979 if (InputBuilderWindow::ShowToolTips())
980 mGVB_NOEdit->SetToolTip(_("$SCF:NO - A space-delimited array providing the degeneracy of each open shell. There must be the number of values specified directly above."));
981 itemFlexGridSizer100->Add(mGVB_NOEdit, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
982
983 listBook->AddPage(itemPanel98, _("GVB Parameters"));
984
985 wxPanel* itemPanel109 = new wxPanel( listBook, ID_IBDFTPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
986 wxBoxSizer* itemBoxSizer110 = new wxBoxSizer(wxVERTICAL);
987 itemPanel109->SetSizer(itemBoxSizer110);
988
989 wxFlexGridSizer* itemFlexGridSizer111 = new wxFlexGridSizer(0, 2, 0, 0);
990 itemBoxSizer110->Add(itemFlexGridSizer111, 0, wxALIGN_LEFT, 5);
991 wxStaticText* itemStaticText112 = new wxStaticText( itemPanel109, wxID_STATIC, _("Method:"), wxDefaultPosition, wxDefaultSize, 0 );
992 itemFlexGridSizer111->Add(itemStaticText112, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
993
994 wxArrayString dftMethodChoiceStrings;
995 dftMethodChoiceStrings.Add(_("Grid"));
996 dftMethodChoiceStrings.Add(_("Grid-Free"));
997 dftMethodChoice = new wxUglyChoice( itemPanel109, ID_DFTMETHOD_CHOICE, wxDefaultPosition, wxDefaultSize, dftMethodChoiceStrings, 0 );
998 dftMethodChoice->SetStringSelection(_("Grid"));
999 itemFlexGridSizer111->Add(dftMethodChoice, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
1000
1001 wxStaticText* itemStaticText114 = new wxStaticText( itemPanel109, wxID_STATIC, _("DFT Functional:"), wxDefaultPosition, wxDefaultSize, 0 );
1002 itemFlexGridSizer111->Add(itemStaticText114, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1003
1004 funcSizer = new wxBoxSizer(wxVERTICAL);
1005 itemFlexGridSizer111->Add(funcSizer, 1, wxGROW|wxGROW, 5);
1006 wxArrayString dftGridFuncChoiceStrings;
1007 dftGridFuncChoiceStrings.Add(_("Slater exchange"));
1008 dftGridFuncChoiceStrings.Add(_("Becke 1988 exchange"));
1009 dftGridFuncChoiceStrings.Add(_("Gill 1996 exchange"));
1010 dftGridFuncChoiceStrings.Add(_("OPTX: Handy-Cohen exchange"));
1011 dftGridFuncChoiceStrings.Add(_("PW91X: Perdew-Want 1991 exchange"));
1012 dftGridFuncChoiceStrings.Add(_("PBEX: Perdew-Burke-Ernzerhof exchange"));
1013 dftGridFuncChoiceStrings.Add(_("VWN: Vosko-Wilk-Nusair (VWN5) correlation"));
1014 dftGridFuncChoiceStrings.Add(_("VWN1: VWN correlation formula 1"));
1015 dftGridFuncChoiceStrings.Add(_("PZ81: Perdew-Wang 1981 correlation"));
1016 dftGridFuncChoiceStrings.Add(_("P86: Perdew 1986 correlation"));
1017 dftGridFuncChoiceStrings.Add(_("LYP: Lee-Yang-Parr correlation"));
1018 dftGridFuncChoiceStrings.Add(_("PW91C: Perdew-Wang 1991 correlation"));
1019 dftGridFuncChoiceStrings.Add(_("PBEC: Perdew-Burke-Ernzerhof correlation"));
1020 dftGridFuncChoiceStrings.Add(_("OP: one parameter progressive correlation"));
1021 dftGridFuncChoiceStrings.Add(_("SVWN: Slater exhange + VWN correlation"));
1022 dftGridFuncChoiceStrings.Add(_("BLYP: BECKE exchange + LYP correlation"));
1023 dftGridFuncChoiceStrings.Add(_("BOP: BECKE exchange + OP correlation"));
1024 dftGridFuncChoiceStrings.Add(_("BP86: Becke exchange + P86 correlation"));
1025 dftGridFuncChoiceStrings.Add(_("GVWN: Gill exchange + VWN5 correlation"));
1026 dftGridFuncChoiceStrings.Add(_("GPW91: Gill exchange + PW91 correlation"));
1027 dftGridFuncChoiceStrings.Add(_("PBEVWN: PBE exchange + VWN5 correlation"));
1028 dftGridFuncChoiceStrings.Add(_("PBEOP: PBE exchange + OP correlation"));
1029 dftGridFuncChoiceStrings.Add(_("OLYP: OPTX exchange + LYP correlation"));
1030 dftGridFuncChoiceStrings.Add(_("PW91: PW91 exhange and correlation"));
1031 dftGridFuncChoiceStrings.Add(_("PBE: exchange and correlation"));
1032 dftGridFuncChoiceStrings.Add(_("revPBE: PBE revised by Zhang-Yang"));
1033 dftGridFuncChoiceStrings.Add(_("RPBE: PBE revised by Hammer-Hansen-Norshov"));
1034 dftGridFuncChoiceStrings.Add(_("PBEsol: PBE revised by Perdew et al for solids"));
1035 dftGridFuncChoiceStrings.Add(_("EDF1: empirical density functional #1"));
1036 dftGridFuncChoiceStrings.Add(_("HCTH93: Hamprecht-Cohen-Tozer-Handy 1998 fit to 93 systems"));
1037 dftGridFuncChoiceStrings.Add(_("HCTH120: later fit to 120 systems"));
1038 dftGridFuncChoiceStrings.Add(_("HCTH147: later fit to 147 systems"));
1039 dftGridFuncChoiceStrings.Add(_("HCTH407: later fit to 407 systems"));
1040 dftGridFuncChoiceStrings.Add(_("SOGGA: PBE revised by Zhang-Truhlar for solids"));
1041 dftGridFuncChoiceStrings.Add(_("MOHLYP: metal optimized OPTX, half LYP"));
1042 dftGridFuncChoiceStrings.Add(_("B97-D: Grimme's mod. B97"));
1043 dftGridFuncChoiceStrings.Add(_("BHHLYP: HF and Becke exchange + LYP correlation"));
1044 dftGridFuncChoiceStrings.Add(_("B3PW91: Becke's 3 parameter exchange + PW91 correlation"));
1045 dftGridFuncChoiceStrings.Add(_("B3LYP: Becke+Slater+HF exchange and LYP+VWN5 correlation"));
1046 dftGridFuncChoiceStrings.Add(_("B3LYP1: use of VWN1 in B3LYP"));
1047 dftGridFuncChoiceStrings.Add(_("B97: Becke's 1997 hybrid functional"));
1048 dftGridFuncChoiceStrings.Add(_("B97-1: Hamprect-Cohen-Tozer-Handy reparam. of B97"));
1049 dftGridFuncChoiceStrings.Add(_("B97-2: Wilson-Bradley-Tozer 2001 mod to B97"));
1050 dftGridFuncChoiceStrings.Add(_("B97-3: Keal-Tozer 2005 mod to B97"));
1051 dftGridFuncChoiceStrings.Add(_("B97-K: Boese-Martin 2004 mod for kinetics"));
1052 dftGridFuncChoiceStrings.Add(_("B98: Schmider-Becke 1998 mod to B97"));
1053 dftGridFuncChoiceStrings.Add(_("PBE0: hybrid made from PBE"));
1054 dftGridFuncChoiceStrings.Add(_("X3LYP: HF+Slater+Becke88+PW91 exchange and LYP+VWN1 correlation"));
1055 dftGridFuncChoiceStrings.Add(_("CAMB3LYP: coulomb attenuated B3LYP"));
1056 dftGridFuncChoiceStrings.Add(_("wB97: omega separated form of B97"));
1057 dftGridFuncChoiceStrings.Add(_("wB97X: wB97 with short-range HF exchange"));
1058 dftGridFuncChoiceStrings.Add(_("wB97X-D: dispersion corrected wB97X"));
1059 dftGridFuncChoiceStrings.Add(_("B2PLYP: mixes BLYP, HF exchange and MP2"));
1060 dftGridFuncChoiceStrings.Add(_("xB97X-2"));
1061 dftGridFuncChoiceStrings.Add(_("wB97X-2L"));
1062 dftGridFuncChoiceStrings.Add(_("VS98: Voorhis-Scuseria 1998"));
1063 dftGridFuncChoiceStrings.Add(_("PKZB: Perdew-Kurth-Zupan-Blaha 1999"));
1064 dftGridFuncChoiceStrings.Add(_("tHCTH: Boese-Handy 2002 metaGGA"));
1065 dftGridFuncChoiceStrings.Add(_("tHCTHhyb: tHCTH hybrid with 15% HF exchange"));
1066 dftGridFuncChoiceStrings.Add(_("BMK: Boese-Martin 2004 param. for kinetics"));
1067 dftGridFuncChoiceStrings.Add(_("TPSS: Tao-Perdew-Staroverov-Scuseria 2003"));
1068 dftGridFuncChoiceStrings.Add(_("TPSSh: TPSS with 10% HF exchange"));
1069 dftGridFuncChoiceStrings.Add(_("TPSSm: TPSS with mod. parameter, 2007"));
1070 dftGridFuncChoiceStrings.Add(_("revTPSS: TPSS rev. 2009"));
1071 dftGridFuncChoiceStrings.Add(_("M05: Minnesota exchange-corr. 2005"));
1072 dftGridFuncChoiceStrings.Add(_("M05-2X: M05 with mod. HF exchange"));
1073 dftGridFuncChoiceStrings.Add(_("M06: Minnesota 2006"));
1074 dftGridFuncChoiceStrings.Add(_("M06-L: M06 with 0% HF exchange"));
1075 dftGridFuncChoiceStrings.Add(_("M06-2X: M06 with doubled HF exchange"));
1076 dftGridFuncChoiceStrings.Add(_("M06-HF: M06 with 100% HF exchange"));
1077 dftGridFuncChoiceStrings.Add(_("M08-HX: M08 with high HF exchange"));
1078 dftGridFuncChoiceStrings.Add(_("M08-SO: M08 form different parameters"));
1079 dftGridFuncChoice = new wxUglyChoice( itemPanel109, ID_GRID_FUNCTIONAL_CHOICE, wxDefaultPosition, wxDefaultSize, dftGridFuncChoiceStrings, 0 );
1080 dftGridFuncChoice->SetStringSelection(_("Slater exchange"));
1081 funcSizer->Add(dftGridFuncChoice, 0, wxALIGN_LEFT|wxALL, 5);
1082
1083 wxArrayString dftGridFreeFuncChoiceStrings;
1084 dftGridFreeFuncChoiceStrings.Add(_("X-Alpha exchange"));
1085 dftGridFreeFuncChoiceStrings.Add(_("Slater exchange"));
1086 dftGridFreeFuncChoiceStrings.Add(_("Becke's 1988 exchange"));
1087 dftGridFreeFuncChoiceStrings.Add(_("Depristo/Kress exchange"));
1088 dftGridFreeFuncChoiceStrings.Add(_("CAMA: Handy et al's mods to Becke exchange"));
1089 dftGridFreeFuncChoiceStrings.Add(_("HALF: 50-50 mix of Becke and HF exchange"));
1090 dftGridFreeFuncChoiceStrings.Add(_("VWN: Vosko/Wilke/Nusair corr"));
1091 dftGridFreeFuncChoiceStrings.Add(_("PWLOC: Perdew/Wang local corr"));
1092 dftGridFreeFuncChoiceStrings.Add(_("LYP: Lee/Yang/Parr corr"));
1093 dftGridFreeFuncChoiceStrings.Add(_("SVWN: Slater exchange + VWN corr"));
1094 dftGridFreeFuncChoiceStrings.Add(_("BVWN: Becke exchange + VWN corr"));
1095 dftGridFreeFuncChoiceStrings.Add(_("BLYP: Becke exchange + LYP corr"));
1096 dftGridFreeFuncChoiceStrings.Add(_("BPWLOC: Becke exchange + Perdew/Wang corr"));
1097 dftGridFreeFuncChoiceStrings.Add(_("B3LYP: hybridized HF/Becke/LYP using VWN"));
1098 dftGridFreeFuncChoiceStrings.Add(_("CAMB: CAMA exchange + Cambridge corr"));
1099 dftGridFreeFuncChoiceStrings.Add(_("XVWN: Xalpha exchange + VWN corr"));
1100 dftGridFreeFuncChoiceStrings.Add(_("XPWLOC: Xalpha exchange + Perdew/Wang corr"));
1101 dftGridFreeFuncChoiceStrings.Add(_("SVWN: Slater exchange + VWN5 corr"));
1102 dftGridFreeFuncChoiceStrings.Add(_("SPWLOC: Slater exchange + PWLOC corr"));
1103 dftGridFreeFuncChoiceStrings.Add(_("WIGNER: Wigner exchange + corr"));
1104 dftGridFreeFuncChoiceStrings.Add(_("WS: Wigner scaled exchange + corr"));
1105 dftGridFreeFuncChoiceStrings.Add(_("WIGEXP: Wigner exponential exchange + corr"));
1106 dftGridFreeFuncChoice = new wxUglyChoice( itemPanel109, ID_GRIDFREE_FUNCTIONAL_CHOICE, wxDefaultPosition, wxDefaultSize, dftGridFreeFuncChoiceStrings, 0 );
1107 dftGridFreeFuncChoice->SetStringSelection(_("Slater exchange"));
1108 funcSizer->Add(dftGridFreeFuncChoice, 0, wxALIGN_LEFT|wxALL, 5);
1109
1110 listBook->AddPage(itemPanel109, _("DFT"));
1111
1112 wxPanel* itemPanel118 = new wxPanel( listBook, ID_FMOPANE, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1113 wxBoxSizer* itemBoxSizer119 = new wxBoxSizer(wxVERTICAL);
1114 itemPanel118->SetSizer(itemBoxSizer119);
1115
1116 mFMOCheck = new wxCheckBox( itemPanel118, ID_FMOACTIVECHECK, _("FMO Active"), wxDefaultPosition, wxDefaultSize, 0 );
1117 mFMOCheck->SetValue(false);
1118 itemBoxSizer119->Add(mFMOCheck, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1119
1120 wxBoxSizer* itemBoxSizer121 = new wxBoxSizer(wxHORIZONTAL);
1121 itemBoxSizer119->Add(itemBoxSizer121, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1122 wxStaticText* itemStaticText122 = new wxStaticText( itemPanel118, wxID_STATIC, _("Number of FMO fragments:"), wxDefaultPosition, wxDefaultSize, 0 );
1123 itemBoxSizer121->Add(itemStaticText122, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1124
1125 mNumFragsEdit = new wxTextCtrl( itemPanel118, ID_FMOFRAGCOUNT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1126 itemBoxSizer121->Add(mNumFragsEdit, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1127
1128 mFMOFragList = new wxGrid( itemPanel118, ID_FMOLIST, wxDefaultPosition, wxSize(220, 150), wxSUNKEN_BORDER|wxVSCROLL|wxALWAYS_SHOW_SB );
1129 mFMOFragList->SetDefaultColSize(100);
1130 mFMOFragList->SetDefaultRowSize(25);
1131 mFMOFragList->SetColLabelSize(25);
1132 mFMOFragList->SetRowLabelSize(80);
1133 mFMOFragList->CreateGrid(4, 1, wxGrid::wxGridSelectCells);
1134 itemBoxSizer119->Add(mFMOFragList, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1135
1136 mFMOGenFragsButton = new wxButton( itemPanel118, ID_FMOFRAGBUTTON, _("Generate fragmentation"), wxDefaultPosition, wxDefaultSize, 0 );
1137 itemBoxSizer119->Add(mFMOGenFragsButton, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1138
1139 listBook->AddPage(itemPanel118, _("FMO"));
1140
1141 wxPanel* itemPanel126 = new wxPanel( listBook, ID_IBMOGUESSPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1142 wxBoxSizer* itemBoxSizer127 = new wxBoxSizer(wxVERTICAL);
1143 itemPanel126->SetSizer(itemBoxSizer127);
1144
1145 wxBoxSizer* itemBoxSizer128 = new wxBoxSizer(wxHORIZONTAL);
1146 itemBoxSizer127->Add(itemBoxSizer128, 0, wxALIGN_LEFT, 5);
1147 wxStaticText* itemStaticText129 = new wxStaticText( itemPanel126, wxID_STATIC, _("Initial Guess:"), wxDefaultPosition, wxDefaultSize, 0 );
1148 itemBoxSizer128->Add(itemStaticText129, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1149
1150 wxArrayString initGuessChoiceStrings;
1151 initGuessChoiceStrings.Add(_("Huckel"));
1152 initGuessChoiceStrings.Add(_("HCore"));
1153 initGuessChoiceStrings.Add(_("MO Read ($VEC)"));
1154 initGuessChoiceStrings.Add(_("MO Saved (DICTNRY)"));
1155 initGuessChoiceStrings.Add(_("Skip"));
1156 initGuessChoice = new wxUglyChoice( itemPanel126, ID_INITGUESS_CHOICE, wxDefaultPosition, wxSize(300, -1), initGuessChoiceStrings, 0 );
1157 initGuessChoice->SetStringSelection(_("Huckel"));
1158 itemBoxSizer128->Add(initGuessChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1159
1160 wxBoxSizer* itemBoxSizer131 = new wxBoxSizer(wxHORIZONTAL);
1161 itemBoxSizer127->Add(itemBoxSizer131, 0, wxALIGN_LEFT|wxALL, 5);
1162 wxStaticText* itemStaticText132 = new wxStaticText( itemPanel126, wxID_STATIC, _("$VEC source:"), wxDefaultPosition, wxDefaultSize, 0 );
1163 itemBoxSizer131->Add(itemStaticText132, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1164
1165 wxArrayString mMOSourceChoiceStrings;
1166 mMOSourceChoice = new wxUglyChoice( itemPanel126, ID_MOGUESS_VECSOURCE_CHOICE, wxDefaultPosition, wxSize(300, -1), mMOSourceChoiceStrings, 0 );
1167 if (InputBuilderWindow::ShowToolTips())
1168 mMOSourceChoice->SetToolTip(_("test tip"));
1169 itemBoxSizer131->Add(mMOSourceChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1170
1171 wxBoxSizer* itemBoxSizer134 = new wxBoxSizer(wxHORIZONTAL);
1172 itemBoxSizer127->Add(itemBoxSizer134, 0, wxALIGN_LEFT|wxALL, 5);
1173 wxStaticText* itemStaticText135 = new wxStaticText( itemPanel126, wxID_STATIC, _("Number of Orbitals to read in:"), wxDefaultPosition, wxDefaultSize, 0 );
1174 itemBoxSizer134->Add(itemStaticText135, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1175
1176 mVecOrbCountText = new wxTextCtrl( itemPanel126, ID_MOGUESS_VECORBCOUNT_TEXT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1177 if (InputBuilderWindow::ShowToolTips())
1178 mVecOrbCountText->SetToolTip(_("$GUESS:NORB - Enter an integer number of orbitals to read in from the $VEC group. The default is to read in the number of occupied orbitals for RHF, UHF, ROHF, and GVB, but you must provide a value for CI and MCSCF runs."));
1179 itemBoxSizer134->Add(mVecOrbCountText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1180
1181 printInitGuessCheck = new wxCheckBox( itemPanel126, ID_PRINTINITGUESS_CHECKBOX, _("Print the initial guess"), wxDefaultPosition, wxDefaultSize, 0 );
1182 printInitGuessCheck->SetValue(false);
1183 if (InputBuilderWindow::ShowToolTips())
1184 printInitGuessCheck->SetToolTip(_("\"$GUESS:PRTMO - When checked GAMESS will write out the initial set of MO vectors to the log file."));
1185 itemBoxSizer127->Add(printInitGuessCheck, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
1186
1187 rotOrbitalsCheck = new wxCheckBox( itemPanel126, ID_ROTORBITALS_CHECKBOX, _("Rotate alpha and beta orbitals"), wxDefaultPosition, wxDefaultSize, 0 );
1188 rotOrbitalsCheck->SetValue(false);
1189 if (InputBuilderWindow::ShowToolTips())
1190 rotOrbitalsCheck->SetToolTip(_("$GUESS:MIX - Click to rotate the alpha and beta HOMO and LUMO orbitals such that the alpha and beta orbital spaces are in-equivalent. Only applicable to UHF runs."));
1191 rotOrbitalsCheck->Enable(false);
1192 itemBoxSizer127->Add(rotOrbitalsCheck, 0, wxALIGN_LEFT|wxALL, 5);
1193
1194 listBook->AddPage(itemPanel126, _("MO Guess"));
1195
1196 wxPanel* itemPanel139 = new wxPanel( listBook, ID_IBHESSOPTSPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1197 wxBoxSizer* itemBoxSizer140 = new wxBoxSizer(wxVERTICAL);
1198 itemPanel139->SetSizer(itemBoxSizer140);
1199
1200 wxBoxSizer* itemBoxSizer141 = new wxBoxSizer(wxHORIZONTAL);
1201 itemBoxSizer140->Add(itemBoxSizer141, 0, wxALIGN_LEFT, 5);
1202 wxArrayString mHessMethodRadioStrings;
1203 mHessMethodRadioStrings.Add(_("Analytic"));
1204 mHessMethodRadioStrings.Add(_("Numeric"));
1205 mHessMethodRadio = new wxRadioBox( itemPanel139, ID_HESSMETHOD_RADIO, _("Method"), wxDefaultPosition, wxDefaultSize, mHessMethodRadioStrings, 1, wxRA_SPECIFY_COLS );
1206 mHessMethodRadio->SetSelection(0);
1207 if (InputBuilderWindow::ShowToolTips())
1208 mHessMethodRadio->SetToolTip(_("$FORCE:METHOD - Choose Numerical to compute the 2nd derivative of the energy numerically by repeated energy and gradient evaluations. Generally you should use numeric hessians only when analytic versions are not available or are to expensive."));
1209 itemBoxSizer141->Add(mHessMethodRadio, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1210
1211 wxBoxSizer* itemBoxSizer143 = new wxBoxSizer(wxHORIZONTAL);
1212 itemBoxSizer141->Add(itemBoxSizer143, 0, wxALIGN_TOP|wxALL, 5);
1213 wxStaticText* itemStaticText144 = new wxStaticText( itemPanel139, wxID_STATIC, _("Displacement size (bohrs):"), wxDefaultPosition, wxDefaultSize, 0 );
1214 itemBoxSizer143->Add(itemStaticText144, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1215
1216 mHESSDisplaceEdit = new wxTextCtrl( itemPanel139, ID_FORCEDISPLACE_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1217 if (InputBuilderWindow::ShowToolTips())
1218 mHESSDisplaceEdit->SetToolTip(_("$FORCE:VIBSIZ Enter a value (in Bohrs) for the size of the displacement for numerical hessians. (default is 0.01)"));
1219 itemBoxSizer143->Add(mHESSDisplaceEdit, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1220
1221 mHessDblDiffCheck = new wxCheckBox( itemPanel139, ID_HESSDOUBLEDIFFCHECK, _("Double differenced hessian"), wxDefaultPosition, wxDefaultSize, 0 );
1222 mHessDblDiffCheck->SetValue(false);
1223 if (InputBuilderWindow::ShowToolTips())
1224 mHessDblDiffCheck->SetToolTip(_("$FORCE:NVIB - Click to double difference the numeric hessian. This will nearly double the number of energy and gradients needed, but will give better accuracy. Recomended for transition state searchs."));
1225 itemBoxSizer140->Add(mHessDblDiffCheck, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
1226
1227 mHessPurifyCheck = new wxCheckBox( itemPanel139, ID_HESSPURIFYCHECK, _("Purify hessian"), wxDefaultPosition, wxDefaultSize, 0 );
1228 mHessPurifyCheck->SetValue(false);
1229 if (InputBuilderWindow::ShowToolTips())
1230 mHessPurifyCheck->SetToolTip(_("$FORCE:PURIFY - Click to transform the hessian to internal coordinates and then back to remove any rotations or translations."));
1231 itemBoxSizer140->Add(mHessPurifyCheck, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
1232
1233 mHessPrintIntFCCheck = new wxCheckBox( itemPanel139, ID_HESSPRTINTFC_CHECK, _("Print internal force constants"), wxDefaultPosition, wxDefaultSize, 0 );
1234 mHessPrintIntFCCheck->SetValue(false);
1235 if (InputBuilderWindow::ShowToolTips())
1236 mHessPrintIntFCCheck->SetToolTip(_("$FORCE:PRTIFC - Click to print out the internal coordinate force constants."));
1237 itemBoxSizer140->Add(mHessPrintIntFCCheck, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
1238
1239 mHessVibAnlCheck = new wxCheckBox( itemPanel139, ID_HESSVIBANL_CHECK, _("Vibrational Analysis"), wxDefaultPosition, wxDefaultSize, 0 );
1240 mHessVibAnlCheck->SetValue(false);
1241 if (InputBuilderWindow::ShowToolTips())
1242 mHessVibAnlCheck->SetToolTip(_("$FORCE:VIBANL - Click to perform vibrational analysis. This is very inexpensive once the force constant matrix is known."));
1243 itemBoxSizer140->Add(mHessVibAnlCheck, 0, wxGROW|wxALL, 5);
1244
1245 wxBoxSizer* itemBoxSizer150 = new wxBoxSizer(wxHORIZONTAL);
1246 itemBoxSizer140->Add(itemBoxSizer150, 0, wxGROW, 5);
1247 wxStaticText* itemStaticText151 = new wxStaticText( itemPanel139, wxID_STATIC, _("Frequency scale factor:"), wxDefaultPosition, wxDefaultSize, 0 );
1248 itemBoxSizer150->Add(itemStaticText151, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1249
1250 mHessFreqScaleEdit = new wxTextCtrl( itemPanel139, ID_HESSFREQSCALE_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1251 if (InputBuilderWindow::ShowToolTips())
1252 mHessFreqScaleEdit->SetToolTip(_("$FORCE:SCLFAC Enter a floating point value representing the frequency scaling factor to use for the thermochemical analysis. (unscaled frequencies are always printed)."));
1253 itemBoxSizer150->Add(mHessFreqScaleEdit, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1254
1255 listBook->AddPage(itemPanel139, _("Hess. Options"));
1256
1257 wxPanel* itemPanel153 = new wxPanel( listBook, ID_IBMISCPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1258 wxBoxSizer* itemBoxSizer154 = new wxBoxSizer(wxVERTICAL);
1259 itemPanel153->SetSizer(itemBoxSizer154);
1260
1261 wxStaticText* itemStaticText155 = new wxStaticText( itemPanel153, wxID_STATIC, _("GAMESS interface to other codes."), wxDefaultPosition, wxDefaultSize, 0 );
1262 itemBoxSizer154->Add(itemStaticText155, 0, wxALIGN_LEFT|wxALL, 5);
1263
1264 wxStaticBox* itemStaticBoxSizer156Static = new wxStaticBox(itemPanel153, wxID_ANY, wxEmptyString);
1265 wxStaticBoxSizer* itemStaticBoxSizer156 = new wxStaticBoxSizer(itemStaticBoxSizer156Static, wxVERTICAL);
1266 itemBoxSizer154->Add(itemStaticBoxSizer156, 0, wxALIGN_LEFT|wxALL, 5);
1267 mMolPltCheck = new wxCheckBox( itemPanel153, ID_MOLPLT_CHECK, _("MolPlt"), wxDefaultPosition, wxDefaultSize, 0 );
1268 mMolPltCheck->SetValue(false);
1269 if (InputBuilderWindow::ShowToolTips())
1270 mMolPltCheck->SetToolTip(_("$CONTRL:MOLPLT=.FALSE. - Click to punch an input deck (to the .dat file) for the MolPlt X-windows program. Note MacMolPlt can also read these files."));
1271 itemStaticBoxSizer156->Add(mMolPltCheck, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
1272
1273 mPltOrbCheck = new wxCheckBox( itemPanel153, ID_PLTORB_CHECK, _("PltOrb"), wxDefaultPosition, wxDefaultSize, 0 );
1274 mPltOrbCheck->SetValue(false);
1275 itemStaticBoxSizer156->Add(mPltOrbCheck, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
1276
1277 aimpacCheck = new wxCheckBox( itemPanel153, ID_AIMPAC_CHECK, _("Atoms In Molecules (AIMPAC)"), wxDefaultPosition, wxDefaultSize, 0 );
1278 aimpacCheck->SetValue(false);
1279 itemStaticBoxSizer156->Add(aimpacCheck, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
1280
1281 rpacCheck = new wxCheckBox( itemPanel153, ID_RPAC_CHECK, _("RPAC"), wxDefaultPosition, wxDefaultSize, 0 );
1282 rpacCheck->SetValue(false);
1283 itemStaticBoxSizer156->Add(rpacCheck, 0, wxALIGN_LEFT|wxALL, 5);
1284
1285 wxArrayString mMiscProgRadioStrings;
1286 mMiscProgRadioStrings.Add(_("None"));
1287 mMiscProgRadioStrings.Add(_("Hondo 8.2"));
1288 mMiscProgRadioStrings.Add(_("MELDF"));
1289 mMiscProgRadioStrings.Add(_("GAMESS (UK version)"));
1290 mMiscProgRadioStrings.Add(_("Gaussian 9x"));
1291 mMiscProgRadioStrings.Add(_("All"));
1292 mMiscProgRadio = new wxRadioBox( itemPanel153, ID_MISC_PROG_RADIO, _("These Force a Check Run Type"), wxDefaultPosition, wxDefaultSize, mMiscProgRadioStrings, 1, wxRA_SPECIFY_COLS );
1293 mMiscProgRadio->SetSelection(0);
1294 if (InputBuilderWindow::ShowToolTips())
1295 mMiscProgRadio->SetToolTip(_("$CONTRL:FRIEND - Click to punch input decks for the programs listed in this box."));
1296 itemBoxSizer154->Add(mMiscProgRadio, 0, wxALIGN_LEFT|wxALL, 5);
1297
1298 listBook->AddPage(itemPanel153, _("Misc. Prefs"));
1299
1300 wxPanel* itemPanel162 = new wxPanel( listBook, ID_IBMP2PANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1301 wxBoxSizer* itemBoxSizer163 = new wxBoxSizer(wxVERTICAL);
1302 itemPanel162->SetSizer(itemBoxSizer163);
1303
1304 wxFlexGridSizer* itemFlexGridSizer164 = new wxFlexGridSizer(0, 2, 0, 0);
1305 itemBoxSizer163->Add(itemFlexGridSizer164, 0, wxGROW, 5);
1306 wxStaticText* itemStaticText165 = new wxStaticText( itemPanel162, wxID_STATIC, _("# of core electrons:"), wxDefaultPosition, wxDefaultSize, 0 );
1307 itemFlexGridSizer164->Add(itemStaticText165, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
1308
1309 mMP2CoreEleEdit = new wxTextCtrl( itemPanel162, ID_MP2_CORE_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1310 if (InputBuilderWindow::ShowToolTips())
1311 mMP2CoreEleEdit->SetToolTip(_("$MP2:NACORE - Enter an integer value for the number of electrons to leave out of the MP2 calculation."));
1312 itemFlexGridSizer164->Add(mMP2CoreEleEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
1313
1314 wxStaticText* itemStaticText167 = new wxStaticText( itemPanel162, wxID_STATIC, _("Memory (in words):"), wxDefaultPosition, wxDefaultSize, 0 );
1315 itemFlexGridSizer164->Add(itemStaticText167, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
1316
1317 mMP2MemEdit = new wxTextCtrl( itemPanel162, ID_MP2MEM_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1318 if (InputBuilderWindow::ShowToolTips())
1319 mMP2MemEdit->SetToolTip(_("$MP2:NWORD - Enter an integer number for the number of words of memory to use in the MP2 calculation. A value of 0 uses all available memory."));
1320 itemFlexGridSizer164->Add(mMP2MemEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
1321
1322 wxStaticText* itemStaticText169 = new wxStaticText( itemPanel162, wxID_STATIC, _("Integral retention cutoff:"), wxDefaultPosition, wxDefaultSize, 0 );
1323 itemFlexGridSizer164->Add(itemStaticText169, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1324
1325 mMP2IntCutoffEdit = new wxTextCtrl( itemPanel162, ID_MP2INTCUTOFF_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1326 mMP2IntCutoffEdit->SetHelpText(_("$MP2:CUTOFF - Enter a floating point value for the integral retention cutoff. (default is 1.0e-9)"));
1327 if (InputBuilderWindow::ShowToolTips())
1328 mMP2IntCutoffEdit->SetToolTip(_("$MP2:CUTOFF - Enter a floating point value for the integral retention cutoff. (default is 1.0e-9)"));
1329 itemFlexGridSizer164->Add(mMP2IntCutoffEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
1330
1331 mLMOMP2Check = new wxCheckBox( itemPanel162, ID_LMOMP2_CHECK, _("Use Localized Orbitals"), wxDefaultPosition, wxDefaultSize, 0 );
1332 mLMOMP2Check->SetValue(false);
1333 itemBoxSizer163->Add(mLMOMP2Check, 0, wxGROW|wxALL, 5);
1334
1335 mMP2PropCheck = new wxCheckBox( itemPanel162, ID_MP2PROP_CHECK, _("Compute MP2 properties"), wxDefaultPosition, wxDefaultSize, 0 );
1336 mMP2PropCheck->SetValue(false);
1337 if (InputBuilderWindow::ShowToolTips())
1338 mMP2PropCheck->SetToolTip(_("$MP2:MP2PRP - a flag to turn on property computation for MP2 energy jobs. This is much more expensive than a plain energy. Properties are always computed during gradient runs where they are almost free."));
1339 itemBoxSizer163->Add(mMP2PropCheck, 0, wxALIGN_LEFT|wxALL, 5);
1340
1341 wxArrayString mMP2TransRadioStrings;
1342 mMP2TransRadioStrings.Add(_("Segmented transformation"));
1343 mMP2TransRadioStrings.Add(_("Two phase bin sort"));
1344 mMP2TransRadio = new wxRadioBox( itemPanel162, ID_MP2TRANS_RADIO, _("Transformation method"), wxDefaultPosition, wxDefaultSize, mMP2TransRadioStrings, 1, wxRA_SPECIFY_COLS );
1345 mMP2TransRadio->SetSelection(0);
1346 if (InputBuilderWindow::ShowToolTips())
1347 mMP2TransRadio->SetToolTip(_("$MP2:Method - The Two phase bin sort is a more conventional method requiring more disk space, but less memory. It is required when using localized orbitals."));
1348 itemBoxSizer163->Add(mMP2TransRadio, 0, wxALIGN_LEFT|wxALL, 5);
1349
1350 wxArrayString mMP2AOStorageRadioStrings;
1351 mMP2AOStorageRadioStrings.Add(_("Duplicated on each node"));
1352 mMP2AOStorageRadioStrings.Add(_("Distributed across all nodes"));
1353 mMP2AOStorageRadio = new wxRadioBox( itemPanel162, ID_MP2AOSTORAGE_RADIO, _("AO integral storage"), wxDefaultPosition, wxDefaultSize, mMP2AOStorageRadioStrings, 1, wxRA_SPECIFY_COLS );
1354 mMP2AOStorageRadio->SetSelection(0);
1355 if (InputBuilderWindow::ShowToolTips())
1356 mMP2AOStorageRadio->SetToolTip(_("$MP2:AOINTS -Choose the 2nd to distribute AO integrals over all nodes. This requires less disk space, but should only be used on parallel computers with high speed communications."));
1357 itemBoxSizer163->Add(mMP2AOStorageRadio, 0, wxALIGN_LEFT|wxALL, 5);
1358
1359 listBook->AddPage(itemPanel162, _("MP2 Options"));
1360
1361 wxPanel* itemPanel175 = new wxPanel( listBook, ID_IBSCBOPTSPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1362 wxBoxSizer* itemBoxSizer176 = new wxBoxSizer(wxVERTICAL);
1363 itemPanel175->SetSizer(itemBoxSizer176);
1364
1365 mDirectSCFCheck = new wxCheckBox( itemPanel175, ID_DIRECTSCF_CHECK, _("Direct SCF"), wxDefaultPosition, wxDefaultSize, 0 );
1366 mDirectSCFCheck->SetValue(false);
1367 if (InputBuilderWindow::ShowToolTips())
1368 mDirectSCFCheck->SetToolTip(_("$SCF:DIRSCF - Direct SCF will be used to calculate the AO integrals. This will also activate direct MP2 if MP2 is requested."));
1369 itemBoxSizer176->Add(mDirectSCFCheck, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
1370
1371 mFDiffCheck = new wxCheckBox( itemPanel175, ID_FDIFF_CHECK, _("Compute only change in Fock Matrix"), wxDefaultPosition, wxDefaultSize, 0 );
1372 mFDiffCheck->SetValue(false);
1373 if (InputBuilderWindow::ShowToolTips())
1374 mFDiffCheck->SetToolTip(_("$SCF:FDIFF - When checked only the change since the previous iteration in the Fock matrices will be computed. This saves a large amount of CPU time, but may not fully converge cases with a lot of diffuse functions."));
1375 mFDiffCheck->Enable(false);
1376 itemBoxSizer176->Add(mFDiffCheck, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
1377
1378 mUHFNOCheck = new wxCheckBox( itemPanel175, ID_UHF_NO_CHECK, _("Generate UHF Natural Orbitals"), wxDefaultPosition, wxDefaultSize, 0 );
1379 mUHFNOCheck->SetValue(false);
1380 if (InputBuilderWindow::ShowToolTips())
1381 mUHFNOCheck->SetToolTip(_("$SCF:UHFNOS - Click to generate the natural orbitals of the UHF function. This option only applies to UHF wavefunctions."));
1382 mUHFNOCheck->Enable(false);
1383 itemBoxSizer176->Add(mUHFNOCheck, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP, 5);
1384
1385 wxBoxSizer* itemBoxSizer180 = new wxBoxSizer(wxHORIZONTAL);
1386 itemBoxSizer176->Add(itemBoxSizer180, 0, wxALIGN_LEFT, 5);
1387 wxStaticText* itemStaticText181 = new wxStaticText( itemPanel175, wxID_STATIC, _("SCF convergence criteria: 10^"), wxDefaultPosition, wxDefaultSize, 0 );
1388 itemBoxSizer180->Add(itemStaticText181, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1389
1390 mSCFConvSpin = new wxSpinCtrl( itemPanel175, ID_SCF_CONV_SPIN, wxT("5"), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 1, 2147483647, 5 );
1391 if (InputBuilderWindow::ShowToolTips())
1392 mSCFConvSpin->SetToolTip(_("$SCF:NCONV - Enter an integer value to use as the power (in 10**(-n)) for the SCF density convergance criteria. Setting this to less than 5 (the default) will give questionable gradients."));
1393 itemBoxSizer180->Add(mSCFConvSpin, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1394
1395 listBook->AddPage(itemPanel175, _("SCF Options"));
1396
1397 wxPanel* itemPanel183 = new wxPanel( listBook, ID_IBSTATPOINTPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1398 wxBoxSizer* itemBoxSizer184 = new wxBoxSizer(wxVERTICAL);
1399 itemPanel183->SetSizer(itemBoxSizer184);
1400
1401 wxFlexGridSizer* itemFlexGridSizer185 = new wxFlexGridSizer(0, 2, 0, 0);
1402 itemBoxSizer184->Add(itemFlexGridSizer185, 0, wxGROW, 5);
1403 wxStaticText* itemStaticText186 = new wxStaticText( itemPanel183, wxID_STATIC, _("Max. number of steps:"), wxDefaultPosition, wxDefaultSize, 0 );
1404 itemFlexGridSizer185->Add(itemStaticText186, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
1405
1406 mMaxStepCountEdit = new wxTextCtrl( itemPanel183, ID_MAXSTEPCOUNT_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1407 if (InputBuilderWindow::ShowToolTips())
1408 mMaxStepCountEdit->SetToolTip(_("$STATPT:NSTEP=An integer representing the maximum number of steps to take before cleanly stopping the run (after punching out all needed restart data). Most such runs can be restarted."));
1409 itemFlexGridSizer185->Add(mMaxStepCountEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
1410
1411 wxStaticText* itemStaticText188 = new wxStaticText( itemPanel183, wxID_STATIC, _("Gradient convergance criteria:"), wxDefaultPosition, wxDefaultSize, 0 );
1412 itemFlexGridSizer185->Add(itemStaticText188, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1413
1414 mGradConvEdit = new wxTextCtrl( itemPanel183, ID_GRADCONVCRITERIA_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1415 if (InputBuilderWindow::ShowToolTips())
1416 mGradConvEdit->SetToolTip(_("$STATPT:OPTTOL=a floating point value representing the convergance criteria for the gradient (in Hartree/Bohr)."));
1417 itemFlexGridSizer185->Add(mGradConvEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
1418
1419 wxBoxSizer* itemBoxSizer190 = new wxBoxSizer(wxHORIZONTAL);
1420 itemBoxSizer184->Add(itemBoxSizer190, 0, wxGROW, 5);
1421 wxStaticText* itemStaticText191 = new wxStaticText( itemPanel183, wxID_STATIC, _("Optimization method:"), wxDefaultPosition, wxDefaultSize, 0 );
1422 itemBoxSizer190->Add(itemStaticText191, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1423
1424 wxArrayString mOptMethodChoiceStrings;
1425 mOptMethodChoiceStrings.Add(_("Newton-Raphson"));
1426 mOptMethodChoiceStrings.Add(_("Rational Function Optimization"));
1427 mOptMethodChoiceStrings.Add(_("Quadratic Approximation"));
1428 mOptMethodChoiceStrings.Add(_("Schlegel (quasi-NR)"));
1429 mOptMethodChoiceStrings.Add(_("Constrained Optimization"));
1430 mOptMethodChoice = new wxUglyChoice( itemPanel183, ID_OPTMETHOD_CHOICE, wxDefaultPosition, wxDefaultSize, mOptMethodChoiceStrings, 0 );
1431 if (InputBuilderWindow::ShowToolTips())
1432 mOptMethodChoice->SetToolTip(_("$STATPT:METHOD The algorithm used to drive the gradient to zero."));
1433 itemBoxSizer190->Add(mOptMethodChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1434
1435 wxBoxSizer* itemBoxSizer193 = new wxBoxSizer(wxHORIZONTAL);
1436 itemBoxSizer184->Add(itemBoxSizer193, 0, wxGROW|wxALL, 5);
1437 wxFlexGridSizer* itemFlexGridSizer194 = new wxFlexGridSizer(0, 2, 0, 0);
1438 itemBoxSizer193->Add(itemFlexGridSizer194, 0, wxGROW, 5);
1439 wxStaticText* itemStaticText195 = new wxStaticText( itemPanel183, wxID_STATIC, _("Initial step size:"), wxDefaultPosition, wxDefaultSize, 0 );
1440 itemFlexGridSizer194->Add(itemStaticText195, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
1441
1442 mInitStepSizeEdit = new wxTextCtrl( itemPanel183, ID_INITSTEPSIZE_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1443 if (InputBuilderWindow::ShowToolTips())
1444 mInitStepSizeEdit->SetToolTip(_("$STATPT:DXMAX = a floating point value representing the initial size of the step"));
1445 itemFlexGridSizer194->Add(mInitStepSizeEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
1446
1447 wxStaticText* itemStaticText197 = new wxStaticText( itemPanel183, wxID_STATIC, _("Min. step size:"), wxDefaultPosition, wxDefaultSize, 0 );
1448 itemFlexGridSizer194->Add(itemStaticText197, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP, 5);
1449
1450 mMinStepSizeEdit = new wxTextCtrl( itemPanel183, ID_MINSTEPSIZE_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1451 if (InputBuilderWindow::ShowToolTips())
1452 mMinStepSizeEdit->SetToolTip(_("$STATPT:TRMIN= the minimum size of the step."));
1453 itemFlexGridSizer194->Add(mMinStepSizeEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5);
1454
1455 wxStaticText* itemStaticText199 = new wxStaticText( itemPanel183, wxID_STATIC, _("Max. step size:"), wxDefaultPosition, wxDefaultSize, 0 );
1456 itemFlexGridSizer194->Add(itemStaticText199, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1457
1458 mMaxStepSizeEdit = new wxTextCtrl( itemPanel183, ID_MAXSTEPSIZE_CHECK, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1459 if (InputBuilderWindow::ShowToolTips())
1460 mMaxStepSizeEdit->SetToolTip(_("$STATPT:TRMAX= the maximum size of the step."));
1461 itemFlexGridSizer194->Add(mMaxStepSizeEdit, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5);
1462
1463 wxBoxSizer* itemBoxSizer201 = new wxBoxSizer(wxVERTICAL);
1464 itemBoxSizer193->Add(itemBoxSizer201, 0, wxGROW, 5);
1465 mUpdateStepSizeCheck = new wxCheckBox( itemPanel183, ID_UPDATESTEPSIZE_CHECK, _("Update Step Size"), wxDefaultPosition, wxDefaultSize, 0 );
1466 mUpdateStepSizeCheck->SetValue(false);
1467 if (InputBuilderWindow::ShowToolTips())
1468 mUpdateStepSizeCheck->SetToolTip(_("$STATPT:TRUPD The step size will be allowed to change within the range given at the left."));
1469 itemBoxSizer201->Add(mUpdateStepSizeCheck, 0, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
1470
1471 mIsStatPtCheck = new wxCheckBox( itemPanel183, ID_STATPT_CHECK, _("Stationary Pt."), wxDefaultPosition, wxDefaultSize, 0 );
1472 mIsStatPtCheck->SetValue(false);
1473 if (InputBuilderWindow::ShowToolTips())
1474 mIsStatPtCheck->SetToolTip(_("$STATPT:STPT If checked the initial geometry will be considered a stationary point and the jump away from the initial geometry will be given by the step size below."));
1475 itemBoxSizer201->Add(mIsStatPtCheck, 0, wxGROW|wxALL, 5);
1476
1477 wxBoxSizer* itemBoxSizer204 = new wxBoxSizer(wxHORIZONTAL);
1478 itemBoxSizer201->Add(itemBoxSizer204, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 0);
1479 wxStaticText* itemStaticText205 = new wxStaticText( itemPanel183, wxID_STATIC, _("Jump Size:"), wxDefaultPosition, wxDefaultSize, 0 );
1480 itemBoxSizer204->Add(itemStaticText205, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1481
1482 mStatPtJumpSizeEdit = new wxTextCtrl( itemPanel183, ID_STATPT_JUMP_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1483 if (InputBuilderWindow::ShowToolTips())
1484 mStatPtJumpSizeEdit->SetToolTip(_("$STATPT:STSTEP= the size of the step taken away from stationary points.\n"));
1485 itemBoxSizer204->Add(mStatPtJumpSizeEdit, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1486
1487 wxBoxSizer* itemBoxSizer207 = new wxBoxSizer(wxHORIZONTAL);
1488 itemBoxSizer184->Add(itemBoxSizer207, 0, wxGROW, 5);
1489 wxArrayString mInitHessRadioStrings;
1490 mInitHessRadioStrings.Add(_("Guess (+ definite)"));
1491 mInitHessRadioStrings.Add(_("Read (from $HESS)"));
1492 mInitHessRadioStrings.Add(_("Calculate"));
1493 mInitHessRadio = new wxRadioBox( itemPanel183, ID_INIT_HESS_RADIO, _("Initial Hessian"), wxDefaultPosition, wxDefaultSize, mInitHessRadioStrings, 1, wxRA_SPECIFY_COLS );
1494 mInitHessRadio->SetSelection(0);
1495 if (InputBuilderWindow::ShowToolTips())
1496 mInitHessRadio->SetToolTip(_("$STATPT:HESS=The source of the initial hessian matrix."));
1497 itemBoxSizer207->Add(mInitHessRadio, 0, wxGROW|wxALL, 5);
1498
1499 wxBoxSizer* itemBoxSizer209 = new wxBoxSizer(wxVERTICAL);
1500 itemBoxSizer207->Add(itemBoxSizer209, 0, wxALIGN_TOP|wxALL, 0);
1501 wxBoxSizer* itemBoxSizer210 = new wxBoxSizer(wxHORIZONTAL);
1502 itemBoxSizer209->Add(itemBoxSizer210, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 0);
1503 wxStaticText* itemStaticText211 = new wxStaticText( itemPanel183, wxID_STATIC, _("Recalc. Hess every"), wxDefaultPosition, wxDefaultSize, 0 );
1504 itemBoxSizer210->Add(itemStaticText211, 0, wxALIGN_TOP|wxLEFT|wxTOP|wxBOTTOM, 10);
1505
1506 mHessRecalcEdit = new wxTextCtrl( itemPanel183, ID_HESS_RECALC_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1507 if (InputBuilderWindow::ShowToolTips())
1508 mHessRecalcEdit->SetToolTip(_("$STATPT:IHREP=an integer representing how often the hessian will be fully recalculated. A value of zero is normal and means never fully recalculate the hessian. The hessian will be updated at every step."));
1509 itemBoxSizer210->Add(mHessRecalcEdit, 0, wxALIGN_TOP|wxALL, 5);
1510
1511 wxStaticText* itemStaticText213 = new wxStaticText( itemPanel183, wxID_STATIC, _("steps."), wxDefaultPosition, wxDefaultSize, 0 );
1512 itemBoxSizer210->Add(itemStaticText213, 0, wxALIGN_TOP|wxTOP|wxBOTTOM, 10);
1513
1514 wxBoxSizer* itemBoxSizer214 = new wxBoxSizer(wxHORIZONTAL);
1515 itemBoxSizer209->Add(itemBoxSizer214, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 0);
1516 wxStaticText* itemStaticText215 = new wxStaticText( itemPanel183, wxID_STATIC, _("Follow which mode?"), wxDefaultPosition, wxDefaultSize, 0 );
1517 itemBoxSizer214->Add(itemStaticText215, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1518
1519 mStatPtModeEdit = new wxTextCtrl( itemPanel183, ID_STATPT_MODE_EDIT, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0, wxTextValidator(wxFILTER_NUMERIC));
1520 if (InputBuilderWindow::ShowToolTips())
1521 mStatPtModeEdit->SetToolTip(_("$STATPT:IFOLOW Only applicable to SADPOINT runs and indicates which mode to maximize."));
1522 itemBoxSizer214->Add(mStatPtModeEdit, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1523
1524 mPrintOrbsCheck = new wxCheckBox( itemPanel183, ID_PRINTORBS_CHECK, _("Print Orbs at each iteration"), wxDefaultPosition, wxDefaultSize, 0 );
1525 mPrintOrbsCheck->SetValue(false);
1526 if (InputBuilderWindow::ShowToolTips())
1527 mPrintOrbsCheck->SetToolTip(_("If checked the optimized orbitals will be output in the log file for each geometry. Otherwise the default is to output them for the 1st and last geometry."));
1528 itemBoxSizer184->Add(mPrintOrbsCheck, 0, wxGROW|wxALL, 5);
1529
1530 wxCheckBox* itemCheckBox218 = new wxCheckBox( itemPanel183, ID_HESSEND_CHECK, _("Compute a hessian on the final optimized structure"), wxDefaultPosition, wxDefaultSize, 0 );
1531 itemCheckBox218->SetValue(false);
1532 if (InputBuilderWindow::ShowToolTips())
1533 itemCheckBox218->SetToolTip(_("Check to automatically compute a hessian for the optimized structure (HSSEND)"));
1534 itemBoxSizer184->Add(itemCheckBox218, 0, wxGROW|wxALL, 3);
1535
1536 listBook->AddPage(itemPanel183, _("Stat. Point"));
1537
1538 wxPanel* itemPanel219 = new wxPanel( listBook, ID_SUMMARYPANEL, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
1539 wxBoxSizer* itemBoxSizer220 = new wxBoxSizer(wxVERTICAL);
1540 itemPanel219->SetSizer(itemBoxSizer220);
1541
1542 wxBoxSizer* itemBoxSizer221 = new wxBoxSizer(wxHORIZONTAL);
1543 itemBoxSizer220->Add(itemBoxSizer221, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1544 wxStaticText* itemStaticText222 = new wxStaticText( itemPanel219, wxID_STATIC, _("Title:"), wxDefaultPosition, wxDefaultSize, 0 );
1545 itemBoxSizer221->Add(itemStaticText222, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1546
1547 mTitleText = new wxTextCtrl( itemPanel219, ID_SUMMARY_TITLE, wxEmptyString, wxDefaultPosition, wxSize(400, -1), 0 );
1548 mTitleText->Enable(false);
1549 itemBoxSizer221->Add(mTitleText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1550
1551 wxBoxSizer* itemBoxSizer224 = new wxBoxSizer(wxHORIZONTAL);
1552 itemBoxSizer220->Add(itemBoxSizer224, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1553 wxStaticText* itemStaticText225 = new wxStaticText( itemPanel219, wxID_STATIC, _("Basis Set:"), wxDefaultPosition, wxDefaultSize, 0 );
1554 itemBoxSizer224->Add(itemStaticText225, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1555
1556 mBasisSetText = new wxTextCtrl( itemPanel219, ID_SUMMARY_BASISSET, wxEmptyString, wxDefaultPosition, wxSize(400, -1), 0 );
1557 mBasisSetText->Enable(false);
1558 itemBoxSizer224->Add(mBasisSetText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1559
1560 wxBoxSizer* itemBoxSizer227 = new wxBoxSizer(wxHORIZONTAL);
1561 itemBoxSizer220->Add(itemBoxSizer227, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1562 wxStaticText* itemStaticText228 = new wxStaticText( itemPanel219, wxID_STATIC, _("SCF Type:"), wxDefaultPosition, wxDefaultSize, 0 );
1563 itemBoxSizer227->Add(itemStaticText228, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1564
1565 mSCFTypeText = new wxTextCtrl( itemPanel219, ID_SUMMARY_SCFTYPE, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
1566 mSCFTypeText->Enable(false);
1567 itemBoxSizer227->Add(mSCFTypeText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1568
1569 wxBoxSizer* itemBoxSizer230 = new wxBoxSizer(wxHORIZONTAL);
1570 itemBoxSizer220->Add(itemBoxSizer230, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1571 wxStaticText* itemStaticText231 = new wxStaticText( itemPanel219, wxID_STATIC, _("Run Type:"), wxDefaultPosition, wxDefaultSize, 0 );
1572 itemBoxSizer230->Add(itemStaticText231, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1573
1574 mRunTypeText = new wxTextCtrl( itemPanel219, ID_SUMMARY_RUNTYPE, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
1575 mRunTypeText->Enable(false);
1576 itemBoxSizer230->Add(mRunTypeText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1577
1578 wxBoxSizer* itemBoxSizer233 = new wxBoxSizer(wxHORIZONTAL);
1579 itemBoxSizer220->Add(itemBoxSizer233, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1580 wxStaticText* itemStaticText234 = new wxStaticText( itemPanel219, wxID_STATIC, _("Molecular Point Group:"), wxDefaultPosition, wxDefaultSize, 0 );
1581 itemBoxSizer233->Add(itemStaticText234, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1582
1583 mPointGroupText = new wxTextCtrl( itemPanel219, ID_SUMMARY_PG, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );
1584 mPointGroupText->Enable(false);
1585 itemBoxSizer233->Add(mPointGroupText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1586
1587 wxBoxSizer* itemBoxSizer236 = new wxBoxSizer(wxHORIZONTAL);
1588 itemBoxSizer220->Add(itemBoxSizer236, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
1589 wxStaticText* itemStaticText237 = new wxStaticText( itemPanel219, wxID_STATIC, _("Electron Correlation"), wxDefaultPosition, wxDefaultSize, 0 );
1590 itemBoxSizer236->Add(itemStaticText237, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1591
1592 mElectronCorr = new wxTextCtrl( itemPanel219, ID_SUMMARY_ELEC, wxEmptyString, wxDefaultPosition, wxSize(200, -1), 0 );
1593 mElectronCorr->Enable(false);
1594 itemBoxSizer236->Add(mElectronCorr, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1595
1596 listBook->AddPage(itemPanel219, _("Summary"));
1597
1598 itemBoxSizer4->Add(listBook, 1, wxGROW|wxALL, 2);
1599
1600 wxBoxSizer* itemBoxSizer239 = new wxBoxSizer(wxHORIZONTAL);
1601 itemBoxSizer4->Add(itemBoxSizer239, 0, wxGROW, 5);
1602
1603 defaultsBtn = new wxButton( itemPanel3, ID_DEFAULTSBUTTON, _("Use Defaults"), wxDefaultPosition, wxDefaultSize, 0 );
1604 itemBoxSizer239->Add(defaultsBtn, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1605
1606 revertBtn = new wxButton( itemPanel3, ID_REVERTBUTTON, _("Revert"), wxDefaultPosition, wxDefaultSize, 0 );
1607 itemBoxSizer239->Add(revertBtn, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1608
1609 writeBtn = new wxButton( itemPanel3, ID_WRITEFILEBUTTON, _("Write File"), wxDefaultPosition, wxDefaultSize, 0 );
1610 itemBoxSizer239->Add(writeBtn, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5);
1611
1612 wxButton* lWriteEditButton = new wxButton( itemPanel3, ID_WRITE_EDIT_BUTTON, _("Edit and Save"), wxDefaultPosition, wxDefaultSize, 0 );
1613 if (InputBuilderWindow::ShowToolTips())
1614 lWriteEditButton->SetToolTip(_("Open the created input file in a text editor allowing you to save the result."));
1615 itemBoxSizer239->Add(lWriteEditButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1616
1617 advanced_button = new wxButton( itemPanel3, ID_ADVANCEDBUTTON, _("Advanced"), wxDefaultPosition, wxDefaultSize, 0 );
1618 advanced_button->Show(false);
1619 itemBoxSizer239->Add(advanced_button, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1620
1621 wxStdDialogButtonSizer* itemStdDialogButtonSizer244 = new wxStdDialogButtonSizer;
1622
1623 itemBoxSizer239->Add(itemStdDialogButtonSizer244, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5);
1624 wxButton* itemButton245 = new wxButton( itemPanel3, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
1625 itemStdDialogButtonSizer244->AddButton(itemButton245);
1626
1627 wxButton* itemButton246 = new wxButton( itemPanel3, wxID_OK, _("&OK"), wxDefaultPosition, wxDefaultSize, 0 );
1628 itemStdDialogButtonSizer244->AddButton(itemButton246);
1629
1630 itemStdDialogButtonSizer244->Realize();
1631
1632 ////@end InputBuilderWindow content construction
1633
1634 wxMenuBar* menuBar = new wxMenuBar;
1635 wxMenu* itemMenu3 = new wxMenu;
1636 itemMenu3->Append(wxID_NEW, _("&New\tCtrl+N"), _T(""), wxITEM_NORMAL);
1637 itemMenu3->Append(wxID_OPEN, _("&Open ...\tCtrl+O"), _T(""), wxITEM_NORMAL);
1638 itemMenu3->Append(wxID_CLOSE, _("&Close\tCtrl+W"), _T(""), wxITEM_NORMAL);
1639 menuBar->Append(itemMenu3, _("File"));
1640 wxMenu* lEditMenu = new wxMenu;
1641 lEditMenu->Append(wxID_UNDO, _("&Undo\tCtrl+Z"), _T(""), wxITEM_NORMAL);
1642 lEditMenu->AppendSeparator();
1643 lEditMenu->Append(wxID_CUT, _("Cu&t\tCtrl+X"), _T(""), wxITEM_NORMAL);
1644 lEditMenu->Append(wxID_COPY, _("&Copy\tCtrl+C"), _T(""), wxITEM_NORMAL);
1645 lEditMenu->Append(wxID_PASTE, _("&Paste\tCtrl+V"), _T(""), wxITEM_NORMAL);
1646 lEditMenu->AppendSeparator();
1647 lEditMenu->Append(wxID_SELECTALL, _("&Select all\tCtrl+A"), _T(""), wxITEM_NORMAL);
1648 lEditMenu->AppendSeparator();
1649 lEditMenu->Append(wxID_PREFERENCES, wxT("Global Pr&eferences"));
1650 menuBar->Append(lEditMenu, _("Edit"));
1651
1652 wxMenu * menuWindow = new wxMenu;
1653 menuWindow->Append(MMP_MOLECULEDISPLAYWINDOW, wxT("&Molecule Display"), _("The primary molecule display"));
1654 menuWindow->Append(MMP_BONDSWINDOW, wxT("&Bonds"), _("View/edit the bonding within the molecule"));
1655 menuWindow->Append(MMP_COORDSWINDOW, wxT("&Coordinates"), _("View/edit cartesian or internal coordinates"));
1656 menuWindow->Append(MMP_ENERGYPLOTWINDOW, wxT("&Energy Plot"), _("A plot of the energy for each geometry"));
1657 menuWindow->Append(MMP_FREQUENCIESWINDOW, wxT("&Frequencies"), _("Plot the vibrational frequencies"));
1658 menuWindow->Append(MMP_SURFACESWINDOW, wxT("&Surfaces"), _T("Add/Edit/Remove various surface types"));
1659 menuWindow->Append(MMP_ZMATRIXCALC, wxT("&Z-Matrix Calculator"), _("Compute bond lengths/angles or dihedrals between any set of atoms"));
1660 menuWindow->Append(MMP_LOCAL_PREFERENCES, wxT("Pr&eferences"), _T("Edit the preferences for this window"));
1661 menuBar->Append(menuWindow, wxT("&Subwindow"));
1662
1663 wxMenu * menuHelp = new wxMenu;
1664 menuHelp->Append(wxID_ABOUT, wxT("&About MacMolPlt..."), _T("Learn about MacMolPlt"));
1665 menuHelp->Append(wxID_HELP, wxT("&MacMolPlt Manual..."), _T("Brief documentation"));
1666 menuBar->Append(menuHelp, wxT("&Help"));
1667
1668 itemFrame1->SetMenuBar(menuBar);
1669
1670 tabText[0] = wxT("Basis");
1671 tabText[1] = wxT("Control");
1672 tabText[2] = wxT("Data");
1673 tabText[3] = wxT("System");
1674 tabText[4] = wxT("GVB Parameters");
1675 tabText[5] = wxT("DFT");
1676 tabText[6] = wxT("FMO");
1677 tabText[7] = wxT("MO Guess");
1678 tabText[8] = wxT("Hess. Options");
1679 tabText[9] = wxT("Misc. Prefs");
1680 tabText[10] = wxT("MP2 Options");
1681 tabText[11] = wxT("SCF Options");
1682 tabText[12] = wxT("Stat. Point");
1683 tabText[13] = wxT("Summary");
1684
1685 for(int i = NUM_PANES - 1; i >= 0; i--) {
1686 tab[i] = listBook->GetPage(i);
1687 visibleTab[i] = true;
1688 }
1689
1690 listBook->SetSelection(1);
1691 }
1692
1693 /*!
1694 * Should we show tooltips?
1695 */
1696
ShowToolTips()1697 bool InputBuilderWindow::ShowToolTips()
1698 {
1699 return true;
1700 }
1701
1702 /*!
1703 * Get bitmap resources
1704 */
1705
GetBitmapResource(const wxString & name)1706 wxBitmap InputBuilderWindow::GetBitmapResource( const wxString& name )
1707 {
1708 // Bitmap retrieval
1709 ////@begin InputBuilderWindow bitmap retrieval
1710 wxUnusedVar(name);
1711 return wxNullBitmap;
1712 ////@end InputBuilderWindow bitmap retrieval
1713 }
1714
1715 /*!
1716 * Get icon resources
1717 */
1718
GetIconResource(const wxString & name)1719 wxIcon InputBuilderWindow::GetIconResource( const wxString& name )
1720 {
1721 // Icon retrieval
1722 ////@begin InputBuilderWindow icon retrieval
1723 wxUnusedVar(name);
1724 return wxNullIcon;
1725 ////@end InputBuilderWindow icon retrieval
1726 }
1727 /*!
1728 * wxEVT_CLOSE_WINDOW event handler for ID_INPUTBUILDERWINDOW
1729 */
1730
OnCloseWindow(wxCloseEvent &)1731 void InputBuilderWindow::OnCloseWindow( wxCloseEvent& /*event*/ )
1732 {
1733 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
1734 parent->CloseInputBuilderWindow();
1735 }
1736
ShowBasis() const1737 bool InputBuilderWindow::ShowBasis() const {
1738
1739 return TmpInputRec->Control->GetRunType() != G3MP2;
1740
1741 }
1742
ShowStatPoint() const1743 bool InputBuilderWindow::ShowStatPoint() const {
1744
1745 return TmpInputRec->Control->GetRunType() == OptimizeRun ||
1746 TmpInputRec->Control->GetRunType() == SadPointRun ||
1747 TmpInputRec->Control->GetRunType() == G3MP2;
1748
1749 }
1750
ShowMP2Opts() const1751 bool InputBuilderWindow::ShowMP2Opts() const {
1752
1753 return TmpInputRec->Control->GetMPLevel() == 2 ||
1754 TmpInputRec->Control->GetRunType() == G3MP2;
1755
1756 }
1757
ShowHessOpts() const1758 bool InputBuilderWindow::ShowHessOpts() const {
1759
1760 return HessianGroup::IsHessianGroupNeeded(TmpInputRec);
1761 }
1762
ShowSCFOpts() const1763 bool InputBuilderWindow::ShowSCFOpts() const {
1764
1765 return TmpInputRec->Control->GetSCFType() <= 4;
1766
1767 }
1768
SetupItems()1769 void InputBuilderWindow::SetupItems() {
1770 SetupBasisItems();
1771 SetupControlItems();
1772 SetupDataItems();
1773 SetupSystemItems();
1774 SetupDFTItems();
1775 SetupGVBItems();
1776 SetupFMOItems();
1777 SetupMOGuessItems();
1778 SetupHessOptsItems();
1779 SetupMiscPrefsItems();
1780 SetupMP2OptsItems();
1781 SetupSCFOptsItems();
1782 SetupStatPointItems();
1783 SetupSummaryItems();
1784
1785 setPaneVisible(BASIS_PANE, ShowBasis());
1786 setPaneVisible(STATPOINT_PANE, ShowStatPoint());
1787 setPaneVisible(MP2OPTS_PANE, ShowMP2Opts());
1788 setPaneVisible(HESSOPTS_PANE, ShowHessOpts());
1789
1790 Fit();
1791 }
1792
SetupBasisItems()1793 void InputBuilderWindow::SetupBasisItems() {
1794 short BasisValue = TmpInputRec->Basis->GetBasis();
1795 if (BasisValue == GAMESS_BS_BC) BasisValue = GAMESS_BS_DZV;
1796 short NumGauss = TmpInputRec->Basis->GetNumGauss();
1797 int itemValue = 0;
1798 int testValue = 0;
1799
1800 // basisChoice
1801 itemValue = BasisValue;
1802 if(itemValue == 0) itemValue = 1;
1803 else if(itemValue == GAMESS_BS_STO) itemValue = NumGauss + 1;
1804 else if(itemValue == GAMESS_BS_N21) {
1805 itemValue += 4;
1806 if(NumGauss == 6) itemValue++;
1807 }
1808 else if(itemValue == GAMESS_BS_N31) itemValue = NumGauss + 6;
1809 else if(itemValue >= GAMESS_BS_N311) itemValue += 7;
1810 basisChoice->SetSelection(itemValue - 1);
1811 CheckBasisMenu();
1812
1813 // ecpTypeChoice
1814 if(BasisValue == GAMESS_BS_SBKJC || BasisValue == GAMESS_BS_HW) {
1815 ecpTypeChoice->Enable(true);
1816 ecpTypeLabel->Enable(true);
1817 itemValue = TmpInputRec->Basis->GetECPPotential();
1818 if(itemValue == 0) {
1819 if(BasisValue == GAMESS_BS_SBKJC) itemValue = GAMESS_BS_ECP_SBKJC;
1820 else itemValue = GAMESS_BS_ECP_HW;
1821 }
1822 ecpTypeChoice->SetSelection(itemValue);
1823 }
1824 else {
1825 ecpTypeChoice->Enable(false);
1826 ecpTypeLabel->Enable(false);
1827 }
1828
1829 spherHarmCheck->Enable(true);
1830 spherHarmCheck->SetValue(TmpInputRec->Control->UseSphericalHarmonics());
1831 if ((BasisValue < GAMESS_BS_CC_PVDZ)||(BasisValue == GAMESS_BS_SBKJC) ||
1832 (BasisValue == GAMESS_BS_HW)) {
1833 // polarChoice
1834 testValue = TmpInputRec->Basis->GetNumPFuncs() +
1835 TmpInputRec->Basis->GetNumDFuncs() +
1836 TmpInputRec->Basis->GetNumFFuncs();
1837 if(testValue) {
1838 polarChoice->Enable(true);
1839 polarLabel->Enable(true);
1840 itemValue = TmpInputRec->Basis->GetPolar();
1841 if(itemValue == 0) {
1842 if(BasisValue == GAMESS_BS_N311 || BasisValue == GAMESS_BS_MC) itemValue = GAMESS_BS_PopN311_Polar;
1843 else if(BasisValue == GAMESS_BS_DZV || BasisValue == GAMESS_BS_DH) itemValue = GAMESS_BS_Dunning_Polar;
1844 else if(BasisValue <= GAMESS_BS_MIDI) itemValue = GAMESS_BS_Huzinaga_Polar;
1845 else if(BasisValue == GAMESS_BS_TZV) itemValue = GAMESS_BS_Hondo7_Polar;
1846 else if(BasisValue == GAMESS_BS_N31) itemValue = GAMESS_BS_PopN31_Polar;
1847 else itemValue = GAMESS_BS_Common_Polar;
1848 }
1849 polarChoice->SetSelection(itemValue - 1);
1850 }
1851 else {
1852 polarChoice->Enable(false);
1853 polarLabel->Enable(false);
1854 }
1855
1856 diffuseLCheck->Enable(true);
1857 diffuseSCheck->Enable(true);
1858 numDChoice->Enable(true);
1859 numFChoice->Enable(true);
1860 numPChoice->Enable(true);
1861 // diffuseLCheck
1862 diffuseLCheck->SetValue(TmpInputRec->Basis->GetDiffuseSP());
1863
1864 // diffuseSCheck
1865 diffuseSCheck->SetValue(TmpInputRec->Basis->GetDiffuseS());
1866
1867 // numDChoice
1868 numDChoice->SetSelection(TmpInputRec->Basis->GetNumDFuncs());
1869
1870 // numFChoice
1871 numFChoice->SetSelection(TmpInputRec->Basis->GetNumFFuncs());
1872
1873 // numPChoice
1874 numPChoice->SetSelection(TmpInputRec->Basis->GetNumPFuncs());
1875 } else {
1876 polarChoice->Enable(false);
1877 polarLabel->Enable(false);
1878 diffuseLCheck->Enable(false);
1879 diffuseSCheck->Enable(false);
1880 numDChoice->Enable(false);
1881 numFChoice->Enable(false);
1882 numPChoice->Enable(false);
1883 if ((BasisValue < GAMESS_BS_SBKJC)||((BasisValue >= GAMESS_BS_MCP_DZP)&&
1884 (BasisValue <= GAMESS_BS_IMCP_NR2))) {
1885 spherHarmCheck->SetValue(true);
1886 spherHarmCheck->Enable(false);
1887 }
1888 }
1889 }
1890
SetupControlItems()1891 void InputBuilderWindow::SetupControlItems() {
1892 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
1893
1894 short mp2 = TmpInputRec->Control->GetMPLevel();
1895 bool dft = TmpInputRec->Control->UseDFT();
1896 short ci = TmpInputRec->Control->GetCIType();
1897 CCRunType cc = TmpInputRec->Control->GetCCType();
1898 long scft = TmpInputRec->Control->GetSCFType();
1899 long NumElectrons = parent->GetData()->GetNumElectrons();
1900
1901 int itemValue = 0;
1902
1903 TypeOfRun runType = TmpInputRec->Control->GetRunType();
1904 if(runType == InvalidRunType) runType = Energy;
1905 runChoice->SetSelection(runType - 1);
1906
1907 if (runType == G3MP2) {
1908 scfChoice->SetSelection(0); //G3MP2 only supports RHF
1909 scfChoice->Enable(false);
1910 } else {
1911 scfChoice->Enable(true);
1912 if(scft == 0) {
1913 if(NumElectrons & 1) {
1914 scft = 3;
1915 } else {
1916 scft = 1;
1917 }
1918 }
1919 scfChoice->SetSelection(scft - 1);
1920 }
1921
1922 setPaneVisible(GVB_PANE, (scft == GVB));
1923
1924 // mp2Check
1925 if(ci || cc || dft || (mp2 < 0)) {
1926 mp2Check->SetValue(false);
1927 mp2Check->Enable(false);
1928 } else {
1929 mp2Check->Enable(true);
1930 if(mp2 < 0) mp2 = 0;
1931 if(mp2 == 2) mp2 = 1;
1932 mp2Check->SetValue(mp2);
1933 }
1934
1935 // dftCheck
1936 if(ci || cc || (mp2 > 0) || (scft > 3) || (runType == G3MP2)) {
1937 dftCheck->SetValue(false);
1938 dftCheck->Enable(false);
1939 setPaneVisible(DFT_PANE, false);
1940 } else {
1941 dftCheck->Enable(true);
1942 dftCheck->SetValue(dft);
1943 if(dft) setPaneVisible(DFT_PANE, true);
1944 else setPaneVisible(DFT_PANE, false);
1945 }
1946
1947 // ciChoice
1948 if((mp2 > 0) || dft || cc || scft == 2 || (runType == G3MP2)) {
1949 ciChoice->SetSelection(0);
1950 ciChoice->Enable(false);
1951 ciLabel->Enable(false);
1952 } else {
1953 ciChoice->Enable(true);
1954 ciLabel->Enable(true);
1955 ciChoice->SetSelection(ci);
1956 }
1957
1958 // ccChoice - coupled cluster is only availble for RHF and ROHF. There is a much more limited
1959 // set of options for ROHF, not sure how to handle that here.
1960 if((mp2 > 0) || dft || ci || ((scft > GAMESS_RHF)&&(scft != GAMESS_ROHF)) || (runType == G3MP2)) {
1961 ccChoice->SetSelection(0);
1962 ccChoice->Enable(false);
1963 ccLabel->Enable(false);
1964 } else {
1965 ccChoice->Enable(true);
1966 ccLabel->Enable(true);
1967 ccChoice->SetSelection(cc);
1968 }
1969
1970 // scfIterText
1971 itemValue = TmpInputRec->Control->GetMaxIt();
1972 if(itemValue <= 0) itemValue = 30;
1973 scfIterText->SetValue(wxString::Format(wxT("%d"), itemValue));
1974
1975 // exeChoice
1976 exeChoice->SetSelection(TmpInputRec->Control->GetExeType());
1977 if(TmpInputRec->Control->GetFriend() != Friend_None) {
1978 //The friend keyword choices force a check run type
1979 exeChoice->Enable(false);
1980 exeChoice->SetSelection(1);
1981 } else {
1982 exeChoice->Enable(true);
1983 }
1984
1985 // mchargeText
1986 mchargeText->SetValue(wxString::Format(wxT("%hd"), TmpInputRec->Control->GetCharge()));
1987
1988 // multText
1989 itemValue = TmpInputRec->Control->GetMultiplicity();
1990 if(itemValue <= 0) {
1991 if(NumElectrons & 1) itemValue = 2;
1992 else itemValue = 1;
1993 }
1994 multText->SetValue(wxString::Format(wxT("%d"), itemValue));
1995
1996 // localChoice
1997 localChoice->SetSelection(TmpInputRec->Control->GetLocal());
1998 }
1999
SetupDataItems()2000 void InputBuilderWindow::SetupDataItems() {
2001 int itemValue;
2002
2003 //Title
2004 if (TmpInputRec->Data->GetTitle())
2005 titleText->SetValue(wxString(TmpInputRec->Data->GetTitle(), wxConvUTF8));
2006 else
2007 titleText->SetValue(wxString(_T("Title")));
2008
2009 // coordTypeChoice
2010 itemValue = TmpInputRec->Data->GetCoordType();
2011 if(itemValue == 0) itemValue = 1;
2012 coordTypeChoice->SetSelection(itemValue - 1);
2013
2014 // unitChoice
2015 unitChoice->SetSelection(TmpInputRec->Data->GetUnits());
2016
2017 //# Z-Matrix vars
2018 wxString zvars;
2019 zvars.Printf(wxT("%d"), TmpInputRec->Data->GetNumZVar());
2020 zmatrixVarsText->SetValue(zvars);
2021
2022 //Point Group
2023 itemValue = TmpInputRec->Data->GetPointGroup();
2024 if (itemValue == 0) itemValue = 1;
2025 pointGroupChoice->SetSelection(itemValue-1);
2026
2027 //Point group order
2028 SetupPointGroupOrder();
2029
2030 // symmetryCheck
2031 symmetryCheck->SetValue(TmpInputRec->Data->GetUseSym());
2032 }
2033
SetupPointGroupOrder(void)2034 void InputBuilderWindow::SetupPointGroupOrder(void) {
2035 //Point group order - only applicable to certain point groups
2036 int itemValue = TmpInputRec->Data->GetPointGroup();
2037 if (itemValue == 0) itemValue = 1;
2038 if ((itemValue>3)&&(itemValue<11)) {
2039 paxisOrderChoice->Enable(true);
2040 paxisOrderText->Enable(true);
2041 itemValue = TmpInputRec->Data->GetPointGroupOrder()-1;
2042 if (itemValue <= 0) {
2043 itemValue = 1;
2044 TmpInputRec->Data->SetPointGroupOrder(2);
2045 }
2046 paxisOrderChoice->SetSelection(itemValue-1);
2047 } else {
2048 paxisOrderChoice->Enable(false);
2049 paxisOrderText->Enable(false);
2050 }
2051 }
2052
SetupSystemItems()2053 void InputBuilderWindow::SetupSystemItems() {
2054
2055 // timeLimitText
2056 wxString time;
2057 time.Printf(wxT("%.2f"), TmpInputRec->System->GetConvertedTime());
2058 timeLimitText->SetValue(time);
2059
2060 // timeLimitUnitChoice
2061 timeLimitUnitChoice->SetSelection(TmpInputRec->System->GetTimeUnits() - 1);
2062
2063 // memoryText
2064 wxString mem;
2065 mem.Printf(wxT("%.2f"), TmpInputRec->System->GetConvertedMem());
2066 memoryText->SetValue(mem);
2067
2068 // memoryUnitChoice
2069 memoryUnitChoice->SetSelection(TmpInputRec->System->GetMemUnits() - 1);
2070
2071 // memDDI edit
2072 mem.Printf(wxT("%.2f"), TmpInputRec->System->GetConvertedMemDDI());
2073 memddiText->SetValue(mem);
2074
2075 // memDDIUnitChoice
2076 memddiUnitChoice->SetSelection(TmpInputRec->System->GetMemDDIUnits() - megaWordsUnit);
2077
2078 // diagChoice
2079 diagChoice->SetSelection(TmpInputRec->System->GetDiag());
2080
2081 // coreCheck
2082 coreCheck->SetValue(TmpInputRec->System->GetCoreFlag());
2083
2084 // plBalanceRadio
2085 plBalanceRadio->SetSelection(TmpInputRec->System->GetBalanceType());
2086
2087 // externDataRepCheck
2088 externDataRepCheck->SetValue(TmpInputRec->System->GetXDR());
2089
2090 // Parall check
2091 mSGParallCheck->SetValue(TmpInputRec->System->GetParallel());
2092 }
2093
SetupGVBItems()2094 void InputBuilderWindow::SetupGVBItems() {
2095 wxString varText;
2096 // # core Orbs edit
2097 varText.Printf(wxT("%ld"), TmpInputRec->SCF->GetGVBNumCoreOrbs());
2098 mGVB_NCOEdit->SetValue(varText);
2099 // # pairs edit
2100 varText.Printf(wxT("%ld"), TmpInputRec->SCF->GetGVBNumPairs());
2101 mGVB_PairsEdit->SetValue(varText);
2102 // # open shells edit
2103 varText.Printf(wxT("%ld"), TmpInputRec->SCF->GetGVBNumOpenShells());
2104 mGVB_NSETOEdit->SetValue(varText);
2105 if (TmpInputRec->SCF->GetGVBNumOpenShells() > 0) {
2106 mGVB_NOEdit->Show(true);
2107 mGVB_NOStatic->Show(true);
2108 std::vector<long> t = TmpInputRec->SCF->GetGVBOpenShellDeg();
2109 int num = t.size();
2110 if (TmpInputRec->SCF->GetGVBNumOpenShells() > num) { //This shouldn't happen?
2111 for (int i=num; i<TmpInputRec->SCF->GetGVBNumOpenShells(); i++)
2112 t.push_back(0);
2113 } else if (TmpInputRec->SCF->GetGVBNumOpenShells() > num)
2114 num =TmpInputRec->SCF->GetGVBNumOpenShells();
2115 std::ostringstream degString;
2116 for (int i=0; i<num; i++) {
2117 if (i>0) degString << " ";
2118 degString << t[i];
2119 }
2120 mGVB_NOEdit->SetValue(wxString(degString.str().c_str(), wxConvUTF8));
2121 } else {
2122 mGVB_NOEdit->Show(false);
2123 mGVB_NOStatic->Show(false);
2124 }
2125 }
2126
SetupDFTItems()2127 void InputBuilderWindow::SetupDFTItems() {
2128 // dftMethodChoice
2129 bool grid = TmpInputRec->DFT.MethodGrid();
2130 dftMethodChoice->SetSelection(grid ? 0 : 1);
2131
2132 // dftGridFuncChoice and dftGridFreeFuncChoice
2133 if(grid) {
2134 dftGridFreeFuncChoice->Show(false);
2135 dftGridFuncChoice->Show(true);
2136 dftGridFuncChoice->SetSelection(TmpInputRec->DFT.GetFunctional() - 1);
2137 funcSizer->Layout();
2138 } else {
2139 dftGridFuncChoice->Show(false);
2140 dftGridFreeFuncChoice->Show(true);
2141 dftGridFreeFuncChoice->SetSelection(TmpInputRec->DFT.GetFunctional() - 1);
2142 funcSizer->Layout();
2143 }
2144 }
2145
SetupFMOItems()2146 void InputBuilderWindow::SetupFMOItems() {
2147 mFMOFragList->HideCellEditControl();
2148 mFMOFragList->ClearSelection();
2149 mFMOFragList->SetColLabelValue(0, _T("Fragment Id"));
2150 //Clear off the old rows
2151 if (mFMOFragList->GetNumberRows()>0)
2152 mFMOFragList->DeleteRows(0, mFMOFragList->GetNumberRows(), true);
2153
2154 if (TmpInputRec->FMO.IsFMOActive()) {
2155 mFMOCheck->SetValue(true);
2156 mFMOGenFragsButton->Enable(true);
2157 mFMOFragList->Enable(true);
2158 mNumFragsEdit->Enable(true);
2159 wxString nf;
2160 nf.Printf(wxT("%ld"), TmpInputRec->FMO.GetNumberFragments());
2161 mNumFragsEdit->SetValue(nf);
2162 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2163 MoleculeData * MainData = parent->GetData();
2164 Frame * cFrame = MainData->GetCurrentFramePtr();
2165 mFMOFragList->InsertRows(0, cFrame->GetNumAtoms(), true);
2166
2167 //Test to see if the fragment list is initialized, if not init it
2168 if (FMOFragmentIds.size() < cFrame->GetNumAtoms()) {
2169 FMOFragmentIds.reserve(cFrame->GetNumAtoms());
2170 while (FMOFragmentIds.size() < cFrame->GetNumAtoms())
2171 FMOFragmentIds.push_back(1);
2172 }
2173
2174 for (long i=0; i<cFrame->GetNumAtoms(); i++) {
2175 wxString foo;
2176 foo.Printf(wxT("%ld"), FMOFragmentIds[i]);
2177 mFMOFragList->SetCellValue(i, 0, foo);
2178 }
2179 } else {
2180 mFMOCheck->SetValue(false);
2181 mFMOGenFragsButton->Enable(false);
2182 mFMOFragList->Enable(false);
2183 mNumFragsEdit->Enable(false);
2184 }
2185 }
2186
SetupMOGuessItems()2187 void InputBuilderWindow::SetupMOGuessItems() {
2188 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2189
2190 long GuessType = TmpInputRec->Guess->GetGuess();
2191 MoleculeData * MainData = parent->GetData();
2192 Frame * lFrame = MainData->GetCurrentFramePtr();
2193 const std::vector<OrbitalRec *> * Orbs = lFrame->GetOrbitalSetVector();
2194 if (GuessType == 0) {
2195 GuessType = 1;
2196 if (Orbs->size() > 0) {GuessType = 3; TmpInputRec->Guess->SetGuess(GuessType);}
2197 }
2198 initGuessChoice->SetSelection(GuessType-1);
2199
2200 if (GuessType == 3) { //only applicable to MO read type of guess
2201 mMOSourceChoice->Enable(true);
2202 mMOSourceChoice->Clear();
2203 mVecOrbCountText->Enable(true);
2204 mMOSourceChoice->Append(wxString(_("By Hand Later")));
2205 short tempVec = TmpInputRec->Guess->GetVecSource();
2206 if (Orbs->size() > 0) {
2207 if ((tempVec<=0)||(tempVec > (Orbs->size() + 2))) tempVec = 2;
2208 std::vector<OrbitalRec *>::const_iterator OrbSet = Orbs->begin();
2209 while (OrbSet != Orbs->end()) { //Build the popup menu
2210 mMOSourceChoice->Append(wxString((*OrbSet)->getOrbitalTypeText(), wxConvUTF8));
2211 OrbSet++;
2212 }
2213 } else { //No orbs so the only choice is by hand later
2214 tempVec = 1;
2215 }
2216 mMOSourceChoice->SetSelection(tempVec-1);
2217
2218 int numOrbs = TmpInputRec->Guess->GetNumOrbs();
2219 if (!numOrbs) { //Obtain the # of orbs if from a local set
2220 if (Orbs->size() > 0) {
2221 if (tempVec > 1) {
2222 OrbitalRec * OrbSet = (*Orbs)[tempVec-2];
2223 numOrbs = OrbSet->getNumOccupiedAlphaOrbitals();
2224 if (numOrbs <= 0) numOrbs = OrbSet->getNumAlphaOrbitals();
2225 }
2226 }
2227 }
2228 wxString noText;
2229 noText.Printf(wxT("%d"), numOrbs);
2230 mVecOrbCountText->SetValue(noText);
2231 } else {
2232 mMOSourceChoice->Enable(false);
2233 mVecOrbCountText->Enable(false);
2234 }
2235
2236 printInitGuessCheck->SetValue(TmpInputRec->Guess->GetPrintMO());
2237
2238 rotOrbitalsCheck->SetValue(TmpInputRec->Guess->GetMix());
2239 rotOrbitalsCheck->Enable(((TmpInputRec->Control->GetSCFType() == 2)&&
2240 ((TmpInputRec->Control->GetMultiplicity() == 1)||
2241 (TmpInputRec->Control->GetMultiplicity() == 0))));
2242 }
2243
SetupHessOptsItems()2244 void InputBuilderWindow::SetupHessOptsItems() {
2245 if (!TmpInputRec->Hessian) TmpInputRec->Hessian = new HessianGroup;
2246
2247 bool AnalyticPoss = TmpInputRec->Hessian->IsAnalyticHessianPossible(TmpInputRec);
2248
2249 bool AnalyticSelected = TmpInputRec->Hessian->GetAnalyticMethod() && AnalyticPoss;
2250 mHessMethodRadio->Enable(AnalyticPoss);
2251 if (AnalyticSelected) mHessMethodRadio->SetSelection(0);
2252 else mHessMethodRadio->SetSelection(1);
2253 //Double difference
2254 mHessDblDiffCheck->Enable(!AnalyticSelected);
2255 mHessDblDiffCheck->SetValue(TmpInputRec->Hessian->GetDoubleDiff());
2256 //Purify
2257 mHessPurifyCheck->Enable((TmpInputRec->Data->GetNumZVar() > 0));
2258 mHessPurifyCheck->SetValue(TmpInputRec->Hessian->GetPurify());
2259 //Print FC
2260 mHessPrintIntFCCheck->Enable((TmpInputRec->Data->GetNumZVar() > 0));
2261 mHessPrintIntFCCheck->SetValue(TmpInputRec->Hessian->GetPrintFC());
2262 //vibartional analysis
2263 mHessVibAnlCheck->SetValue(TmpInputRec->Hessian->GetVibAnalysis());
2264 //frequency scale factor
2265 mHessFreqScaleEdit->Enable(TmpInputRec->Hessian->GetVibAnalysis());
2266 if (TmpInputRec->Hessian->GetVibAnalysis()) {
2267 wxString temp;
2268 temp.Printf(wxT("%f"), TmpInputRec->Hessian->GetFreqScale());
2269 mHessFreqScaleEdit->SetValue(temp);
2270 }
2271 //displacement
2272 mHESSDisplaceEdit->Enable(!AnalyticSelected);
2273 if (!AnalyticSelected) {
2274 wxString temp;
2275 temp.Printf(wxT("%f"), TmpInputRec->Hessian->GetDisplacementSize());
2276 mHESSDisplaceEdit->SetValue(temp);
2277 }
2278 }
2279
SetupMiscPrefsItems()2280 void InputBuilderWindow::SetupMiscPrefsItems() {
2281 mMolPltCheck->SetValue(TmpInputRec->Control->GetMolPlot());
2282 mPltOrbCheck->SetValue(TmpInputRec->Control->GetPlotOrb());
2283
2284 //aimpac and rpac require normal run type, but the others below require a check run
2285 if ((TmpInputRec->Control->GetExeType()!=1)&&(TmpInputRec->Control->GetFriend()==Friend_None)) {
2286 aimpacCheck->Enable(true);
2287 aimpacCheck->SetValue(TmpInputRec->Control->GetAIMPAC());
2288
2289 rpacCheck->Enable(true);
2290 rpacCheck->SetValue(TmpInputRec->Control->GetRPAC());
2291 } else {
2292 aimpacCheck->Enable(false);
2293 aimpacCheck->SetValue(false);
2294
2295 rpacCheck->Enable(false);
2296 rpacCheck->SetValue(false);
2297 }
2298
2299 mMiscProgRadio->SetSelection(TmpInputRec->Control->GetFriend());
2300 }
2301
SetupMP2OptsItems()2302 void InputBuilderWindow::SetupMP2OptsItems() {
2303 if (!TmpInputRec->MP2) TmpInputRec->MP2 = new MP2Group;
2304
2305 wxString temp;
2306 //# core electrons
2307 if (TmpInputRec->MP2->GetNumCoreElectrons()>=0) {
2308 temp.Printf(wxT("%ld"), TmpInputRec->MP2->GetNumCoreElectrons());
2309 mMP2CoreEleEdit->SetValue(temp);
2310 }
2311 //memory
2312 long memVal = TmpInputRec->MP2->GetMemory();
2313 if (memVal == 0)
2314 temp.Printf(wxT("All"));
2315 else
2316 temp.Printf(wxT("%d"), memVal);
2317 mMP2MemEdit->SetValue(temp);
2318 //integral cutoff
2319 double tempf = TmpInputRec->MP2->GetIntCutoff();
2320 if (tempf == 0.0) tempf = 1.0e-9;
2321 temp.Printf(wxT("%g"), tempf);
2322 mMP2IntCutoffEdit->SetValue(temp);
2323 //LMOMP2
2324 mLMOMP2Check->Enable((1>=TmpInputRec->Control->GetSCFType()));
2325 mLMOMP2Check->SetValue(TmpInputRec->MP2->GetLMOMP2());
2326 //MP2 Prop
2327 mMP2PropCheck->Enable((Energy==TmpInputRec->Control->GetRunType()));
2328 mMP2PropCheck->SetValue(TmpInputRec->MP2->GetMP2Prop());
2329 //Trans. method
2330 if (TmpInputRec->MP2->GetLMOMP2()) { //LMOMP2 forces method = 3
2331 mMP2TransRadio->Enable(false);
2332 mMP2TransRadio->SetSelection(1);
2333 } else {
2334 mMP2TransRadio->Enable(true);
2335 short itemValue = TmpInputRec->MP2->GetMethod();
2336 if (itemValue <= 2) itemValue = 0;
2337 else itemValue = 1;
2338 mMP2TransRadio->SetSelection(itemValue);
2339 }
2340 //AO dist.
2341 short itemValue = TmpInputRec->MP2->GetAOIntMethod();
2342 if ((itemValue == 0)||(itemValue == 2)) itemValue = 1;
2343 else itemValue = 0;
2344 mMP2AOStorageRadio->SetSelection(itemValue);
2345 }
2346
SetupSCFOptsItems()2347 void InputBuilderWindow::SetupSCFOptsItems() {
2348 if (!TmpInputRec->SCF) TmpInputRec->SCF = new SCFGroup;
2349 mDirectSCFCheck->SetValue(TmpInputRec->SCF->GetDirectSCF());
2350 if ((TmpInputRec->SCF->GetDirectSCF() && (3>=TmpInputRec->Control->GetSCFType()))) {
2351 mFDiffCheck->SetValue(TmpInputRec->SCF->GetFockDiff());
2352 mFDiffCheck->Enable(true);
2353 } else {
2354 mFDiffCheck->SetValue(false);
2355 mFDiffCheck->Enable(false);
2356 }
2357 if (TmpInputRec->Control->GetSCFType() == GAMESS_UHF) {
2358 mUHFNOCheck->SetValue(TmpInputRec->SCF->GetUHFNO());
2359 mUHFNOCheck->Enable(true);
2360 } else {
2361 mUHFNOCheck->SetValue(false);
2362 mUHFNOCheck->Enable(false);
2363 }
2364
2365 int conv = TmpInputRec->SCF->GetConvergance();
2366 if (conv == 0) conv = 5;
2367 mSCFConvSpin->SetValue(conv);
2368 }
2369
SetupStatPointItems()2370 void InputBuilderWindow::SetupStatPointItems() {
2371 short RunType = TmpInputRec->Control->GetRunType();
2372
2373 wxString temp;
2374 //max steps
2375 temp.Printf(wxT("%d"), TmpInputRec->StatPt->GetMaxSteps());
2376 mMaxStepCountEdit->SetValue(temp);
2377
2378 //conv. criteria
2379 temp.Printf(wxT("%g"), TmpInputRec->StatPt->GetOptConvergance());
2380 mGradConvEdit->SetValue(temp);
2381
2382 //method
2383 short OptMethod = TmpInputRec->StatPt->GetMethod();
2384 mOptMethodChoice->SetSelection(OptMethod-1);
2385
2386 //init step size
2387 if (OptMethod == 1) {
2388 mInitStepSizeEdit->Enable(false);
2389 } else {
2390 mInitStepSizeEdit->Enable(true);
2391 float tempf = TmpInputRec->StatPt->GetInitRadius();
2392 if (tempf == 0.0) {
2393 if (OptMethod == 5) tempf = 0.1f;
2394 else if (RunType == 6) tempf = 0.2f;
2395 else tempf = 0.3f;
2396 }
2397 temp.Printf(wxT("%g"), tempf);
2398 mInitStepSizeEdit->SetValue(temp);
2399 }
2400 //Min step size
2401 temp.Printf(wxT("%g"), TmpInputRec->StatPt->GetMinRadius());
2402 mMinStepSizeEdit->SetValue(temp);
2403 //max step size
2404 float tempf = TmpInputRec->StatPt->GetMaxRadius();
2405 if (tempf == 0.0) {
2406 if (RunType == 6) tempf = 0.3f;
2407 else tempf = 0.5;
2408 }
2409 temp.Printf(wxT("%g"), tempf);
2410 mMaxStepSizeEdit->SetValue(temp);
2411
2412 //hess recalc interval
2413 temp.Printf(wxT("%d"), TmpInputRec->StatPt->GetHessRecalcInterval());
2414 mHessRecalcEdit->SetValue(temp);
2415
2416 //Init Hess
2417 short HessType = TmpInputRec->StatPt->GetHessMethod();
2418 if (!HessType) {
2419 if ((RunType == OptimizeRun)||(RunType == G3MP2)) HessType = 1;
2420 else HessType = 2;
2421 }
2422 mInitHessRadio->SetSelection(HessType-1);
2423 //step size update radius
2424 mUpdateStepSizeCheck->SetValue(TmpInputRec->StatPt->GetRadiusUpdate());
2425 //Statpt check
2426 mIsStatPtCheck->SetValue(TmpInputRec->StatPt->GetStatPoint());
2427 //Orbs print check
2428 mPrintOrbsCheck->SetValue(TmpInputRec->StatPt->AlwaysPrintOrbs());
2429
2430 //statpt jump off size
2431 if (TmpInputRec->StatPt->GetStatPoint()) {
2432 mStatPtJumpSizeEdit->Enable(true);
2433 temp.Printf(wxT("%g"), TmpInputRec->StatPt->GetStatJump());
2434 mStatPtJumpSizeEdit->SetValue(temp);
2435 } else {
2436 mStatPtJumpSizeEdit->Enable(false);
2437 }
2438 //mode to follow
2439 if (RunType == 6) {
2440 mStatPtModeEdit->Enable(true);
2441 temp.Printf(wxT("%ld"), TmpInputRec->StatPt->GetModeFollow());
2442 mStatPtModeEdit->SetValue(temp);
2443 } else
2444 mStatPtModeEdit->Enable(false);
2445 }
2446
SetupSummaryItems()2447 void InputBuilderWindow::SetupSummaryItems() {
2448
2449 if (TmpInputRec->Data->GetTitle()) {
2450 mTitleText->SetValue(wxString(TmpInputRec->Data->GetTitle(), wxConvUTF8));
2451 } else mTitleText->Clear();
2452 if (TmpInputRec->Basis->GetBasis()) {
2453 wxString temp(TmpInputRec->Basis->GetBasisText(), wxConvUTF8);
2454 wxString t2(TmpInputRec->Basis->GetBasisText(), wxConvUTF8);
2455 if ((TmpInputRec->Basis->GetBasis()>3)&&(TmpInputRec->Basis->GetBasis()<6)) {
2456 temp.Printf(wxT("%d-%s"), TmpInputRec->Basis->GetNumGauss(), t2.c_str());
2457 } else if (TmpInputRec->Basis->GetBasis()==3) {
2458 temp.Printf(wxT("%s-%dG"), t2.c_str(), TmpInputRec->Basis->GetNumGauss());
2459 }
2460 if (TmpInputRec->Basis->GetNumDFuncs()) {
2461 wxString t;
2462 t.Printf(wxT(", # D funcs = %d"), TmpInputRec->Basis->GetNumDFuncs());
2463 temp.Append(t);
2464 }
2465 if (TmpInputRec->Basis->GetNumPFuncs()) {
2466 wxString t;
2467 t.Printf(wxT(", # P funcs = %d"), TmpInputRec->Basis->GetNumPFuncs());
2468 temp.Append(t);
2469 }
2470 if (TmpInputRec->Basis->GetNumFFuncs()) {
2471 wxString t;
2472 t.Printf(wxT(", # F funcs = %d"), TmpInputRec->Basis->GetNumFFuncs());
2473 temp.Append(t);
2474 }
2475 if (TmpInputRec->Basis->GetPolar() > GAMESS_BS_No_Polarization) {
2476 wxString t;
2477 wxString t1(TmpInputRec->Basis->GetPolarText(), wxConvUTF8);
2478 t.Printf(wxT(", Polar = "));
2479 temp.Append(t);
2480 temp.Append(t1);
2481 }
2482 mBasisSetText->SetValue(temp);
2483 } else mBasisSetText->Clear();
2484
2485 wxString temp(ControlGroup::GetGAMESSRunText(TmpInputRec->Control->GetRunType()), wxConvUTF8);
2486 mRunTypeText->SetValue(temp);
2487
2488 if (TmpInputRec->Control->GetSCFType()) {
2489 mSCFTypeText->SetValue(wxString(TmpInputRec->Control->GetSCFTypeText(), wxConvUTF8));
2490 } else mSCFTypeText->Clear();
2491 {
2492 wxString pg;
2493 const char * pgt = TmpInputRec->Data->GetPointGroupText();
2494 if (TmpInputRec->Data->GetPointGroupOrder() > 0) {
2495 int i=0;
2496 while (pgt[i]) {
2497 if (pgt[i] == 'N') {
2498 wxString temp;
2499 temp.Printf(wxT("%d"), TmpInputRec->Data->GetPointGroupOrder());
2500 pg.Append(temp);
2501 } else {
2502 pg.Append((char)(pgt[i]), 1);
2503 }
2504 i++;
2505 }
2506 } else pg = wxString(pgt, wxConvUTF8);
2507 mPointGroupText->SetValue(pg);
2508 }
2509 wxString eclevel;
2510 if (TmpInputRec->Control->GetMPLevel() == 2)
2511 eclevel.Printf(wxT("MP2"));
2512 else if (TmpInputRec->Control->GetCCType()) {
2513 wxString t(TmpInputRec->Control->GetGAMESSCCType(TmpInputRec->Control->GetCCType()), wxConvUTF8);
2514 eclevel = t;
2515 } else if (TmpInputRec->Control->GetCIType()) {
2516 wxString t(TmpInputRec->Control->GetCIType(TmpInputRec->Control->GetCIType()), wxConvUTF8);
2517 eclevel = t;
2518 }
2519 mElectronCorr->SetValue(eclevel);
2520 }
2521
2522
2523 /*!
2524 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_BASIS_CHOICE
2525 */
2526
OnBasisChoiceSelected(wxCommandEvent &)2527 void InputBuilderWindow::OnBasisChoiceSelected( wxCommandEvent& /*event*/ )
2528 {
2529 short BasisValue = 0;
2530 short NumGauss = 0;
2531 int itemValue = basisChoice->GetSelection();
2532
2533 if(itemValue < 2) {
2534 BasisValue = itemValue + 1;
2535 }
2536 else if(itemValue < 7) {
2537 BasisValue = GAMESS_BS_STO;
2538 NumGauss = itemValue;
2539 }
2540 else if(itemValue < 9) {
2541 BasisValue = GAMESS_BS_N21;
2542 NumGauss = ((itemValue==7) ? 3 : 6);
2543 }
2544 else if(itemValue < 12) {
2545 BasisValue = GAMESS_BS_N31;
2546 NumGauss = itemValue - 5;
2547 }
2548 else if(itemValue < 18) {
2549 BasisValue = itemValue - 6;
2550 if(itemValue == 12) NumGauss = 6;
2551 } else {
2552 BasisValue = itemValue - 6;
2553 }
2554
2555 TmpInputRec->Basis->SetBasis(BasisValue);
2556 TmpInputRec->Basis->SetNumGauss(NumGauss);
2557 SetupItems();
2558 }
2559
2560
2561 /*!
2562 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_ECPT_CHOICE
2563 */
2564
OnEcptChoiceSelected(wxCommandEvent &)2565 void InputBuilderWindow::OnEcptChoiceSelected( wxCommandEvent& /*event*/ )
2566 {
2567 TmpInputRec->Basis->SetECPPotential(ecpTypeChoice->GetSelection());
2568 }
2569
2570
2571 /*!
2572 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_POLAR_CHOICE
2573 */
2574
OnPolarChoiceSelected(wxCommandEvent &)2575 void InputBuilderWindow::OnPolarChoiceSelected( wxCommandEvent& /*event*/ )
2576 {
2577 TmpInputRec->Basis->SetPolar((GAMESS_BS_Polarization)(polarChoice->GetSelection() + 1));
2578 }
2579
2580
2581 /*!
2582 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_DIFFL_CHECKBOX
2583 */
2584
OnDifflCheckboxClick(wxCommandEvent & event)2585 void InputBuilderWindow::OnDifflCheckboxClick( wxCommandEvent& event )
2586 {
2587 TmpInputRec->Basis->SetDiffuseSP(event.IsChecked());
2588 }
2589
2590
2591 /*!
2592 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_DIFFS_CHECKBOX
2593 */
2594
OnDiffsCheckboxClick(wxCommandEvent & event)2595 void InputBuilderWindow::OnDiffsCheckboxClick( wxCommandEvent& event )
2596 {
2597 TmpInputRec->Basis->SetDiffuseS(event.IsChecked());
2598 }
2599
2600
2601 /*!
2602 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_NUMD_CHOICE
2603 */
2604
OnNumdChoiceSelected(wxCommandEvent &)2605 void InputBuilderWindow::OnNumdChoiceSelected( wxCommandEvent& /*event*/ )
2606 {
2607 TmpInputRec->Basis->SetNumDFuncs(numDChoice->GetSelection());
2608 SetupItems();
2609 }
2610
2611
2612 /*!
2613 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_NUMF_CHOICE
2614 */
2615
OnNumfChoiceSelected(wxCommandEvent &)2616 void InputBuilderWindow::OnNumfChoiceSelected( wxCommandEvent& /*event*/ )
2617 {
2618 TmpInputRec->Basis->SetNumFFuncs(numFChoice->GetSelection());
2619 SetupItems();
2620 }
2621
2622
2623 /*!
2624 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_NUMP_CHOICE
2625 */
2626
OnNumpChoiceSelected(wxCommandEvent &)2627 void InputBuilderWindow::OnNumpChoiceSelected( wxCommandEvent& /*event*/ )
2628 {
2629 TmpInputRec->Basis->SetNumPFuncs(numPChoice->GetSelection());
2630 SetupItems();
2631 }
2632 /*!
2633 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_RUN_CHOICE
2634 */
2635
OnRunChoiceSelected(wxCommandEvent &)2636 void InputBuilderWindow::OnRunChoiceSelected( wxCommandEvent& /*event*/ )
2637 {
2638 TmpInputRec->Control->SetRunType((TypeOfRun)(runChoice->GetSelection() + 1));
2639 SetupItems();
2640 }
2641
2642
2643 /*!
2644 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_SCF_CHOICE
2645 */
2646
OnScfChoiceSelected(wxCommandEvent &)2647 void InputBuilderWindow::OnScfChoiceSelected( wxCommandEvent& /*event*/ )
2648 {
2649 TmpInputRec->Control->SetSCFType((GAMESS_SCFType)(scfChoice->GetSelection() + 1));
2650 setPaneVisible(SCFOPTS_PANE, ShowSCFOpts());
2651 SetupItems();
2652 }
2653
2654
2655 /*!
2656 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_LOCAL_CHOICE
2657 */
2658
OnLocalChoiceSelected(wxCommandEvent &)2659 void InputBuilderWindow::OnLocalChoiceSelected( wxCommandEvent& /*event*/ )
2660 {
2661 TmpInputRec->Control->SetLocal((GAMESS_Localization)(localChoice->GetSelection()));
2662 SetupItems();
2663 }
2664 /*!
2665 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_MP2_CHECKBOX
2666 */
2667
OnMp2CheckboxClick(wxCommandEvent & event)2668 void InputBuilderWindow::OnMp2CheckboxClick( wxCommandEvent& event )
2669 {
2670 if(event.IsChecked()) {
2671 TmpInputRec->Control->SetMPLevel(2);
2672 }
2673 else {
2674 TmpInputRec->Control->SetMPLevel(0);
2675 }
2676 SetupItems();
2677 }
2678
2679
2680 /*!
2681 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_DFT_CHECKBOX
2682 */
2683
OnDftCheckboxClick(wxCommandEvent & event)2684 void InputBuilderWindow::OnDftCheckboxClick( wxCommandEvent& event )
2685 {
2686 TmpInputRec->Control->UseDFT(event.IsChecked());
2687 SetupItems();
2688 }
2689
2690
2691 /*!
2692 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_CI_CHOICE
2693 */
2694
OnCiChoiceSelected(wxCommandEvent &)2695 void InputBuilderWindow::OnCiChoiceSelected( wxCommandEvent& /*event*/ )
2696 {
2697 TmpInputRec->Control->SetCIType((CIRunType)(ciChoice->GetSelection()));
2698 SetupItems();
2699 }
2700
2701
2702 /*!
2703 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_CC_CHOICE
2704 */
2705
OnCcChoiceSelected(wxCommandEvent &)2706 void InputBuilderWindow::OnCcChoiceSelected( wxCommandEvent& /*event*/ )
2707 {
2708 TmpInputRec->Control->SetCCType((CCRunType)(ccChoice->GetSelection()));
2709 SetupItems();
2710 }
2711
2712
2713 /*!
2714 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_EXE_CHOICE
2715 */
2716
OnExeChoiceSelected(wxCommandEvent &)2717 void InputBuilderWindow::OnExeChoiceSelected( wxCommandEvent& /*event*/ )
2718 {
2719 TmpInputRec->Control->SetExeType(exeChoice->GetSelection());
2720 SetupMiscPrefsItems();
2721 }
2722
2723
2724 /*!
2725 * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL
2726 */
2727
OnCancelClick(wxCommandEvent &)2728 void InputBuilderWindow::OnCancelClick( wxCommandEvent& /*event*/ )
2729 {
2730 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2731 parent->CloseInputBuilderWindow();
2732 }
2733
SaveData(void) const2734 void InputBuilderWindow::SaveData(void) const {
2735 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2736 parent->GetData()->SetInputData(TmpInputRec);
2737 if (TmpInputRec->FMO.IsFMOActive()) {
2738 if (FMOFragmentIds.size() > 0) {
2739 MoleculeData * MainData = ((MolDisplayWin *)parent)->GetData();
2740 Frame * cFrame = MainData->GetCurrentFramePtr();
2741 for (long i=0; i<cFrame->GetNumAtoms(); i++) {
2742 MainData->SetFMOFragmentId(i, FMOFragmentIds[i]);
2743 }
2744 }
2745 }
2746 }
FrameChanged(void)2747 void InputBuilderWindow::FrameChanged(void) {
2748 SetupFMOItems();
2749 }
2750 /*!
2751 * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_OK
2752 */
2753
OnOkClick(wxCommandEvent &)2754 void InputBuilderWindow::OnOkClick( wxCommandEvent& /*event*/ )
2755 {
2756 SaveData();
2757 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2758 parent->ResetModel(false);
2759 parent->CloseInputBuilderWindow();
2760 }
2761
2762
2763 /*!
2764 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DEFAULTSBUTTON
2765 */
2766
OnDefaultsbuttonClick(wxCommandEvent &)2767 void InputBuilderWindow::OnDefaultsbuttonClick( wxCommandEvent& /*event*/ )
2768 {
2769 switch(getCurrentPane()) {
2770 case BASIS_PANE:
2771 TmpInputRec->Basis->InitData();
2772 break;
2773 case CONTROL_PANE:
2774 TmpInputRec->Control->InitControlPaneData();
2775 break;
2776 case DATA_PANE:
2777 TmpInputRec->Data->InitData();
2778 break;
2779 case SYSTEM_PANE:
2780 TmpInputRec->System->InitData();
2781 break;
2782 case DFT_PANE:
2783 TmpInputRec->DFT.InitData();
2784 break;
2785 case FMO_Pane:
2786 TmpInputRec->FMO.InitData();
2787 FMOFragmentIds.clear();
2788 break;
2789 case MOGUESS_PANE:
2790 TmpInputRec->Guess->InitData();
2791 break;
2792 case HESSOPTS_PANE:
2793 TmpInputRec->Hessian->InitData();
2794 break;
2795 case MISCPREFS_PANE:
2796 TmpInputRec->Control->InitProgPaneData();
2797 break;
2798 case MP2OPTS_PANE:
2799 TmpInputRec->MP2->InitData();
2800 break;
2801 case SCFOPTS_PANE:
2802 TmpInputRec->SCF->InitData();
2803 break;
2804 case STATPOINT_PANE:
2805 TmpInputRec->StatPt->InitData();
2806 break;
2807 default:
2808 // NO-OP
2809 break;
2810 }
2811
2812 SetupItems();
2813 }
2814
2815
2816 /*!
2817 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_REVERTBUTTON
2818 */
2819
OnRevertbuttonClick(wxCommandEvent &)2820 void InputBuilderWindow::OnRevertbuttonClick( wxCommandEvent& /*event*/ )
2821 {
2822 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2823 MoleculeData * MainData = ((MolDisplayWin *)parent)->GetData();
2824 InputData *OldData = ((MolDisplayWin *)parent)->GetData()->GetInputData();
2825
2826 switch(getCurrentPane()) {
2827 case BASIS_PANE:
2828 *(TmpInputRec->Basis) = *(OldData->Basis);
2829 break;
2830 case CONTROL_PANE:
2831 TmpInputRec->Control->RevertControlPane(OldData->Control);
2832 break;
2833 case DATA_PANE:
2834 if(TmpInputRec->Data) delete TmpInputRec->Data;
2835 TmpInputRec->Data = new DataGroup(OldData->Data);
2836 break;
2837 case SYSTEM_PANE:
2838 *(TmpInputRec->System) = *(OldData->System);
2839 break;
2840 case DFT_PANE:
2841 TmpInputRec->DFT = OldData->DFT;
2842 break;
2843 case FMO_Pane:
2844 TmpInputRec->FMO = OldData->FMO;
2845 FMOFragmentIds.clear();
2846 if (MainData->GetFMOFragmentId(0)>0) { //copy them over if setup
2847 Frame * cFrame = MainData->GetCurrentFramePtr();
2848 FMOFragmentIds.reserve(cFrame->GetNumAtoms());
2849 for (long i=0; i<cFrame->GetNumAtoms(); i++) {
2850 FMOFragmentIds.push_back(MainData->GetFMOFragmentId(i));
2851 }
2852 }
2853 break;
2854 case MOGUESS_PANE:
2855 if(OldData->Guess) {
2856 *(TmpInputRec->Guess) = *(OldData->Guess);
2857 }
2858 else {
2859 TmpInputRec->Guess->InitData();
2860 }
2861 break;
2862 case HESSOPTS_PANE:
2863 if(OldData->Hessian) {
2864 *(TmpInputRec->Hessian) = *(OldData->Hessian);
2865 }
2866 else {
2867 TmpInputRec->Hessian->InitData();
2868 }
2869 break;
2870 case MISCPREFS_PANE:
2871 TmpInputRec->Control->RevertProgPane(OldData->Control);
2872 break;
2873 case MP2OPTS_PANE:
2874 if(OldData->MP2) {
2875 *(TmpInputRec->MP2) = *(OldData->MP2);
2876 }
2877 else {
2878 TmpInputRec->MP2->InitData();
2879 }
2880 break;
2881 case SCFOPTS_PANE:
2882 if(OldData->SCF) {
2883 *(TmpInputRec->SCF) = *(OldData->SCF);
2884 }
2885 else {
2886 TmpInputRec->SCF->InitData();
2887 }
2888 break;
2889 case STATPOINT_PANE:
2890 if(OldData->StatPt) {
2891 *(TmpInputRec->StatPt) = *(OldData->StatPt);
2892 }
2893 else {
2894 TmpInputRec->StatPt->InitData();
2895 }
2896 break;
2897 default:
2898 // NO-OP
2899 break;
2900 }
2901
2902 SetupItems();
2903 }
2904
2905 /*!
2906 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_ADVANCEDBUTTON
2907 */
2908
OnAdvancedButtonClicked(wxCommandEvent &)2909 void InputBuilderWindow::OnAdvancedButtonClicked( wxCommandEvent& /*event*/ )
2910 {
2911
2912 // User wants to go to advanced mode.
2913 if (advanced_button->GetLabel() == wxT("Advanced")) {
2914 advanced_button->SetLabel(wxT("Basic"));
2915 setPaneVisible(BASIS_PANE, ShowBasis());
2916 setPaneVisible(CONTROL_PANE, true);
2917 setPaneVisible(DATA_PANE, true);
2918 setPaneVisible(SYSTEM_PANE, true);
2919 setPaneVisible(DFT_PANE, true);
2920 setPaneVisible(MOGUESS_PANE, true);
2921 setPaneVisible(HESSOPTS_PANE, ShowHessOpts());
2922 setPaneVisible(MISCPREFS_PANE, true);
2923 setPaneVisible(MP2OPTS_PANE, ShowMP2Opts());
2924 setPaneVisible(SCFOPTS_PANE, ShowSCFOpts());
2925 setPaneVisible(STATPOINT_PANE, ShowStatPoint());
2926 setPaneVisible(SUMMARY_PANE, true);
2927 SetupControlItems();
2928 }
2929
2930 // User wants to go to basic mode.
2931 else {
2932 listBook->SetSelection(1);
2933 advanced_button->SetLabel(wxT("Advanced"));
2934 for (int i = DATA_PANE; i <= SUMMARY_PANE; ++i) {
2935 setPaneVisible(i, false);
2936 }
2937 }
2938
2939 advanced_button->SetSize(advanced_button->GetBestSize());
2940 button_sizer->Layout();
2941
2942 }
2943
2944 /*!
2945 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_WRITEFILEBUTTON
2946 */
2947
OnWritefilebuttonClick(wxCommandEvent &)2948 void InputBuilderWindow::OnWritefilebuttonClick( wxCommandEvent& /*event*/ )
2949 {
2950 SaveData();
2951 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2952 parent->GetData()->WriteInputFile(parent);
2953 }
2954
2955 /*!
2956 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_WRITE_EDIT_BUTTON
2957 */
2958
OnWriteEditButtonClick(wxCommandEvent &)2959 void InputBuilderWindow::OnWriteEditButtonClick( wxCommandEvent& /*event*/ )
2960 {
2961 SaveData();
2962 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2963 parent->GetData()->WriteEditInputFile(parent);
2964 }
2965
2966 /*!
2967 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_ENQUEUEBUTTON
2968 */
2969
OnEnqueueButtonClick(wxCommandEvent &)2970 void InputBuilderWindow::OnEnqueueButtonClick( wxCommandEvent& /*event*/ )
2971 {
2972 wxFileName file(wxFileName::CreateTempFileName(wxT("wxMacMolPltData_")));
2973 file.SetExt(wxT("inp"));
2974 SaveData();
2975 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
2976 TmpInputRec->WriteInputFile(file.GetFullPath(), parent->GetData(), parent);
2977
2978 #ifdef __WXMAC__
2979 pid_t pid = fork();
2980 if (pid == 0) {
2981 //My guess is that ToAscii needs to be replaced with mb_str for this to work.
2982 execlp("open", "open", "-a", "gamessq",
2983 (const char *)file.GetFullPath().ToAscii(), NULL);
2984 exit(1);
2985 }
2986 #else /* __WXMAC__ */
2987 wxExecute(wxT("gamessq ") + file.GetFullPath());
2988 #endif /* __WXMAC__ */
2989 }
2990
setPaneVisible(int pane,bool visible)2991 void InputBuilderWindow::setPaneVisible(int pane, bool visible) {
2992 int currPos = pane;
2993 int i = 0;
2994
2995 if (visibleTab[pane] == visible) return;
2996
2997 for(i = 0; i < pane; i++) {
2998 if(!visibleTab[i]) {
2999 currPos--;
3000 }
3001 }
3002
3003 if (visible) {
3004 visibleTab[pane] = listBook->InsertPage(currPos, tab[pane], tabText[pane]);
3005 }
3006 else {
3007 visibleTab[pane] = !(listBook->RemovePage(currPos));
3008 }
3009 }
3010
getCurrentPane()3011 int InputBuilderWindow::getCurrentPane() {
3012 return getPaneAtPosition(listBook->GetSelection());
3013 }
3014
3015 /*!
3016 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_COORD_CHOICE
3017 */
3018
OnCoordChoiceSelected(wxCommandEvent &)3019 void InputBuilderWindow::OnCoordChoiceSelected( wxCommandEvent& /*event*/ )
3020 {
3021 TmpInputRec->Data->SetCoordType((CoordinateType)(coordTypeChoice->GetSelection() + 1));
3022 SetupItems();
3023 }
3024
3025
3026 /*!
3027 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_UNIT_CHOICE
3028 */
3029
OnUnitChoiceSelected(wxCommandEvent &)3030 void InputBuilderWindow::OnUnitChoiceSelected( wxCommandEvent& /*event*/ )
3031 {
3032 TmpInputRec->Data->SetUnits(unitChoice->GetSelection());
3033 }
3034
3035
3036 /*!
3037 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_POINTGROUP_CHOICE
3038 */
3039
OnPointgroupChoiceSelected(wxCommandEvent & event)3040 void InputBuilderWindow::OnPointgroupChoiceSelected( wxCommandEvent& event )
3041 {
3042 TmpInputRec->Data->SetPointGroup((GAMESSPointGroup)(pointGroupChoice->GetSelection()+1));
3043 SetupPointGroupOrder();
3044 event.Skip();
3045 }
3046
3047
3048 /*!
3049 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_ORDER_CHOICE
3050 */
3051
OnOrderChoiceSelected(wxCommandEvent & event)3052 void InputBuilderWindow::OnOrderChoiceSelected( wxCommandEvent& event )
3053 {
3054 TmpInputRec->Data->SetPointGroupOrder(paxisOrderChoice->GetSelection()+2);
3055 event.Skip();
3056 }
3057
3058
3059 /*!
3060 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_SYMMETRY_CHECKBOX
3061 */
3062
OnSymmetryCheckboxClick(wxCommandEvent & event)3063 void InputBuilderWindow::OnSymmetryCheckboxClick( wxCommandEvent& event )
3064 {
3065 TmpInputRec->Data->SetUseSym(event.IsChecked());
3066 }
3067
3068
3069 /*!
3070 * wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED event handler for ID_IBNOTEBOOK
3071 */
3072
OnIblistbookPageChanged(wxListbookEvent & event)3073 void InputBuilderWindow::OnIblistbookPageChanged( wxListbookEvent& event )
3074 {
3075 switch (getPaneAtPosition(event.GetSelection())) {
3076 case HESSOPTS_PANE:
3077 SetupHessOptsItems();
3078 break;
3079 case SUMMARY_PANE:
3080 SetupSummaryItems();
3081 break;
3082 }
3083 event.Skip();
3084 }
3085
3086
getPaneAtPosition(int pos)3087 int InputBuilderWindow::getPaneAtPosition(int pos) {
3088 int currPane = pos;
3089 int i = 0;
3090
3091 for(i = 0; i <= currPane && i < NUM_PANES; i++) {
3092 if (!visibleTab[i]) {
3093 currPane++;
3094 }
3095 }
3096
3097 return currPane;
3098 }
3099
3100 #define kNumBasisMenuItems 89
CheckBasisMenu(void)3101 void InputBuilderWindow::CheckBasisMenu(void) {
3102 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
3103 AtomTypeList * list = parent->GetData()->GetAtomTypes();
3104 int i = 0;
3105 bool states[kNumBasisMenuItems];
3106
3107 if(list) {
3108 for(i = 0; i < kNumBasisMenuItems; i++) states[i] = false;
3109 list->Sort();
3110 long MaxType = list->GetMaxAtomType();
3111 //Run through the rules for each basis set
3112 if (MaxType <= 86) { //H-Rn
3113 states[0] = true; //MINI
3114 states[1] = true; //MIDI
3115 }
3116 if (MaxType <= 54) { //H-Xe
3117 for (i=2; i<7; i++) states[i] = true; //STO-NG
3118 states[7] = true; //3-21G
3119 }
3120 if (MaxType <= 18) //H-Ar
3121 states[8] = true; //6-21G
3122 if ((MaxType <= 17)&&(!list->IsAtomInList(11) && !list->IsAtomInList(12) &&
3123 ! list->IsAtomInList(13) && ! list->IsAtomInList(14))) {
3124 //H-Ne, P-Cl
3125 states[9] = true; //4-31G
3126 }
3127 if ((MaxType <= 9)&&(!list->IsAtomInList(3) && !list->IsAtomInList(4) &&
3128 ! list->IsAtomInList(5))) {
3129 //H-He, C-F
3130 states[10] = true; //5-31G
3131 }
3132 if (MaxType <= 36) //H-Kr
3133 states[11] = true; //6-31G
3134 if (MaxType <= 10) //H-Ne
3135 states[12] = true; //6-311G
3136 if ((MaxType <= 36)&&(!list->IsAtomInList(2) && !list->IsAtomInList(11) &&
3137 ! list->IsAtomInList(12) && ! list->TransitionMetalInList())) {
3138 //H, Li, Be-Ne, Al-Cl, K-Ca, Ga-Kr
3139 states[13] = true; //DZV
3140 }
3141 if ((MaxType <= 17)&&(!list->IsAtomInList(2) && !list->IsAtomInList(11) &&
3142 ! list->IsAtomInList(12))) {
3143 //H, Li, Be-Ne, Al-Cl
3144 states[14] = true; //DH
3145 }
3146 if ((MaxType <= 30)&&(!list->IsAtomInList(2))) {
3147 //H, Li-Zn
3148 states[15] = true; //TZV
3149 }
3150 if (MaxType <= 18) { //H-Ar
3151 states[16] = true; //MC
3152 }
3153 if ((MaxType <= 36)&&(!list->IsAtomInList(19))) {
3154 //H-Ar, Ca, Ga-Kr, Sc-Zn for T,Q only
3155 if (! list->TransitionMetalInList()) {
3156 states[17] = true; //cc-pVDZ
3157 states[20] = true; //cc-pV5Z
3158 states[21] = true; //cc-pV6Z
3159
3160 states[22] = true; //aug-cc-pVDZ
3161 states[25] = true; //aug-cc-pV5Z
3162 states[26] = true; //aug-cc-pV6Z
3163
3164 states[27] = true; //cc-pCVDZ
3165 states[30] = true; //cc-pCV5Z
3166 states[31] = true; //cc-pCV6Z
3167
3168 states[32] = true; //aug-cc-pCVDZ
3169 states[35] = true; //aug-cc-pCV5Z
3170 states[36] = true; //aug-cc-pCV6Z
3171 }
3172 states[18] = true; //cc-pVTZ
3173 states[19] = true; //cc-pVQZ
3174 states[23] = true; //aug-cc-pVTZ
3175 states[24] = true; //aug-cc-pVQZ
3176 states[28] = true; //cc-pCVTZ
3177 states[29] = true; //cc-pCVQZ
3178 states[33] = true; //aug-cc-pCVTZ
3179 states[34] = true; //aug-cc-pCVQZ
3180 }
3181 if (MaxType <= 18) { //H-Ar
3182 for (i=37; i<(37+10); i++)
3183 states[i] = true; //Jensen PCn and APCn
3184 }
3185 if (MaxType <= 54) { //H-Xe
3186 for (i=47; i<(47+12); i++) states[i] = true; //SPK variations
3187 }
3188 //the manual isn't clear on what is support for KTZV basis, for now just make them available
3189 states[59] = true;
3190 states[60] = true;
3191 states[61] = true;
3192 if (MaxType <= 86) { //H-Rn
3193 states[62] = true; //SBKJC
3194 }
3195 if (MaxType <= 54) { //H-Xe
3196 states[63] = true; //HW
3197 }
3198 if (MaxType <= 88) { //H-Ra with exceptions
3199 states[64] = true; //MCP family
3200 states[65] = true; //MCP family
3201 states[66] = true; //MCP family
3202 states[67] = true; //MCP family
3203 states[68] = true; //MCP family
3204 states[69] = true; //MCP family
3205 states[70] = true; //MCP family
3206 states[71] = true; //MCP family
3207 states[72] = true; //MCP family
3208 states[73] = true; //MCP family
3209 states[74] = true; //MCP family
3210 }
3211 if (MaxType <= 86) { //H-Rn (ok lots of exceptions not included here)
3212 states[75] = true; //IMCP-SR series
3213 states[76] = true; //IMCP-SR series
3214 states[77] = true; //IMCP-SR series
3215 states[78] = true; //IMCP-SR series
3216 }
3217 if (MaxType <= 86 && ! list->TransitionMetalInList()) { //H-Rn minus D-block elements
3218 states[79] = true; //ZFK series
3219 states[80] = true; //ZFK series
3220 states[81] = true; //ZFK series
3221 states[82] = true; //ZFK series
3222 states[83] = true; //ZFK series
3223 states[84] = true; //ZFK series
3224 }
3225 if (MaxType <= 86) { //H-Rn, but's lot's of exceptions I'm too lazy to put in here
3226 states[85] = true; //MNDO
3227 states[86] = true; //AM1
3228 states[87] = true; //PM3
3229 states[88] = true; //RM1
3230 }
3231
3232 delete list;
3233
3234 for(i = 0; i < kNumBasisMenuItems; i++) {
3235 basisChoice->SetEnabled(i, states[i]);
3236 }
3237 }
3238 }
3239 /*!
3240 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_ZMAT_VARS_TEXT
3241 */
3242
OnZmatVarsTextUpdated(wxCommandEvent & event)3243 void InputBuilderWindow::OnZmatVarsTextUpdated( wxCommandEvent& event )
3244 {
3245 wxString temp = zmatrixVarsText->GetValue();
3246 long t;
3247 if (temp.ToLong(&t)) {
3248 TmpInputRec->Data->SetNumZVar(t);
3249 }
3250 event.Skip();
3251 }
3252
3253
3254 /*!
3255 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_TITLE_TEXTCTRL
3256 */
3257
OnTitleTextctrlUpdated(wxCommandEvent & event)3258 void InputBuilderWindow::OnTitleTextctrlUpdated( wxCommandEvent& event )
3259 {
3260 wxString temp = titleText->GetValue();
3261 TmpInputRec->Data->SetTitle((const char *)temp.mb_str(wxConvUTF8));
3262 event.Skip();
3263 }
3264
3265
3266 /*!
3267 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_CORE_CHECKBOX
3268 */
3269
OnCoreCheckboxClick(wxCommandEvent & event)3270 void InputBuilderWindow::OnCoreCheckboxClick( wxCommandEvent& event )
3271 {
3272 TmpInputRec->System->SetCoreFlag(coreCheck->GetValue());
3273 event.Skip();
3274 }
3275
3276
3277 /*!
3278 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_TIMELIMIT_TEXT
3279 */
3280
OnTimelimitTextUpdated(wxCommandEvent & event)3281 void InputBuilderWindow::OnTimelimitTextUpdated( wxCommandEvent& event )
3282 {
3283 wxString temp = timeLimitText->GetValue();
3284 double t;
3285 if (temp.ToDouble(&t)) {
3286 TmpInputRec->System->SetConvertedTime(t);
3287 }
3288
3289 event.Skip();
3290 }
3291
3292 /*!
3293 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_TIMELIMITUNITS_CHOICE
3294 */
3295
OnTimelimitunitsChoiceSelected(wxCommandEvent & event)3296 void InputBuilderWindow::OnTimelimitunitsChoiceSelected( wxCommandEvent& event )
3297 {
3298 TmpInputRec->System->SetTimeUnits((TimeUnit) (timeLimitUnitChoice->GetSelection()+1));
3299 wxString time;
3300 time.Printf(wxT("%.2f"), TmpInputRec->System->GetConvertedTime());
3301 timeLimitText->SetValue(time);
3302
3303 event.Skip();
3304 }
3305
3306 /*!
3307 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MEMORY_TEXT
3308 */
3309
OnMemoryTextUpdated(wxCommandEvent & event)3310 void InputBuilderWindow::OnMemoryTextUpdated( wxCommandEvent& event )
3311 {
3312 wxString temp = memoryText->GetValue();
3313 double t;
3314 if (temp.ToDouble(&t)) {
3315 TmpInputRec->System->SetConvertedMem(t);
3316 }
3317
3318 event.Skip();
3319 }
3320
3321 /*!
3322 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_MEMORYUNITS_CHOICE
3323 */
3324
OnMemoryunitsChoiceSelected(wxCommandEvent & event)3325 void InputBuilderWindow::OnMemoryunitsChoiceSelected( wxCommandEvent& event )
3326 {
3327 TmpInputRec->System->SetMemUnits((MemoryUnit) (memoryUnitChoice->GetSelection()+1));
3328 wxString mem;
3329 mem.Printf(wxT("%.2f"), TmpInputRec->System->GetConvertedMem());
3330 memoryText->SetValue(mem);
3331
3332 event.Skip();
3333 }
3334
3335
3336 /*!
3337 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_DIAGONALIZATION_CHOICE
3338 */
3339
OnDiagonalizationChoiceSelected(wxCommandEvent & event)3340 void InputBuilderWindow::OnDiagonalizationChoiceSelected( wxCommandEvent& event )
3341 {
3342 TmpInputRec->System->SetDiag(diagChoice->GetSelection());
3343 event.Skip();
3344 }
3345
3346 /*!
3347 * wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_PLBALANCE_RADIOBOX
3348 */
3349
OnPlbalanceRadioboxSelected(wxCommandEvent & event)3350 void InputBuilderWindow::OnPlbalanceRadioboxSelected( wxCommandEvent& event )
3351 {
3352 TmpInputRec->System->SetBalanceType(plBalanceRadio->GetSelection());
3353 event.Skip();
3354 }
3355
3356
3357 /*!
3358 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_EXTERNDATAREP_CHECKBOX
3359 */
3360
OnExterndatarepCheckboxClick(wxCommandEvent & event)3361 void InputBuilderWindow::OnExterndatarepCheckboxClick( wxCommandEvent& event )
3362 {
3363 TmpInputRec->System->SetXDR(externDataRepCheck->GetValue());
3364 event.Skip();
3365 }
3366
3367
3368 /*!
3369 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_INITGUESS_CHOICE
3370 */
3371
OnInitguessChoiceSelected(wxCommandEvent & event)3372 void InputBuilderWindow::OnInitguessChoiceSelected( wxCommandEvent& event )
3373 {
3374 int s = initGuessChoice->GetSelection() + 1;
3375 if (s != TmpInputRec->Guess->GetGuess()) {
3376 TmpInputRec->Guess->SetGuess(s);
3377 SetupMOGuessItems();
3378 }
3379 event.Skip();
3380 }
3381
3382 /*!
3383 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_PRINTINITGUESS_CHECKBOX
3384 */
3385
OnPrintinitguessCheckboxClick(wxCommandEvent & event)3386 void InputBuilderWindow::OnPrintinitguessCheckboxClick( wxCommandEvent& event )
3387 {
3388 TmpInputRec->Guess->SetPrintMO(printInitGuessCheck->GetValue());
3389 event.Skip();
3390 }
3391
3392 /*!
3393 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_ROTORBITALS_CHECKBOX
3394 */
3395
OnRotorbitalsCheckboxClick(wxCommandEvent & event)3396 void InputBuilderWindow::OnRotorbitalsCheckboxClick( wxCommandEvent& event )
3397 {
3398 TmpInputRec->Guess->SetMix(rotOrbitalsCheck->GetValue());
3399 event.Skip();
3400 }
3401
3402
3403 /*!
3404 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_MOGUESS_VECSOURCE_CHOICE
3405 */
3406
OnMoguessVecsourceChoiceSelected(wxCommandEvent & event)3407 void InputBuilderWindow::OnMoguessVecsourceChoiceSelected( wxCommandEvent& event )
3408 {
3409 int s = mMOSourceChoice->GetSelection() + 1;
3410 if (s != TmpInputRec->Guess->GetVecSource()) {
3411 TmpInputRec->Guess->SetVecSource(s);
3412 SetupMOGuessItems();
3413 }
3414 event.Skip();
3415 }
3416
3417
3418 /*!
3419 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MOGUESS_VECORBCOUNT_TEXT
3420 */
3421
OnMoguessVecorbcountTextUpdated(wxCommandEvent & event)3422 void InputBuilderWindow::OnMoguessVecorbcountTextUpdated( wxCommandEvent& event )
3423 {
3424 long t;
3425 wxString noTemp = mVecOrbCountText->GetValue();
3426 if (noTemp.ToLong(&t)) {
3427 TmpInputRec->Guess->SetNumOrbs(t);
3428 }
3429 event.Skip();
3430 }
3431
3432
3433 /*!
3434 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_MOLPLT_CHECK
3435 */
3436
OnMolpltCheckClick(wxCommandEvent & event)3437 void InputBuilderWindow::OnMolpltCheckClick( wxCommandEvent& event )
3438 {
3439 TmpInputRec->Control->SetMolPlot(mMolPltCheck->GetValue());
3440 event.Skip();
3441 }
3442
3443 /*!
3444 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_PLTORB_CHECK
3445 */
3446
OnPltorbCheckClick(wxCommandEvent & event)3447 void InputBuilderWindow::OnPltorbCheckClick( wxCommandEvent& event )
3448 {
3449 TmpInputRec->Control->SetPlotOrb(mPltOrbCheck->GetValue());
3450 event.Skip();
3451 }
3452
3453 /*!
3454 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_AIMPAC_CHECK
3455 */
3456
OnAimpacCheckClick(wxCommandEvent & event)3457 void InputBuilderWindow::OnAimpacCheckClick( wxCommandEvent& event )
3458 {
3459 TmpInputRec->Control->SetAIMPAC(aimpacCheck->GetValue());
3460 event.Skip();
3461 }
3462
3463 /*!
3464 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_RPAC_CHECK
3465 */
3466
OnRpacCheckClick(wxCommandEvent & event)3467 void InputBuilderWindow::OnRpacCheckClick( wxCommandEvent& event )
3468 {
3469 TmpInputRec->Control->SetRPAC(rpacCheck->GetValue());
3470 event.Skip();
3471 }
3472
3473 /*!
3474 * wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_MISC_PROG_RADIO
3475 */
3476
OnMiscProgRadioSelected(wxCommandEvent & event)3477 void InputBuilderWindow::OnMiscProgRadioSelected( wxCommandEvent& event )
3478 {
3479 int val = mMiscProgRadio->GetSelection();
3480 if (val != TmpInputRec->Control->GetFriend()) {
3481 TmpInputRec->Control->SetFriend((FriendType) val);
3482 SetupMiscPrefsItems();
3483 SetupControlItems();
3484 }
3485 event.Skip();
3486 }
3487
3488
3489 /*!
3490 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_DIRECTSCF_CHECK
3491 */
3492
OnDirectscfCheckClick(wxCommandEvent & event)3493 void InputBuilderWindow::OnDirectscfCheckClick( wxCommandEvent& event )
3494 {
3495 TmpInputRec->SCF->SetDirectSCF(mDirectSCFCheck->GetValue());
3496 SetupSCFOptsItems();
3497 event.Skip();
3498 }
3499
3500 /*!
3501 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_FDIFF_CHECK
3502 */
3503
OnFdiffCheckClick(wxCommandEvent & event)3504 void InputBuilderWindow::OnFdiffCheckClick( wxCommandEvent& event )
3505 {
3506 TmpInputRec->SCF->SetFockDiff(mFDiffCheck->GetValue());
3507 event.Skip();
3508 }
3509
3510 /*!
3511 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_UHF_NO_CHECK
3512 */
3513
OnUhfNoCheckClick(wxCommandEvent &)3514 void InputBuilderWindow::OnUhfNoCheckClick( wxCommandEvent& /*event*/ )
3515 {
3516 TmpInputRec->SCF->SetUHFNO(mUHFNOCheck->GetValue());
3517 // event.Skip();
3518 }
3519
3520 /*!
3521 * wxEVT_COMMAND_SPINCTRL_UPDATED event handler for ID_SCF_CONV_SPIN
3522 */
3523
OnScfConvSpinUpdated(wxSpinEvent & event)3524 void InputBuilderWindow::OnScfConvSpinUpdated( wxSpinEvent& event )
3525 {
3526 TmpInputRec->SCF->SetConvergance(mSCFConvSpin->GetValue());
3527 event.Skip();
3528 }
3529
3530 /*!
3531 * wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_INIT_HESS_RADIO
3532 */
3533
OnInitHessRadioSelected(wxCommandEvent & event)3534 void InputBuilderWindow::OnInitHessRadioSelected( wxCommandEvent& event )
3535 {
3536 int val = mInitHessRadio->GetSelection() + 1;
3537 if (val != TmpInputRec->StatPt->GetHessMethod()) {
3538 TmpInputRec->StatPt->SetHessMethod(val);
3539 }
3540 SetupStatPointItems();
3541 SetupItems();
3542 event.Skip();
3543 }
3544
3545
3546 /*!
3547 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_PRINTORBS_CHECK
3548 */
3549
OnPrintorbsCheckClick(wxCommandEvent &)3550 void InputBuilderWindow::OnPrintorbsCheckClick( wxCommandEvent& /*event*/ )
3551 {
3552 TmpInputRec->StatPt->SetAlwaysPrintOrbs(mPrintOrbsCheck->GetValue());
3553 // event.Skip();
3554 }
3555
3556
3557 /*!
3558 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_HESS_RECALC_EDIT
3559 */
3560
OnHessRecalcEditUpdated(wxCommandEvent & event)3561 void InputBuilderWindow::OnHessRecalcEditUpdated( wxCommandEvent& event )
3562 {
3563 wxString temp = mHessRecalcEdit->GetValue();
3564 long t;
3565 if (temp.ToLong(&t)) {
3566 TmpInputRec->StatPt->SetHessRecalcInterval(t);
3567 }
3568 event.Skip();
3569 }
3570
3571
3572 /*!
3573 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MAXSTEPCOUNT_EDIT
3574 */
3575
OnMaxstepcountEditUpdated(wxCommandEvent & event)3576 void InputBuilderWindow::OnMaxstepcountEditUpdated( wxCommandEvent& event )
3577 {
3578 wxString temp = mMaxStepCountEdit->GetValue();
3579 long t;
3580 if (temp.ToLong(&t)) {
3581 TmpInputRec->StatPt->SetMaxSteps(t);
3582 }
3583 event.Skip();
3584 }
3585
3586
3587 /*!
3588 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_GRADCONVCRITERIA_EDIT
3589 */
3590
OnGradconvcriteriaEditUpdated(wxCommandEvent & event)3591 void InputBuilderWindow::OnGradconvcriteriaEditUpdated( wxCommandEvent& event )
3592 {
3593 wxString temp = mGradConvEdit->GetValue();
3594 double t;
3595 if (temp.ToDouble(&t)) {
3596 TmpInputRec->StatPt->SetOptConvergance(t);
3597 }
3598 event.Skip();
3599 }
3600
3601
3602 /*!
3603 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_OPTMETHOD_CHOICE
3604 */
3605
OnOptmethodChoiceSelected(wxCommandEvent & event)3606 void InputBuilderWindow::OnOptmethodChoiceSelected( wxCommandEvent& event )
3607 {
3608 TmpInputRec->StatPt->SetMethod(mOptMethodChoice->GetSelection()+1);
3609 SetupStatPointItems();
3610 event.Skip();
3611 }
3612
3613
3614 /*!
3615 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_INITSTEPSIZE_EDIT
3616 */
3617
OnInitstepsizeEditUpdated(wxCommandEvent & event)3618 void InputBuilderWindow::OnInitstepsizeEditUpdated( wxCommandEvent& event )
3619 {
3620 wxString temp = mInitStepSizeEdit->GetValue();
3621 double t;
3622 if (temp.ToDouble(&t)) {
3623 //test against the default
3624 double def = 0.3;
3625 if (TmpInputRec->StatPt->GetMethod() == 5) def = 0.1;
3626 else if (TmpInputRec->Control->GetRunType() == 6) def = 0.2;
3627 if (fabs(t-def) < 1.0e-10) t = 0.0;
3628 TmpInputRec->StatPt->SetInitRadius(t);
3629 }
3630 event.Skip();
3631 }
3632
3633
3634 /*!
3635 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_UPDATESTEPSIZE_CHECK
3636 */
3637
OnUpdatestepsizeCheckClick(wxCommandEvent & event)3638 void InputBuilderWindow::OnUpdatestepsizeCheckClick( wxCommandEvent& event )
3639 {
3640 TmpInputRec->StatPt->SetRadiusUpdate(mUpdateStepSizeCheck->GetValue());
3641 event.Skip();
3642 }
3643
3644
3645 /*!
3646 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MINSTEPSIZE_EDIT
3647 */
3648
OnMinstepsizeEditUpdated(wxCommandEvent & event)3649 void InputBuilderWindow::OnMinstepsizeEditUpdated( wxCommandEvent& event )
3650 {
3651 wxString temp = mMinStepSizeEdit->GetValue();
3652 double t;
3653 if (temp.ToDouble(&t)) {
3654 TmpInputRec->StatPt->SetMinRadius(t);
3655 }
3656 event.Skip();
3657 }
3658
3659
3660 /*!
3661 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MAXSTEPSIZE_Edit
3662 */
3663
OnMaxstepsizeEditUpdated(wxCommandEvent & event)3664 void InputBuilderWindow::OnMaxstepsizeEditUpdated( wxCommandEvent& event )
3665 {
3666 wxString temp = mMaxStepSizeEdit->GetValue();
3667 double t;
3668 if (temp.ToDouble(&t)) {
3669 //test against the default
3670 double def=0.5;
3671 if (TmpInputRec->Control->GetRunType() == 6) def = 0.3;
3672 if (fabs(t-def) < 1.0e-10) t = 0.0;
3673 TmpInputRec->StatPt->SetMaxRadius(t);
3674 }
3675 event.Skip();
3676 }
3677
3678
3679 /*!
3680 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_STATPT_CHECK
3681 */
3682
OnStatptCheckClick(wxCommandEvent & event)3683 void InputBuilderWindow::OnStatptCheckClick( wxCommandEvent& event )
3684 {
3685 TmpInputRec->StatPt->SetStatPoint(mIsStatPtCheck->GetValue());
3686 SetupStatPointItems();
3687 event.Skip();
3688 }
3689
3690
3691 /*!
3692 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_STATPT_MODE_EDIT
3693 */
3694
OnStatptModeEditUpdated(wxCommandEvent & event)3695 void InputBuilderWindow::OnStatptModeEditUpdated( wxCommandEvent& event )
3696 {
3697 wxString temp = mStatPtModeEdit->GetValue();
3698 long t;
3699 if (temp.ToLong(&t)) {
3700 TmpInputRec->StatPt->SetModeFollow(t);
3701 }
3702 event.Skip();
3703 }
3704
3705
3706 /*!
3707 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_STATPT_JUMP_EDIT
3708 */
3709
OnStatptJumpEditUpdated(wxCommandEvent & event)3710 void InputBuilderWindow::OnStatptJumpEditUpdated( wxCommandEvent& event )
3711 {
3712 wxString temp = mStatPtJumpSizeEdit->GetValue();
3713 double t;
3714 if (temp.ToDouble(&t)) {
3715 TmpInputRec->StatPt->SetStatJump(t);
3716 }
3717 event.Skip();
3718 }
3719
3720
3721 /*!
3722 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MCHARGE_TEXTCTRL
3723 */
3724
OnMchargeTextctrlUpdated(wxCommandEvent & event)3725 void InputBuilderWindow::OnMchargeTextctrlUpdated( wxCommandEvent& event )
3726 {
3727 wxString tmpStr = mchargeText->GetValue();
3728 long val = 0;
3729 if(tmpStr.ToLong(&val)) {
3730 TmpInputRec->Control->SetCharge((short)val);
3731 }
3732
3733 event.Skip();
3734 }
3735
3736
3737 /*!
3738 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MULT_TEXTCTRL
3739 */
3740
OnMultTextctrlUpdated(wxCommandEvent & event)3741 void InputBuilderWindow::OnMultTextctrlUpdated( wxCommandEvent& event )
3742 {
3743 wxString tmpStr = multText->GetValue();
3744 long val = 0;
3745 if(tmpStr.ToLong(&val)) {
3746 TmpInputRec->Control->SetMultiplicity((short)val);
3747 }
3748
3749 event.Skip();
3750 }
3751
3752
3753 /*!
3754 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MAXIT_TEXTCTRL
3755 */
3756
OnMaxitTextctrlUpdated(wxCommandEvent & event)3757 void InputBuilderWindow::OnMaxitTextctrlUpdated( wxCommandEvent& event )
3758 {
3759 wxString tmpStr = scfIterText->GetValue();
3760 long val = 0;
3761 if(tmpStr.ToLong(&val)) {
3762 TmpInputRec->Control->SetMaxIt((short)val);
3763 }
3764
3765 event.Skip();
3766 }
3767 /*!
3768 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MP2_CORE_EDIT
3769 */
3770
OnMp2CoreEditUpdated(wxCommandEvent & event)3771 void InputBuilderWindow::OnMp2CoreEditUpdated( wxCommandEvent& event )
3772 {
3773 wxString tmpStr = mMP2CoreEleEdit->GetValue();
3774 long val;
3775 if(tmpStr.ToLong(&val)) {
3776 if (val >= 0)
3777 TmpInputRec->MP2->SetNumCoreElectrons(val);
3778 }
3779 event.Skip();
3780 }
3781
3782 /*!
3783 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MP2MEM_EDIT
3784 */
3785
OnMp2memEditUpdated(wxCommandEvent & event)3786 void InputBuilderWindow::OnMp2memEditUpdated( wxCommandEvent& event )
3787 {
3788 wxString tmpStr = mMP2MemEdit->GetValue();
3789 long val;
3790 if(tmpStr.ToLong(&val)) {
3791 TmpInputRec->MP2->SetMemory(val);
3792 }
3793 event.Skip();
3794 }
3795
3796 /*!
3797 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MP2INTCUTOFF_EDIT
3798 */
3799
OnMp2intcutoffEditUpdated(wxCommandEvent & event)3800 void InputBuilderWindow::OnMp2intcutoffEditUpdated( wxCommandEvent& event )
3801 {
3802 wxString tmpStr = mMP2IntCutoffEdit->GetValue();
3803 double val;
3804 if(tmpStr.ToDouble(&val)) {
3805 //test against the default
3806 if (fabs(val - 1.0e-9) < 1.0e-20) val = 0.0;
3807 TmpInputRec->MP2->SetIntCutoff(val);
3808 }
3809 event.Skip();
3810 }
3811
3812 /*!
3813 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_LMOMP2_CHECK
3814 */
3815
OnLmomp2CheckClick(wxCommandEvent & event)3816 void InputBuilderWindow::OnLmomp2CheckClick( wxCommandEvent& event )
3817 {
3818 TmpInputRec->MP2->SetLMOMP2(mLMOMP2Check->GetValue());
3819 SetupMP2OptsItems();
3820 event.Skip();
3821 }
3822
3823 /*!
3824 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_MP2PROP_CHECK
3825 */
3826
OnMp2propCheckClick(wxCommandEvent & event)3827 void InputBuilderWindow::OnMp2propCheckClick( wxCommandEvent& event )
3828 {
3829 TmpInputRec->MP2->SetMP2Prop(mMP2PropCheck->GetValue());
3830 event.Skip();
3831 }
3832
3833 /*!
3834 * wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_MP2TRANS_RADIO
3835 */
3836
OnMp2transRadioSelected(wxCommandEvent & event)3837 void InputBuilderWindow::OnMp2transRadioSelected( wxCommandEvent& event )
3838 {
3839 TmpInputRec->MP2->SetMethod(mMP2TransRadio->GetSelection()+1);
3840 event.Skip();
3841 }
3842
3843 /*!
3844 * wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_MP2AOSTORAGE_RADIO
3845 */
3846
OnMp2aostorageRadioSelected(wxCommandEvent & event)3847 void InputBuilderWindow::OnMp2aostorageRadioSelected( wxCommandEvent& event )
3848 {
3849 TmpInputRec->MP2->SetAOIntMethod(mMP2AOStorageRadio->GetSelection()+1);
3850 event.Skip();
3851 }
3852
3853
3854 /*!
3855 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_DFTMETHOD_CHOICE
3856 */
3857
OnDftmethodChoiceSelected(wxCommandEvent &)3858 void InputBuilderWindow::OnDftmethodChoiceSelected( wxCommandEvent& /*event*/ )
3859 {
3860 TmpInputRec->DFT.SetMethodGrid(!(dftMethodChoice->GetSelection()));
3861 SetupItems();
3862 }
3863
3864
3865 /*!
3866 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_FUNCTIONAL_CHOICE
3867 */
3868
OnGridFunctionalChoiceSelected(wxCommandEvent &)3869 void InputBuilderWindow::OnGridFunctionalChoiceSelected( wxCommandEvent& /*event*/ )
3870 {
3871 TmpInputRec->DFT.SetFunctional(dftGridFuncChoice->GetSelection() + 1);
3872 }
3873
3874
3875 /*!
3876 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_GRIDFREE_FUNCTIONAL_CHOICE
3877 */
3878
OnGridfreeFunctionalChoiceSelected(wxCommandEvent &)3879 void InputBuilderWindow::OnGridfreeFunctionalChoiceSelected( wxCommandEvent& /*event*/ )
3880 {
3881 TmpInputRec->DFT.SetFunctional(dftGridFreeFuncChoice->GetSelection() + 1);
3882 }
3883
3884 /*!
3885 * wxEVT_COMMAND_RADIOBOX_SELECTED event handler for ID_HESSMETHOD_RADIO
3886 */
3887
OnHessmethodRadioSelected(wxCommandEvent & event)3888 void InputBuilderWindow::OnHessmethodRadioSelected( wxCommandEvent& event )
3889 {
3890 TmpInputRec->Hessian->SetAnalyticMethod(!(mHessMethodRadio->GetSelection()));
3891 SetupHessOptsItems();
3892 event.Skip();
3893 }
3894
3895 /*!
3896 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_FORCEDISPLACE_EDIT
3897 */
3898
OnForcedisplaceEditUpdated(wxCommandEvent & event)3899 void InputBuilderWindow::OnForcedisplaceEditUpdated( wxCommandEvent& event )
3900 {
3901 wxString tmpStr = mHESSDisplaceEdit->GetValue();
3902 double val;
3903 if(tmpStr.ToDouble(&val)) {
3904 TmpInputRec->Hessian->SetDisplacementSize(val);
3905 }
3906 event.Skip();
3907 }
3908
3909 /*!
3910 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_HESSDOUBLEDIFFCHECK
3911 */
3912
OnHessdoublediffcheckClick(wxCommandEvent & event)3913 void InputBuilderWindow::OnHessdoublediffcheckClick( wxCommandEvent& event )
3914 {
3915 TmpInputRec->Hessian->SetDoubleDiff(mHessDblDiffCheck->GetValue());
3916 event.Skip();
3917 }
3918
3919 /*!
3920 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_HESSPURIFYCHECK
3921 */
3922
OnHesspurifycheckClick(wxCommandEvent & event)3923 void InputBuilderWindow::OnHesspurifycheckClick( wxCommandEvent& event )
3924 {
3925 TmpInputRec->Hessian->SetPurify(mHessPurifyCheck->GetValue());
3926 event.Skip();
3927 }
3928
3929 /*!
3930 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_HESSPRTINTFC_CHECK
3931 */
3932
OnHessprtintfcCheckClick(wxCommandEvent & event)3933 void InputBuilderWindow::OnHessprtintfcCheckClick( wxCommandEvent& event )
3934 {
3935 TmpInputRec->Hessian->SetPrintFC(mHessPrintIntFCCheck->GetValue());
3936 event.Skip();
3937 }
3938
3939 /*!
3940 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_HESSVIBANL_CHECK
3941 */
3942
OnHessvibanlCheckClick(wxCommandEvent & event)3943 void InputBuilderWindow::OnHessvibanlCheckClick( wxCommandEvent& event )
3944 {
3945 TmpInputRec->Hessian->SetVibAnalysis(mHessVibAnlCheck->GetValue());
3946 SetupHessOptsItems();
3947 event.Skip();
3948 }
3949
3950 /*!
3951 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_HESSFREQSCALE_EDIT
3952 */
3953
OnHessfreqscaleEditUpdated(wxCommandEvent & event)3954 void InputBuilderWindow::OnHessfreqscaleEditUpdated( wxCommandEvent& event )
3955 {
3956 wxString tmpStr = mHessFreqScaleEdit->GetValue();
3957 double val;
3958 if(tmpStr.ToDouble(&val)) {
3959 TmpInputRec->Hessian->SetFreqScale(val);
3960 }
3961 event.Skip();
3962 }
3963
3964
3965 /*!
3966 * wxEVT_COMMAND_CHOICE_SELECTED event handler for ID_MEMDDICHOICE
3967 */
3968
OnMemddichoiceSelected(wxCommandEvent & event)3969 void InputBuilderWindow::OnMemddichoiceSelected( wxCommandEvent& event )
3970 {
3971 TmpInputRec->System->SetMemDDIUnits((MemoryUnit) (memddiUnitChoice->GetSelection()+megaWordsUnit));
3972 wxString mem;
3973 mem.Printf(wxT("%.2f"), TmpInputRec->System->GetConvertedMemDDI());
3974 memddiText->SetValue(mem);
3975
3976 event.Skip();
3977 }
3978
3979
3980 /*!
3981 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_MEMDDI_EDIT
3982 */
3983
OnMemddiEditUpdated(wxCommandEvent & event)3984 void InputBuilderWindow::OnMemddiEditUpdated( wxCommandEvent& event )
3985 {
3986 wxString temp = memddiText->GetValue();
3987 double t;
3988 if (temp.ToDouble(&t)) {
3989 TmpInputRec->System->SetConvertedMemDDI(t);
3990 }
3991
3992 event.Skip();
3993 }
3994 /*!
3995 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_PARALL_CHECK
3996 */
3997
OnParallCheckClick(wxCommandEvent & event)3998 void InputBuilderWindow::OnParallCheckClick( wxCommandEvent& event )
3999 {
4000 TmpInputRec->System->SetParallel(mSGParallCheck->GetValue());
4001 event.Skip();
4002 }
4003
4004 /*!
4005 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_SPHERE_CHECK
4006 */
4007
OnSphereCheckClick(wxCommandEvent & event)4008 void InputBuilderWindow::OnSphereCheckClick( wxCommandEvent& event )
4009 {
4010 TmpInputRec->Control->UseSphericalHarmonics(spherHarmCheck->GetValue());
4011 event.Skip();
4012 }
4013
4014
4015 /*!
4016 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_HESSEND_CHECK
4017 */
4018
OnHessendCheckClick(wxCommandEvent & event)4019 void InputBuilderWindow::OnHessendCheckClick( wxCommandEvent& event )
4020 {
4021 TmpInputRec->StatPt->SetHessFlag(event.IsChecked());
4022 SetupItems();
4023 event.Skip();
4024 }
4025
4026
4027 /*!
4028 * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_FMOACTIVECHECK
4029 */
4030
OnFMOActiveCheckClick(wxCommandEvent & event)4031 void InputBuilderWindow::OnFMOActiveCheckClick( wxCommandEvent& event )
4032 {
4033 TmpInputRec->FMO.FMOActive(mFMOCheck->GetValue());
4034 SetupFMOItems();
4035 event.Skip();
4036 }
4037
4038
4039 /*!
4040 * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_FMOFRAGBUTTON
4041 */
4042
OnFMOFragButtonClick(wxCommandEvent & event)4043 void InputBuilderWindow::OnFMOFragButtonClick( wxCommandEvent& event )
4044 {
4045 //launch the FMO fragmentation dialog
4046 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
4047
4048 FMOFragmentationDialog fragDialog(parent);
4049 if (fragDialog.ShowModal() == wxID_OK) {
4050 //retrieve the # nonbonded atoms and call the fragmentation routine
4051 MoleculeData * MainData = parent->GetData();
4052 int count = fragDialog.GetMolCount();
4053 long fragcount = MainData->CreateFMOFragmentation(count, FMOFragmentIds);
4054 TmpInputRec->FMO.SetNumberFragments(fragcount);
4055 SetupFMOItems();
4056 wxString nf;
4057 nf.Printf(wxT("%ld"), TmpInputRec->FMO.GetNumberFragments());
4058 mNumFragsEdit->SetValue(nf);
4059 }
4060 event.Skip();
4061 }
4062
4063 /*!
4064 * wxEVT_GRID_CELL_CHANGE event handler for ID_FMOLIST
4065 */
4066
OnFMOFragIdCellChange(wxGridEvent & event)4067 void InputBuilderWindow::OnFMOFragIdCellChange( wxGridEvent& event )
4068 {
4069 int row = event.GetRow();
4070
4071 // MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
4072 // MoleculeData * MainData = parent->GetData();
4073
4074 wxString val = mFMOFragList->GetCellValue(row, 0);
4075 long newval;
4076 if (val.ToLong(&newval)) {
4077 if ((newval>0)&&(newval<=TmpInputRec->FMO.GetNumberFragments())) {
4078 FMOFragmentIds[row] = newval;
4079 }
4080 }
4081 val.Printf(wxT("%d"), FMOFragmentIds[row]);
4082 mFMOFragList->SetCellValue(row, 0, val);
4083 event.Skip();
4084 }
4085
4086 /*!
4087 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_FMOFRAGCOUNT
4088 */
4089
OnFMOFragCountTextUpdated(wxCommandEvent & event)4090 void InputBuilderWindow::OnFMOFragCountTextUpdated( wxCommandEvent& event )
4091 {
4092 wxString temp = mNumFragsEdit->GetValue();
4093 long t;
4094 if (temp.ToLong(&t)) {
4095 TmpInputRec->FMO.SetNumberFragments(t);
4096 }
4097 event.Skip();
4098 }
4099
4100
4101 /*!
4102 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_GVB_NCOEDIT
4103 */
4104
OnGVBNCOEditTextUpdated(wxCommandEvent & event)4105 void InputBuilderWindow::OnGVBNCOEditTextUpdated( wxCommandEvent& event )
4106 {
4107 wxString temp = mGVB_NCOEdit->GetValue();
4108 long t;
4109 if (temp.ToLong(&t)) {
4110 TmpInputRec->SCF->SetGVBNumCoreOrbs(t);
4111 }
4112
4113 event.Skip();
4114 }
4115
4116
4117 /*!
4118 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_GVB_PAIRSEDIT
4119 */
4120
OnGVBPairsEditTextUpdated(wxCommandEvent & event)4121 void InputBuilderWindow::OnGVBPairsEditTextUpdated( wxCommandEvent& event )
4122 {
4123 wxString temp = mGVB_PairsEdit->GetValue();
4124 long t;
4125 if (temp.ToLong(&t)) {
4126 TmpInputRec->SCF->SetGVBNumPairs(t);
4127 }
4128
4129 event.Skip();
4130 }
4131
4132
4133 /*!
4134 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_GVB_NSETOEDIT
4135 */
4136
OnGVBNSetOeditTextUpdated(wxCommandEvent & event)4137 void InputBuilderWindow::OnGVBNSetOeditTextUpdated( wxCommandEvent& event )
4138 {
4139 wxString temp = mGVB_NSETOEdit->GetValue();
4140 long t;
4141 if (temp.ToLong(&t)) {
4142 TmpInputRec->SCF->SetGVBNumOpenShells(t);
4143 //now adjust the shell degeneracy array
4144 if (TmpInputRec->SCF->GetGVBNumOpenShells() > 0) {
4145 mGVB_NOEdit->Show(true);
4146 mGVB_NOStatic->Show(true);
4147 std::vector<long> t = TmpInputRec->SCF->GetGVBOpenShellDeg();
4148 int num = t.size();
4149 if (TmpInputRec->SCF->GetGVBNumOpenShells() > num) { //This shouldn't happen?
4150 for (int i=num; i<TmpInputRec->SCF->GetGVBNumOpenShells(); i++)
4151 t.push_back(0);
4152 } else if (TmpInputRec->SCF->GetGVBNumOpenShells() < num)
4153 num =TmpInputRec->SCF->GetGVBNumOpenShells();
4154 std::ostringstream degString;
4155 for (int i=0; i<num; i++) {
4156 if (i>0) degString << " ";
4157 degString << t[i];
4158 }
4159 mGVB_NOEdit->SetValue(wxString(degString.str().c_str(), wxConvUTF8));
4160 } else {
4161 mGVB_NOEdit->Show(false);
4162 mGVB_NOStatic->Show(false);
4163 }
4164 }
4165
4166 event.Skip();
4167 }
4168
4169
4170 /*!
4171 * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_GVB_NOEDIT
4172 */
4173
OnGVBNOeditTextUpdated(wxCommandEvent & event)4174 void InputBuilderWindow::OnGVBNOeditTextUpdated( wxCommandEvent& event )
4175 {
4176 wxString temp = mGVB_NOEdit->GetValue();
4177 std::istringstream buf((const char *)temp.mb_str(wxConvUTF8));
4178 int count=0;
4179 long val;
4180
4181 while ((count<TmpInputRec->SCF->GetGVBNumOpenShells())&&(!buf.eof())) {
4182 buf >> val;
4183 if (val >= 0) TmpInputRec->SCF->SetGVBNODegValue(count, val);
4184 count++;
4185 }
4186 event.Skip();
4187 }
4188
OnActivate(wxActivateEvent & event)4189 void InputBuilderWindow::OnActivate(wxActivateEvent & event) {
4190 if (event.GetActive()) {
4191 MolDisplayWin *parent = (MolDisplayWin *)this->GetParent();
4192 parent->StopAnimations();
4193 }
4194 event.Skip();
4195 }
4196