diff --git a/mathmech/Makefile b/mathmech/Makefile new file mode 100644 index 0000000..3459f10 --- /dev/null +++ b/mathmech/Makefile @@ -0,0 +1,289 @@ +############################################################################# +# Makefile for building: mathmech +# Generated by qmake (2.01a) (Qt 4.8.5) on: ?? ??? 6 23:41:09 2013 +# Project: mathmech.pro +# Template: app +# Command: /usr/lib/qt4/bin/qmake -o Makefile mathmech.pro +############################################################################# + +####### Compiler, tools and options + +CC = gcc +CXX = g++ +DEFINES = -DQT_NO_DEBUG -DQT_GUI_LIB -DQT_CORE_LIB -DQT_SHARED +CFLAGS = -pipe -march=x86-64 -mtune=generic -O2 -pipe -fstack-protector --param=ssp-buffer-size=4 -Wall -W -D_REENTRANT $(DEFINES) +CXXFLAGS = -pipe -march=x86-64 -mtune=generic -O2 -pipe -fstack-protector --param=ssp-buffer-size=4 -Wall -W -D_REENTRANT $(DEFINES) +INCPATH = -I/usr/share/qt4/mkspecs/linux-g++ -I. -I/usr/include/qt4/QtCore -I/usr/include/qt4/QtGui -I/usr/include/qt4 -I. -I. -I. +LINK = g++ +LFLAGS = -Wl,-O1,--sort-common,--as-needed,-z,relro -Wl,-O1 +LIBS = $(SUBLIBS) -L/usr/lib -lQtGui -lQtCore -lpthread +AR = ar cqs +RANLIB = +QMAKE = /usr/lib/qt4/bin/qmake +TAR = tar -cf +COMPRESS = gzip -9f +COPY = cp -f +SED = sed +COPY_FILE = $(COPY) +COPY_DIR = $(COPY) -r +STRIP = strip +INSTALL_FILE = install -m 644 -p +INSTALL_DIR = $(COPY_DIR) +INSTALL_PROGRAM = install -m 755 -p +DEL_FILE = rm -f +SYMLINK = ln -f -s +DEL_DIR = rmdir +MOVE = mv -f +CHK_DIR_EXISTS= test -d +MKDIR = mkdir -p + +####### Output directory + +OBJECTS_DIR = ./ + +####### Files + +SOURCES = main.cpp \ + mainwindow.cpp \ + errorwindow.cpp \ + clear_items.cpp \ + start_events.cpp moc_mainwindow.cpp \ + moc_errorwindow.cpp \ + moc_clear_items.cpp \ + moc_start_events.cpp +OBJECTS = main.o \ + mainwindow.o \ + errorwindow.o \ + clear_items.o \ + start_events.o \ + moc_mainwindow.o \ + moc_errorwindow.o \ + moc_clear_items.o \ + moc_start_events.o +DIST = /usr/share/qt4/mkspecs/common/unix.conf \ + /usr/share/qt4/mkspecs/common/linux.conf \ + /usr/share/qt4/mkspecs/common/gcc-base.conf \ + /usr/share/qt4/mkspecs/common/gcc-base-unix.conf \ + /usr/share/qt4/mkspecs/common/g++-base.conf \ + /usr/share/qt4/mkspecs/common/g++-unix.conf \ + /usr/share/qt4/mkspecs/qconfig.pri \ + /usr/share/qt4/mkspecs/modules/qt_phonon.pri \ + /usr/share/qt4/mkspecs/modules/qt_webkit.pri \ + /usr/share/qt4/mkspecs/features/qt_functions.prf \ + /usr/share/qt4/mkspecs/features/qt_config.prf \ + /usr/share/qt4/mkspecs/features/exclusive_builds.prf \ + /usr/share/qt4/mkspecs/features/default_pre.prf \ + /usr/share/qt4/mkspecs/features/release.prf \ + /usr/share/qt4/mkspecs/features/default_post.prf \ + /usr/share/qt4/mkspecs/features/shared.prf \ + /usr/share/qt4/mkspecs/features/unix/gdb_dwarf_index.prf \ + /usr/share/qt4/mkspecs/features/warn_on.prf \ + /usr/share/qt4/mkspecs/features/qt.prf \ + /usr/share/qt4/mkspecs/features/unix/thread.prf \ + /usr/share/qt4/mkspecs/features/moc.prf \ + /usr/share/qt4/mkspecs/features/resources.prf \ + /usr/share/qt4/mkspecs/features/uic.prf \ + /usr/share/qt4/mkspecs/features/yacc.prf \ + /usr/share/qt4/mkspecs/features/lex.prf \ + /usr/share/qt4/mkspecs/features/include_source_dir.prf \ + mathmech.pro +QMAKE_TARGET = mathmech +DESTDIR = +TARGET = mathmech + +first: all +####### Implicit rules + +.SUFFIXES: .o .c .cpp .cc .cxx .C + +.cpp.o: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o "$@" "$<" + +.cc.o: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o "$@" "$<" + +.cxx.o: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o "$@" "$<" + +.C.o: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o "$@" "$<" + +.c.o: + $(CC) -c $(CFLAGS) $(INCPATH) -o "$@" "$<" + +####### Build rules + +all: Makefile $(TARGET) + +$(TARGET): ui_mainwindow.h ui_errorwindow.h $(OBJECTS) + $(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJCOMP) $(LIBS) + +Makefile: mathmech.pro /usr/share/qt4/mkspecs/linux-g++/qmake.conf /usr/share/qt4/mkspecs/common/unix.conf \ + /usr/share/qt4/mkspecs/common/linux.conf \ + /usr/share/qt4/mkspecs/common/gcc-base.conf \ + /usr/share/qt4/mkspecs/common/gcc-base-unix.conf \ + /usr/share/qt4/mkspecs/common/g++-base.conf \ + /usr/share/qt4/mkspecs/common/g++-unix.conf \ + /usr/share/qt4/mkspecs/qconfig.pri \ + /usr/share/qt4/mkspecs/modules/qt_phonon.pri \ + /usr/share/qt4/mkspecs/modules/qt_webkit.pri \ + /usr/share/qt4/mkspecs/features/qt_functions.prf \ + /usr/share/qt4/mkspecs/features/qt_config.prf \ + /usr/share/qt4/mkspecs/features/exclusive_builds.prf \ + /usr/share/qt4/mkspecs/features/default_pre.prf \ + /usr/share/qt4/mkspecs/features/release.prf \ + /usr/share/qt4/mkspecs/features/default_post.prf \ + /usr/share/qt4/mkspecs/features/shared.prf \ + /usr/share/qt4/mkspecs/features/unix/gdb_dwarf_index.prf \ + /usr/share/qt4/mkspecs/features/warn_on.prf \ + /usr/share/qt4/mkspecs/features/qt.prf \ + /usr/share/qt4/mkspecs/features/unix/thread.prf \ + /usr/share/qt4/mkspecs/features/moc.prf \ + /usr/share/qt4/mkspecs/features/resources.prf \ + /usr/share/qt4/mkspecs/features/uic.prf \ + /usr/share/qt4/mkspecs/features/yacc.prf \ + /usr/share/qt4/mkspecs/features/lex.prf \ + /usr/share/qt4/mkspecs/features/include_source_dir.prf \ + /usr/lib/libQtGui.prl \ + /usr/lib/libQtCore.prl + $(QMAKE) -o Makefile mathmech.pro +/usr/share/qt4/mkspecs/common/unix.conf: +/usr/share/qt4/mkspecs/common/linux.conf: +/usr/share/qt4/mkspecs/common/gcc-base.conf: +/usr/share/qt4/mkspecs/common/gcc-base-unix.conf: +/usr/share/qt4/mkspecs/common/g++-base.conf: +/usr/share/qt4/mkspecs/common/g++-unix.conf: +/usr/share/qt4/mkspecs/qconfig.pri: +/usr/share/qt4/mkspecs/modules/qt_phonon.pri: +/usr/share/qt4/mkspecs/modules/qt_webkit.pri: +/usr/share/qt4/mkspecs/features/qt_functions.prf: +/usr/share/qt4/mkspecs/features/qt_config.prf: +/usr/share/qt4/mkspecs/features/exclusive_builds.prf: +/usr/share/qt4/mkspecs/features/default_pre.prf: +/usr/share/qt4/mkspecs/features/release.prf: +/usr/share/qt4/mkspecs/features/default_post.prf: +/usr/share/qt4/mkspecs/features/shared.prf: +/usr/share/qt4/mkspecs/features/unix/gdb_dwarf_index.prf: +/usr/share/qt4/mkspecs/features/warn_on.prf: +/usr/share/qt4/mkspecs/features/qt.prf: +/usr/share/qt4/mkspecs/features/unix/thread.prf: +/usr/share/qt4/mkspecs/features/moc.prf: +/usr/share/qt4/mkspecs/features/resources.prf: +/usr/share/qt4/mkspecs/features/uic.prf: +/usr/share/qt4/mkspecs/features/yacc.prf: +/usr/share/qt4/mkspecs/features/lex.prf: +/usr/share/qt4/mkspecs/features/include_source_dir.prf: +/usr/lib/libQtGui.prl: +/usr/lib/libQtCore.prl: +qmake: FORCE + @$(QMAKE) -o Makefile mathmech.pro + +dist: + @$(CHK_DIR_EXISTS) .tmp/mathmech1.0.0 || $(MKDIR) .tmp/mathmech1.0.0 + $(COPY_FILE) --parents $(SOURCES) $(DIST) .tmp/mathmech1.0.0/ && $(COPY_FILE) --parents mainwindow.h errorwindow.h clear_items.h start_events.h .tmp/mathmech1.0.0/ && $(COPY_FILE) --parents main.cpp mainwindow.cpp errorwindow.cpp clear_items.cpp start_events.cpp .tmp/mathmech1.0.0/ && $(COPY_FILE) --parents mainwindow.ui errorwindow.ui .tmp/mathmech1.0.0/ && (cd `dirname .tmp/mathmech1.0.0` && $(TAR) mathmech1.0.0.tar mathmech1.0.0 && $(COMPRESS) mathmech1.0.0.tar) && $(MOVE) `dirname .tmp/mathmech1.0.0`/mathmech1.0.0.tar.gz . && $(DEL_FILE) -r .tmp/mathmech1.0.0 + + +clean:compiler_clean + -$(DEL_FILE) $(OBJECTS) + -$(DEL_FILE) *~ core *.core + + +####### Sub-libraries + +distclean: clean + -$(DEL_FILE) $(TARGET) + -$(DEL_FILE) Makefile + + +check: first + +mocclean: compiler_moc_header_clean compiler_moc_source_clean + +mocables: compiler_moc_header_make_all compiler_moc_source_make_all + +compiler_moc_header_make_all: moc_mainwindow.cpp moc_errorwindow.cpp moc_clear_items.cpp moc_start_events.cpp +compiler_moc_header_clean: + -$(DEL_FILE) moc_mainwindow.cpp moc_errorwindow.cpp moc_clear_items.cpp moc_start_events.cpp +moc_mainwindow.cpp: mainwindow.h + /usr/lib/qt4/bin/moc $(DEFINES) $(INCPATH) mainwindow.h -o moc_mainwindow.cpp + +moc_errorwindow.cpp: errorwindow.h + /usr/lib/qt4/bin/moc $(DEFINES) $(INCPATH) errorwindow.h -o moc_errorwindow.cpp + +moc_clear_items.cpp: clear_items.h + /usr/lib/qt4/bin/moc $(DEFINES) $(INCPATH) clear_items.h -o moc_clear_items.cpp + +moc_start_events.cpp: start_events.h + /usr/lib/qt4/bin/moc $(DEFINES) $(INCPATH) start_events.h -o moc_start_events.cpp + +compiler_rcc_make_all: +compiler_rcc_clean: +compiler_image_collection_make_all: qmake_image_collection.cpp +compiler_image_collection_clean: + -$(DEL_FILE) qmake_image_collection.cpp +compiler_moc_source_make_all: +compiler_moc_source_clean: +compiler_uic_make_all: ui_mainwindow.h ui_errorwindow.h +compiler_uic_clean: + -$(DEL_FILE) ui_mainwindow.h ui_errorwindow.h +ui_mainwindow.h: mainwindow.ui + /usr/lib/qt4/bin/uic mainwindow.ui -o ui_mainwindow.h + +ui_errorwindow.h: errorwindow.ui + /usr/lib/qt4/bin/uic errorwindow.ui -o ui_errorwindow.h + +compiler_yacc_decl_make_all: +compiler_yacc_decl_clean: +compiler_yacc_impl_make_all: +compiler_yacc_impl_clean: +compiler_lex_make_all: +compiler_lex_clean: +compiler_clean: compiler_moc_header_clean compiler_uic_clean + +####### Compile + +main.o: main.cpp mainwindow.h + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o main.o main.cpp + +mainwindow.o: mainwindow.cpp mainwindow.h \ + ui_mainwindow.h \ + clear_items.h \ + start_events.h + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o mainwindow.o mainwindow.cpp + +errorwindow.o: errorwindow.cpp errorwindow.h \ + ui_errorwindow.h + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o errorwindow.o errorwindow.cpp + +clear_items.o: clear_items.cpp clear_items.h \ + mainwindow.h \ + ui_mainwindow.h + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o clear_items.o clear_items.cpp + +start_events.o: start_events.cpp start_events.h \ + mainwindow.h \ + ui_mainwindow.h \ + errorwindow.h \ + ui_errorwindow.h + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o start_events.o start_events.cpp + +moc_mainwindow.o: moc_mainwindow.cpp + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o moc_mainwindow.o moc_mainwindow.cpp + +moc_errorwindow.o: moc_errorwindow.cpp + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o moc_errorwindow.o moc_errorwindow.cpp + +moc_clear_items.o: moc_clear_items.cpp + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o moc_clear_items.o moc_clear_items.cpp + +moc_start_events.o: moc_start_events.cpp + $(CXX) -c $(CXXFLAGS) $(INCPATH) -o moc_start_events.o moc_start_events.cpp + +####### Install + +install: FORCE + +uninstall: FORCE + +FORCE: + diff --git a/mathmech/bin/mm_agl b/mathmech/bin/mm_agl new file mode 100755 index 0000000..856b7ba Binary files /dev/null and b/mathmech/bin/mm_agl differ diff --git a/mathmech/bin/mm_envir b/mathmech/bin/mm_envir new file mode 100755 index 0000000..8de9f79 Binary files /dev/null and b/mathmech/bin/mm_envir differ diff --git a/mathmech/bin/mm_radf b/mathmech/bin/mm_radf new file mode 100755 index 0000000..139dd15 Binary files /dev/null and b/mathmech/bin/mm_radf differ diff --git a/mathmech/bin/mm_statgen b/mathmech/bin/mm_statgen new file mode 100755 index 0000000..0ed5810 Binary files /dev/null and b/mathmech/bin/mm_statgen differ diff --git a/mathmech/bin/mm_trj b/mathmech/bin/mm_trj new file mode 100755 index 0000000..5d7f231 Binary files /dev/null and b/mathmech/bin/mm_trj differ diff --git a/mathmech/bin/mm_trj2pdb b/mathmech/bin/mm_trj2pdb new file mode 100755 index 0000000..d040b8b Binary files /dev/null and b/mathmech/bin/mm_trj2pdb differ diff --git a/mathmech/clear_items.cpp b/mathmech/clear_items.cpp new file mode 100644 index 0000000..1fbc9c9 --- /dev/null +++ b/mathmech/clear_items.cpp @@ -0,0 +1,103 @@ +#include "clear_items.h" + +#include "mainwindow.h" +#include "ui_mainwindow.h" + +Clear_items::Clear_items(MainWindow *wid) : + parent(wid) +{ + +} + +void Clear_items::clear_trj() +{ + parent->ui->trj_lineEdit_workDir->clear(); + parent->ui->trj_lineEdit_input->clear(); + parent->ui->trj_comboBox_type->setCurrentIndex(0); + parent->ui->trj_spinBox_steps->setValue(1); + parent->ui->trj_lineEdit_atoms->clear(); + parent->ui->trj_lineEdit_output->clear(); + parent->ui->trj_spinBox_totalTypes->setValue(1024); + parent->ui->trj_checkBox_log->setCheckState(Qt::Checked); + parent->ui->trj_lineEdit_log->clear(); +} + +void Clear_items::clear_statgen() +{ + parent->ui->statgen_lineEdit_workDir->clear(); + parent->ui->statgen_lineEdit_input->clear(); + parent->ui->statgen_spinBox_stepsFirst->setValue(1); + parent->ui->statgen_spinBox_stepsLast->setValue(1); + parent->ui->statgen_doubleSpinBox_cellX->setValue(0.1); + parent->ui->statgen_doubleSpinBox_cellY->setValue(0.1); + parent->ui->statgen_doubleSpinBox_cellZ->setValue(0.1); + parent->ui->statgen_spinBox_atoms0->setValue(0); + parent->ui->statgen_checkBox_atoms1->setCheckState(Qt::Unchecked); + parent->ui->statgen_spinBox_atoms1->setValue(0); + parent->ui->statgen_spinBox_atoms2->setValue(0); + parent->ui->statgen_spinBox_atoms3->setValue(0); + parent->ui->statgen_doubleSpinBox_int->setValue(0.0); + parent->ui->statgen_listWidget_int->clear(); + parent->ui->statgen_lineEdit_output->clear(); + parent->ui->statgen_checkBox_depth->setCheckState(Qt::Checked); + parent->ui->statgen_spinBox_depth->setValue(10); + parent->ui->statgen_checkBox_log->setCheckState(Qt::Checked); + parent->ui->statgen_lineEdit_log->clear(); +} + +void Clear_items::clear_envir() +{ + parent->ui->envir_lineEdit_workDir->clear(); + parent->ui->envir_lineEdit_input->clear(); + parent->ui->envir_doubleSpinBox_cellX->setValue(0.1); + parent->ui->envir_doubleSpinBox_cellY->setValue(0.1); + parent->ui->envir_doubleSpinBox_cellZ->setValue(0.1); + parent->ui->envir_lineEdit_output->clear(); + parent->ui->envir_spinBox_molecule->setValue(1); + parent->ui->envir_doubleSpinBox_radius->setValue(0.0); + parent->ui->envir_checkBox_log->setCheckState(Qt::Checked); + parent->ui->envir_lineEdit_log->clear(); +} + +void Clear_items::clear_radf() +{ + parent->ui->radf_lineEdit_workDir->clear(); + parent->ui->radf_lineEdit_input->clear(); + parent->ui->radf_spinBox_stepsFirst->setValue(1); + parent->ui->radf_spinBox_stepsLast->setValue(1); + parent->ui->radf_doubleSpinBox_cellX->setValue(0.1); + parent->ui->radf_doubleSpinBox_cellY->setValue(0.1); + parent->ui->radf_doubleSpinBox_cellZ->setValue(0.1); + parent->ui->radf_lineEdit_output->clear(); + parent->ui->radf_comboBox_atom->setCurrentIndex(0); + parent->ui->radf_spinBox_atoms0->setValue(0); + parent->ui->radf_spinBox_atoms1->setValue(0); + parent->ui->radf_spinBox_atoms2->setValue(0); + parent->ui->radf_spinBox_atoms3->setValue(0); + parent->ui->radf_spinBox_atoms4->setValue(0); + parent->ui->radf_spinBox_atoms5->setValue(0); + parent->ui->radf_doubleSpinBox_radMin->setValue(2.0); + parent->ui->radf_doubleSpinBox_radMax->setValue(15.0); + parent->ui->radf_doubleSpinBox_radStep->setValue(0.2); + parent->ui->radf_checkBox_ang->setCheckState(Qt::Unchecked); + parent->ui->radf_doubleSpinBox_angMin->setValue(0.0); + parent->ui->radf_doubleSpinBox_angMax->setValue(90.0); + parent->ui->radf_doubleSpinBox_angStep->setValue(15.0); + parent->ui->radf_checkBox_matrix->setCheckState(Qt::Unchecked); + parent->ui->radf_checkBox_log->setCheckState(Qt::Checked); + parent->ui->radf_lineEdit_log->clear(); +} + +void Clear_items::clear_pdb() +{ + parent->ui->pdb_comboBox_mode->setCurrentIndex(0); + parent->ui->pdb_lineEdit_workDir->clear(); + parent->ui->pdb_lineEdit_input->clear(); + parent->ui->pdb_lineEdit_agl->clear(); + parent->ui->pdb_doubleSpinBox_cellX->setValue(0.1); + parent->ui->pdb_doubleSpinBox_cellY->setValue(0.1); + parent->ui->pdb_doubleSpinBox_cellZ->setValue(0.1); + parent->ui->pdb_lineEdit_output->clear(); + parent->ui->pdb_checkBox_log->setCheckState(Qt::Checked); + parent->ui->pdb_lineEdit_log->clear(); +} diff --git a/mathmech/clear_items.h b/mathmech/clear_items.h new file mode 100644 index 0000000..b7d2471 --- /dev/null +++ b/mathmech/clear_items.h @@ -0,0 +1,27 @@ +#ifndef CLEAR_ITEMS_H +#define CLEAR_ITEMS_H + +#include + +class MainWindow; + +class Clear_items : public QWidget +{ + Q_OBJECT +public: + explicit Clear_items(MainWindow *wid = 0); + void clear_trj(); + void clear_statgen(); + void clear_envir(); + void clear_radf(); + void clear_pdb(); + +signals: + +public slots: + +private: + MainWindow *parent; +}; + +#endif /* CLEAR_ITEMS_H */ diff --git a/mathmech/errorwindow.cpp b/mathmech/errorwindow.cpp new file mode 100644 index 0000000..011102c --- /dev/null +++ b/mathmech/errorwindow.cpp @@ -0,0 +1,63 @@ +#include "errorwindow.h" +#include "ui_errorwindow.h" + +ErrorWindow::ErrorWindow(QWidget *parent) : + QMainWindow(parent), + ui(new Ui::ErrorWindow) +{ + ui->setupUi(this); +} + +ErrorWindow::~ErrorWindow() +{ + delete ui; +} + +void ErrorWindow::set_message(QString language, int mess) +{ + QString message; + if (language == QString("eng")) + { + switch(mess) + { + case 0: + message = QString("Work directory does not exists"); + break; + case 1: + message = QString("Input file does not exists"); + break; + case 2: + message = QString("Number of steps is not set"); + break; + case 3: + message = QString("Atom types file does not exists"); + break; + case 4: + message = QString("Output file is not set"); + break; + case 5: + message = QString("Number of total types is not set"); + break; + case 6: + message = QString("Log file is not set"); + break; + case 7: + message = QString("Component is not found"); + break; + case 8: + message = QString("Cell size is not set"); + break; + case 9: + message = QString("Atom types are not set"); + break; + case 10: + message = QString ("Interactions are not set"); + break; + case 11: + message = QString ("Depth is not set"); + break; + } + } + + ui->label->setText(message); +} diff --git a/mathmech/errorwindow.h b/mathmech/errorwindow.h new file mode 100644 index 0000000..0c7e6f8 --- /dev/null +++ b/mathmech/errorwindow.h @@ -0,0 +1,23 @@ +#ifndef ERRORWINDOW_H +#define ERRORWINDOW_H + +#include + +namespace Ui { + class ErrorWindow; +} + +class ErrorWindow : public QMainWindow +{ + Q_OBJECT + +public: + explicit ErrorWindow(QWidget *parent = 0); + ~ErrorWindow(); + void set_message(QString language, int mess); + +private: + Ui::ErrorWindow *ui; +}; + +#endif /* ERRORWINDOW_H */ diff --git a/mathmech/errorwindow.ui b/mathmech/errorwindow.ui new file mode 100644 index 0000000..27fcd22 --- /dev/null +++ b/mathmech/errorwindow.ui @@ -0,0 +1,129 @@ + + + ErrorWindow + + + + 0 + 0 + 287 + 101 + + + + Error + + + + + + + Qt::Vertical + + + + 20 + 10 + + + + + + + + + + + 0 + 30 + + + + Error text + + + Qt::AlignCenter + + + + + + + + + Qt::Vertical + + + + 20 + 10 + + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 80 + 23 + + + + Ok + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + pushButton + clicked() + ErrorWindow + close() + + + 143 + 93 + + + 143 + 57 + + + + + diff --git a/mathmech/main.cpp b/mathmech/main.cpp new file mode 100644 index 0000000..a3e99a8 --- /dev/null +++ b/mathmech/main.cpp @@ -0,0 +1,14 @@ +#include "mainwindow.h" +#include +#include + +int main(int argc, char *argv[]) +{ + QLocale::setDefault(QLocale::C); + + QApplication a(argc, argv); + MainWindow w; + w.show(); + + return a.exec(); +} diff --git a/mathmech/mainwindow.cpp b/mathmech/mainwindow.cpp new file mode 100644 index 0000000..5a9e570 --- /dev/null +++ b/mathmech/mainwindow.cpp @@ -0,0 +1,552 @@ +#include +#include + +#include "mainwindow.h" +#include "ui_mainwindow.h" +#include "clear_items.h" +#include "start_events.h" + +MainWindow::MainWindow(QWidget *parent) : + QMainWindow(parent), + ui(new Ui::MainWindow), + clear_items(new Clear_items(this)), + start_events(new Start_events(this)) +{ + ui->setupUi(this); + statgen_crit = new float[10]; + + ui->statusBar->showMessage(QString("Ready")); + +// TODO: read config + language = QString("eng"); + mm_agl_path = QString("/home/arcanis/mathmech/bin/mm_agl"); + mm_envir_path = QString("/home/arcanis/mathmech/bin/mm_envir"); + mm_radf_path = QString("/home/arcanis/mathmech/bin/mm_radf"); + mm_statgen_path = QString("/home/arcanis/mathmech/bin/mm_statgen"); + mm_trj_path = QString("/home/arcanis/mathmech/bin/mm_trj"); + mm_trj2pdb_path = QString("/home/arcanis/mathmech/bin/mm_trj2pdb"); +} + +MainWindow::~MainWindow() +{ + delete ui; + delete clear_items; + delete start_events; + delete statgen_crit; +} + +// signals +void MainWindow::on_trj_checkBox_log_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->trj_lineEdit_log->setDisabled(true); + ui->trj_pushButton_log->setDisabled(true); + } + else if (arg1 == 2) + { + ui->trj_lineEdit_log->setEnabled(true); + ui->trj_pushButton_log->setEnabled(true); + ui->trj_lineEdit_log->clear(); + } +} + +void MainWindow::on_statgen_checkBox_depth_stateChanged(int arg1) +{ + if (arg1 == 0) + ui->statgen_spinBox_depth->setDisabled(true); + else if (arg1 == 2) + { + ui->statgen_spinBox_depth->setEnabled(true); + ui->statgen_spinBox_depth->setValue(10); + } +} + +void MainWindow::on_statgen_checkBox_log_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->statgen_lineEdit_log->setDisabled(true); + ui->statgen_pushButton_log->setDisabled(true); + } + else if (arg1 == 2) + { + ui->statgen_lineEdit_log->setEnabled(true); + ui->statgen_pushButton_log->setEnabled(true); + ui->statgen_lineEdit_log->clear(); + } +} + +void MainWindow::on_statgen_checkBox_atoms1_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->statgen_spinBox_atoms1->setDisabled(true); + ui->statgen_checkBox_atoms2->setCheckState(Qt::Unchecked); + ui->statgen_checkBox_atoms2->setDisabled(true); + } + else if (arg1 == 2) + { + ui->statgen_spinBox_atoms1->setEnabled(true); + ui->statgen_spinBox_atoms1->setValue(0); + ui->statgen_checkBox_atoms2->setEnabled(true); + } + update_interaction(); +} + +void MainWindow::on_statgen_checkBox_atoms2_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->statgen_spinBox_atoms2->setDisabled(true); + ui->statgen_checkBox_atoms3->setCheckState(Qt::Unchecked); + ui->statgen_checkBox_atoms3->setDisabled(true); + } + else if (arg1 == 2) + { + ui->statgen_spinBox_atoms2->setEnabled(true); + ui->statgen_spinBox_atoms2->setValue(0); + ui->statgen_checkBox_atoms3->setEnabled(true); + } + update_interaction(); +} + +void MainWindow::on_statgen_checkBox_atoms3_stateChanged(int arg1) +{ + if (arg1 == 0) + ui->statgen_spinBox_atoms3->setDisabled(true); + else if (arg1 == 2) + { + ui->statgen_spinBox_atoms3->setEnabled(true); + ui->statgen_spinBox_atoms3->setValue(0); + } + update_interaction(); +} + +void MainWindow::on_envir_checkBox_log_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->envir_lineEdit_log->setDisabled(true); + ui->envir_pushButton_log->setDisabled(true); + } + else if (arg1 == 2) + { + ui->envir_lineEdit_log->setEnabled(true); + ui->envir_pushButton_log->setEnabled(true); + ui->envir_lineEdit_log->clear(); + } +} + +void MainWindow::on_radf_comboBox_atom_currentIndexChanged(int index) +{ + if (index == 0) + { + ui->radf_spinBox_atoms1->setDisabled(true); + ui->radf_spinBox_atoms2->setDisabled(true); + ui->radf_spinBox_atoms4->setDisabled(true); + ui->radf_spinBox_atoms5->setDisabled(true); + } + else if (index == 1) + { + ui->radf_spinBox_atoms1->setEnabled(true); + ui->radf_spinBox_atoms2->setEnabled(true); + ui->radf_spinBox_atoms4->setEnabled(true); + ui->radf_spinBox_atoms5->setEnabled(true); + ui->radf_spinBox_atoms1->setValue(0); + ui->radf_spinBox_atoms2->setValue(0); + ui->radf_spinBox_atoms4->setValue(0); + ui->radf_spinBox_atoms5->setValue(0); + } +} + +void MainWindow::on_radf_checkBox_ang_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->radf_doubleSpinBox_angMax->setDisabled(true); + ui->radf_doubleSpinBox_angMin->setDisabled(true); + ui->radf_doubleSpinBox_angStep->setDisabled(true); + } + else if (arg1 == 2) + { + ui->radf_doubleSpinBox_angMax->setEnabled(true); + ui->radf_doubleSpinBox_angMin->setEnabled(true); + ui->radf_doubleSpinBox_angStep->setEnabled(true); + ui->radf_doubleSpinBox_angMax->setValue(90.0); + ui->radf_doubleSpinBox_angMin->setValue(0.0); + ui->radf_doubleSpinBox_angStep->setValue(15.0); + } +} + +void MainWindow::on_radf_checkBox_log_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->radf_lineEdit_log->setDisabled(true); + ui->radf_pushButton_log->setDisabled(true); + } + else if (arg1 == 2) + { + ui->radf_lineEdit_log->setEnabled(true); + ui->radf_pushButton_log->setEnabled(true); + ui->radf_lineEdit_log->clear(); + } +} + +void MainWindow::on_pdb_comboBox_mode_currentIndexChanged(int index) +{ + if (index == 1) + { + ui->pdb_lineEdit_agl->setDisabled(true); + ui->pdb_pushButton_agl->setDisabled(true); + ui->pdb_doubleSpinBox_cellX->setDisabled(true); + ui->pdb_doubleSpinBox_cellY->setDisabled(true); + ui->pdb_doubleSpinBox_cellZ->setDisabled(true); + } + else if (index == 0) + { + ui->pdb_lineEdit_agl->clear(); + ui->pdb_doubleSpinBox_cellX->setValue(0.1); + ui->pdb_doubleSpinBox_cellY->setValue(0.1); + ui->pdb_doubleSpinBox_cellZ->setValue(0.1); + ui->pdb_lineEdit_agl->setEnabled(true); + ui->pdb_pushButton_agl->setEnabled(true); + ui->pdb_doubleSpinBox_cellX->setEnabled(true); + ui->pdb_doubleSpinBox_cellY->setEnabled(true); + ui->pdb_doubleSpinBox_cellZ->setEnabled(true); + } +} + +void MainWindow::on_pdb_checkBox_log_stateChanged(int arg1) +{ + if (arg1 == 0) + { + ui->pdb_lineEdit_log->setDisabled(true); + ui->pdb_pushButton_log->setDisabled(true); + } + else if (arg1 == 2) + { + ui->pdb_lineEdit_log->setEnabled(true); + ui->pdb_pushButton_log->setEnabled(true); + ui->pdb_lineEdit_log->clear(); + } +} + +// file dialogs +void MainWindow::on_trj_pushButton_workDir_clicked() +{ + QString dirname = QFileDialog::getExistingDirectory( + this, + tr("Select work directory"), + QDir::currentPath()); + if (!dirname.isEmpty()) + ui->trj_lineEdit_workDir->setText(dirname); +} + +void MainWindow::on_trj_pushButton_input_clicked() +{ + QString filename = QFileDialog::getOpenFileName( + this, + tr("Select trajectory file"), + QDir(ui->trj_lineEdit_workDir->text()).absolutePath(), + tr("All files (*.*)")); + if (!filename.isEmpty()) + ui->trj_lineEdit_input->setText(filename); +} + +void MainWindow::on_trj_pushButton_atoms_clicked() +{ + QString filename = QFileDialog::getOpenFileName( + this, + tr("Select atom types file"), + QDir(ui->trj_lineEdit_workDir->text()).absolutePath(), + tr("Atom types files (*.types);;All files (*.*)")); + if (!filename.isEmpty()) + ui->trj_lineEdit_atoms->setText(filename); +} + +void MainWindow::on_trj_pushButton_log_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save log file as..."), + QDir(ui->trj_lineEdit_workDir->text()).absolutePath(), + tr("Log files (*.log)")); + if (!filename.isEmpty()) + ui->trj_lineEdit_log->setText(filename); +} + +void MainWindow::on_statgen_pushButton_workDir_clicked() +{ + QString dirname = QFileDialog::getExistingDirectory( + this, + tr("Select work directory"), + QDir::currentPath()); + if (!dirname.isEmpty()) + ui->statgen_lineEdit_workDir->setText(dirname); +} + +void MainWindow::on_statgen_pushButton_output_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save output file as..."), + QDir(ui->statgen_lineEdit_workDir->text()).absolutePath(), + tr("Output files (*.dat)")); + if (!filename.isEmpty()) + ui->statgen_lineEdit_output->setText(filename); +} + +void MainWindow::on_statgen_pushButton_log_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save log file as..."), + QDir(ui->statgen_lineEdit_workDir->text()).absolutePath(), + tr("Log files (*.log)")); + if (!filename.isEmpty()) + ui->statgen_lineEdit_log->setText(filename); +} + +void MainWindow::on_envir_pushButton_workDir_clicked() +{ + QString dirname = QFileDialog::getExistingDirectory( + this, + tr("Select work directory"), + QDir::currentPath()); + if (!dirname.isEmpty()) + ui->envir_lineEdit_workDir->setText(dirname); +} + +void MainWindow::on_envir_pushButton_input_clicked() +{ + QString filename = QFileDialog::getOpenFileName( + this, + tr("Select trajectory file"), + QDir(ui->envir_lineEdit_workDir->text()).absolutePath(), + tr("Trajectory files (*.*[0-9])")); + if (!filename.isEmpty()) + ui->envir_lineEdit_input->setText(filename); +} + +void MainWindow::on_envir_pushButton_output_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save PDB file as..."), + QDir(ui->envir_lineEdit_workDir->text()).absolutePath(), + tr("PDB files (*.pdb)")); + if (!filename.isEmpty()) + ui->envir_lineEdit_output->setText(filename); +} + +void MainWindow::on_envir_pushButton_log_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save log file as..."), + QDir(ui->envir_lineEdit_workDir->text()).absolutePath(), + tr("Log files (*.log)")); + if (!filename.isEmpty()) + ui->envir_lineEdit_log->setText(filename); +} + +void MainWindow::on_radf_pushButton_workDir_clicked() +{ + QString dirname = QFileDialog::getExistingDirectory( + this, + tr("Select work directory"), + QDir::currentPath()); + if (!dirname.isEmpty()) + ui->radf_lineEdit_workDir->setText(dirname); +} + +void MainWindow::on_radf_pushButton_output_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save output file as..."), + QDir(ui->radf_lineEdit_workDir->text()).absolutePath(), + tr("Output files (*.dat)")); + if (!filename.isEmpty()) + ui->envir_lineEdit_output->setText(filename); +} + +void MainWindow::on_radf_pushButton_log_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save log file as..."), + QDir(ui->radf_lineEdit_workDir->text()).absolutePath(), + tr("Log files (*.log)")); + if (!filename.isEmpty()) + ui->radf_lineEdit_log->setText(filename); +} + +void MainWindow::on_pdb_pushButton_workDir_clicked() +{ + QString dirname = QFileDialog::getExistingDirectory( + this, + tr("Select work directory"), + QDir::currentPath()); + if (!dirname.isEmpty()) + ui->pdb_lineEdit_workDir->setText(dirname); +} + +void MainWindow::on_pdb_pushButton_input_clicked() +{ + QString filename = QFileDialog::getOpenFileName( + this, + tr("Select trajectory file"), + QDir(ui->pdb_lineEdit_workDir->text()).absolutePath(), + tr("Trajectory files (*.*[0-9])")); + if (!filename.isEmpty()) + ui->pdb_lineEdit_input->setText(filename); +} + +void MainWindow::on_pdb_pushButton_agl_clicked() +{ + QString filename = QFileDialog::getOpenFileName( + this, + tr("Select agglomerate file"), + QDir(ui->pdb_lineEdit_workDir->text()).absolutePath(), + tr("Agglomerate files (*.agl]);;All files (*.*)")); + if (!filename.isEmpty()) + ui->pdb_lineEdit_agl->setText(filename); +} + +void MainWindow::on_pdb_pushButton_output_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save PDB file as..."), + QDir(ui->pdb_lineEdit_workDir->text()).absolutePath(), + tr("PDB files (*.pdb)")); + if (!filename.isEmpty()) + ui->pdb_lineEdit_output->setText(filename); +} + +void MainWindow::on_pdb_pushButton_log_clicked() +{ + QString filename = QFileDialog::getSaveFileName( + this, + tr("Save log file as..."), + QDir(ui->pdb_lineEdit_workDir->text()).absolutePath(), + tr("Log files (*.log)")); + if (!filename.isEmpty()) + ui->pdb_lineEdit_log->setText(filename); +} + +// clear actions +void MainWindow::on_trj_pushButton_clear_clicked() +{ + clear_items->clear_trj(); +} + +void MainWindow::on_statgen_pushButton_clear_clicked() +{ + clear_items->clear_statgen(); +} + +void MainWindow::on_envir_pushButton_clear_clicked() +{ + clear_items->clear_envir(); +} + +void MainWindow::on_radf_pushButton_clear_clicked() +{ + clear_items->clear_radf(); +} + +void MainWindow::on_pdb_pushButton_clear_clicked() +{ + clear_items->clear_pdb(); +} + +// set interaction (statgen) +void MainWindow::update_interaction() +{ + int num_inter = 0; + + if (ui->statgen_checkBox_atoms1->checkState() == 2) + num_inter++; + if (ui->statgen_checkBox_atoms2->checkState() == 2) + num_inter++; + if (ui->statgen_checkBox_atoms3->checkState() == 2) + num_inter++; + + ui->statgen_comboBox_int->clear(); + ui->statgen_comboBox_int->addItem("0-0"); + if (num_inter >= 1) + { + ui->statgen_comboBox_int->addItem("0-1"); + ui->statgen_comboBox_int->addItem("1-1"); + } + if (num_inter >= 2) + { + ui->statgen_comboBox_int->addItem("0-2"); + ui->statgen_comboBox_int->addItem("1-2"); + ui->statgen_comboBox_int->addItem("2-2"); + } + if (num_inter >= 3) + { + ui->statgen_comboBox_int->addItem("0-3"); + ui->statgen_comboBox_int->addItem("1-3"); + ui->statgen_comboBox_int->addItem("2-3"); + ui->statgen_comboBox_int->addItem("3-3"); + } + + for (int i=0; i<10; i++) + statgen_crit[i] = 0.0; +} + +void MainWindow::on_statgen_comboBox_int_currentIndexChanged(int index) +{ + ui->statgen_doubleSpinBox_int->setValue(statgen_crit[index]); +} + +void MainWindow::on_stagen_pushButton_intSave_clicked() +{ + int index; + index = ui->statgen_comboBox_int->currentIndex(); + statgen_crit[index] = ui->statgen_doubleSpinBox_int->value(); +} + +void MainWindow::on_statgen_pushButton_intAdd_clicked() +{ + QString interaction; + QString crit; + + int num_inter = ui->statgen_comboBox_int->count(); + for (int i=0; istatgen_comboBox_int->itemText(i)); + interaction.append(QString(":")); + crit.setNum(statgen_crit[i], 'f', 3); + interaction.append(crit); + interaction.append(QString(",")); + } + interaction.remove(interaction.count()-1, 1); + ui->statgen_listWidget_int->addItem(interaction); + ui->statgen_doubleSpinBox_int->setValue(0.0); + for (int i=0; i<10; i++) + statgen_crit[i] = 0.0; +} + +void MainWindow::on_stagen_pushButton_intRem_clicked() +{ + if (int curIndex = ui->statgen_listWidget_int->currentRow() > -1) + delete ui->statgen_listWidget_int->item(curIndex-1); +} + +// start signals +void MainWindow::on_trj_pushButton_start_clicked() +{ + start_events->start_trj(mm_trj_path); +} + +void MainWindow::on_statgen_pushButton_start_clicked() +{ + start_events->start_statgen(mm_statgen_path); +} diff --git a/mathmech/mainwindow.h b/mathmech/mainwindow.h new file mode 100644 index 0000000..c8034c4 --- /dev/null +++ b/mathmech/mainwindow.h @@ -0,0 +1,88 @@ +#ifndef MAINWINDOW_H +#define MAINWINDOW_H + +#include + +class Clear_items; +class Start_events; + +namespace Ui { +class MainWindow; +} + +class MainWindow : public QMainWindow +{ + Q_OBJECT + +public: + explicit MainWindow(QWidget *parent = 0); + ~MainWindow(); + QString language; + +private slots: +// enable/disable signals + void on_trj_checkBox_log_stateChanged (int arg1); + void on_statgen_checkBox_depth_stateChanged (int arg1); + void on_statgen_checkBox_log_stateChanged (int arg1); + void on_statgen_checkBox_atoms1_stateChanged(int arg1); + void on_statgen_checkBox_atoms2_stateChanged(int arg1); + void on_statgen_checkBox_atoms3_stateChanged(int arg1); + void on_envir_checkBox_log_stateChanged(int arg1); + void on_radf_comboBox_atom_currentIndexChanged(int index); + void on_radf_checkBox_ang_stateChanged(int arg1); + void on_radf_checkBox_log_stateChanged(int arg1); + void on_pdb_comboBox_mode_currentIndexChanged(int index); + void on_pdb_checkBox_log_stateChanged(int arg1); +// select directory signals + void on_trj_pushButton_workDir_clicked(); + void on_trj_pushButton_input_clicked(); + void on_trj_pushButton_atoms_clicked(); + void on_trj_pushButton_log_clicked(); + void on_statgen_pushButton_workDir_clicked(); + void on_statgen_pushButton_output_clicked(); + void on_statgen_pushButton_log_clicked(); + void on_envir_pushButton_workDir_clicked(); + void on_envir_pushButton_input_clicked(); + void on_envir_pushButton_output_clicked(); + void on_envir_pushButton_log_clicked(); + void on_radf_pushButton_workDir_clicked(); + void on_radf_pushButton_output_clicked(); + void on_radf_pushButton_log_clicked(); + void on_pdb_pushButton_workDir_clicked(); + void on_pdb_pushButton_input_clicked(); + void on_pdb_pushButton_agl_clicked(); + void on_pdb_pushButton_output_clicked(); + void on_pdb_pushButton_log_clicked(); +// clear signals + void on_trj_pushButton_clear_clicked(); + void on_statgen_pushButton_clear_clicked(); + void on_envir_pushButton_clear_clicked(); + void on_radf_pushButton_clear_clicked(); + void on_pdb_pushButton_clear_clicked(); +// interaction (statgen) + void on_statgen_comboBox_int_currentIndexChanged(int index); + void on_stagen_pushButton_intSave_clicked(); + void on_statgen_pushButton_intAdd_clicked(); + void on_stagen_pushButton_intRem_clicked(); +// start events + void on_trj_pushButton_start_clicked(); + void on_statgen_pushButton_start_clicked(); + +private: + Ui::MainWindow *ui; + void update_interaction(); + float *statgen_crit; + QString mm_agl_path; + QString mm_envir_path; + QString mm_radf_path; + QString mm_statgen_path; + QString mm_trj_path; + QString mm_trj2pdb_path; + + Clear_items *clear_items; + friend class Clear_items; + Start_events *start_events; + friend class Start_events; +}; + +#endif /* MAINWINDOW_H */ diff --git a/mathmech/mainwindow.ui b/mathmech/mainwindow.ui new file mode 100644 index 0000000..ec3aa4f --- /dev/null +++ b/mathmech/mainwindow.ui @@ -0,0 +1,3449 @@ + + + MainWindow + + + + 0 + 0 + 564 + 554 + + + + Mathematical Molecular Mechanics + + + + + + + 0 + + + + Generate trajectory + + + + + + + + + 110 + 23 + + + + Work directory + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Input file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Type of trajectory + + + + + + + + 130 + 23 + + + + + GROMACS text + + + + + PUMA + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 110 + 23 + + + + Number of steps + + + + + + + + 75 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1 + + + 999 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + 110 + 23 + + + + Atom type file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Mask of output files + + + + + + + + 365 + 23 + + + + + + + + + + + + + 110 + 23 + + + + Total atom types + + + + + + + + 80 + 23 + + + + Qt::LeftToRight + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1024 + + + 999999 + + + + + + + + 110 + 23 + + + + Log + + + true + + + + + + + + 80 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + + + + 80 + 23 + + + + Clear + + + true + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 80 + 23 + + + + + 16777215 + 16777215 + + + + Start + + + true + + + + + + + + + + Agglomeration + + + + + + + + + 110 + 23 + + + + Work directory + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Mask of input files + + + + + + + + 280 + 23 + + + + + + + + + + + + + 110 + 23 + + + + Steps + + + + + + + + 75 + 23 + + + + first + + + + + + + + 75 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1 + + + 999 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 75 + 23 + + + + last + + + + + + + + 75 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1 + + + 999 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + 110 + 23 + + + + Cell, A + + + + + + + + 50 + 23 + + + + X + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Y + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Z + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + + + + + 0 + 0 + + + + + 45 + 23 + + + + atom 0 + + + + + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + 65 + 23 + + + + atom 1 + + + + + + + false + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + false + + + + 65 + 23 + + + + atom 2 + + + + + + + false + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + false + + + + 65 + 23 + + + + atom 3 + + + + + + + false + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + + + + + 110 + 23 + + + + Interaction + + + + + + + + 0 + 0 + + + + + 90 + 23 + + + + + 0-0 + + + + + + + + + 0 + 0 + + + + + 90 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + 0.000000000000000 + + + 0.000000000000000 + + + + + + + + 80 + 23 + + + + Save + + + true + + + + + + + + 80 + 23 + + + + Add + + + true + + + + + + + + + + 484 + 85 + + + + QAbstractItemView::NoEditTriggers + + + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 80 + 23 + + + + Remove + + + true + + + + + + + + + + + + 110 + 23 + + + + Output file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Depth of search + + + true + + + + + + + + 80 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + 1000 + + + 10 + + + + + + + + 110 + 23 + + + + Log + + + true + + + + + + + + 80 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 80 + 23 + + + + Clear + + + true + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 80 + 23 + + + + + 16777215 + 16777215 + + + + Start + + + true + + + + + + + + + + Environment + + + + + + + + + 110 + 23 + + + + Work directory + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Input file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Cell, A + + + + + + + + 50 + 23 + + + + X + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Y + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Z + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + + + + + 110 + 23 + + + + Output file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Molecule + + + + + + + + 75 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1 + + + 9999 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 110 + 23 + + + + Radius + + + + + + + + 75 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + 110 + 23 + + + + Log + + + true + + + + + + + + 173 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + Qt::Vertical + + + + 20 + 177 + + + + + + + + + + + 80 + 23 + + + + Clear + + + true + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 80 + 23 + + + + + 16777215 + 16777215 + + + + Start + + + true + + + + + + + + + + RADF + + + + + + + + + 110 + 23 + + + + Work directory + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Mask of input files + + + + + + + + 280 + 23 + + + + + + + + + + + + + 110 + 23 + + + + Steps + + + + + + + + 75 + 23 + + + + first + + + + + + + + 75 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1 + + + 999 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 75 + 23 + + + + last + + + + + + + + 75 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 1 + + + 999 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + + + + + 110 + 23 + + + + Cell, A + + + + + + + + 50 + 23 + + + + X + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Y + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Z + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + + + + + 110 + 23 + + + + Output file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 150 + 23 + + + + + One atom function + + + + + Three atom function + + + + + + + + + 0 + 0 + + + + + 45 + 23 + + + + atom 1 + + + + + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + 0 + 0 + + + + + 45 + 23 + + + + atom 2 + + + + + + + false + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + 0 + 0 + + + + + 45 + 23 + + + + atom 3 + + + + + + + false + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + + + + Qt::Horizontal + + + QSizePolicy::Fixed + + + + 155 + 23 + + + + + + + + + 0 + 0 + + + + + 45 + 23 + + + + atom 1 + + + + + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + 0 + 0 + + + + + 45 + 23 + + + + atom 2 + + + + + + + false + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + 0 + 0 + + + + + 45 + 23 + + + + atom 3 + + + + + + + false + + + + 0 + 0 + + + + + 50 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + + + + + + 110 + 23 + + + + R, A + + + + + + + + 50 + 23 + + + + min + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + 0.000000000000000 + + + 999.990000000000009 + + + 2.000000000000000 + + + + + + + + 50 + 23 + + + + max + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + 0.100000000000000 + + + 999.990000000000009 + + + 15.000000000000000 + + + + + + + + 50 + 23 + + + + step + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 3 + + + 0.001000000000000 + + + 1.000000000000000 + + + 0.010000000000000 + + + 0.020000000000000 + + + + + + + + + + + + 110 + 23 + + + + Angle, deg + + + + + + + + 50 + 23 + + + + min + + + + + + + false + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 2 + + + 0.000000000000000 + + + 90.000000000000000 + + + 15.000000000000000 + + + 0.000000000000000 + + + + + + + + 50 + 23 + + + + max + + + + + + + false + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 2 + + + 0.100000000000000 + + + 90.000000000000000 + + + 15.000000000000000 + + + 90.000000000000000 + + + + + + + + 50 + 23 + + + + step + + + + + + + false + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 2 + + + 0.100000000000000 + + + 90.000000000000000 + + + 15.000000000000000 + + + 15.000000000000000 + + + + + + + + + + + + 110 + 23 + + + + Matrix + + + + + + + + 110 + 23 + + + + Log + + + true + + + + + + + + 150 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + Qt::Vertical + + + + 20 + 47 + + + + + + + + + + + 80 + 23 + + + + Clear + + + true + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 80 + 23 + + + + + 16777215 + 16777215 + + + + Start + + + true + + + + + + + + + + Generate PDB + + + + + + + From agglomerate + + + + + From trajectory snapshot + + + + + + + + + + + 110 + 23 + + + + Work directory + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Input file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 150 + 23 + + + + File with agglomerate + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Cell, A + + + + + + + + 50 + 23 + + + + X + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Y + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + 50 + 23 + + + + Z + + + + + + + + 0 + 0 + + + + + 55 + 23 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 4 + + + 0.100000000000000 + + + 999.990000000000009 + + + + + + + + + + + + 110 + 23 + + + + Output file + + + + + + + + 280 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + + + + 110 + 23 + + + + Log + + + true + + + + + + + + 173 + 23 + + + + + + + + + 80 + 23 + + + + Browse + + + true + + + + + + + + + Qt::Vertical + + + + 20 + 147 + + + + + + + + + + + 80 + 23 + + + + Clear + + + true + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + + 80 + 23 + + + + + 16777215 + 16777215 + + + + Start + + + true + + + + + + + + + + + + + + + 0 + 0 + 564 + 20 + + + + + Menu + + + + + + Help + + + + + + + + + + TopToolBarArea + + + false + + + + + + Exit + + + Ctrl+Q + + + + + Help + + + F1 + + + + + About + + + + + + tabWidget + trj_lineEdit_workDir + trj_pushButton_workDir + trj_lineEdit_input + trj_pushButton_input + trj_comboBox_type + trj_spinBox_steps + trj_lineEdit_atoms + trj_pushButton_atoms + trj_lineEdit_output + trj_spinBox_totalTypes + trj_checkBox_log + trj_lineEdit_log + trj_pushButton_log + trj_pushButton_clear + trj_pushButton_start + statgen_lineEdit_workDir + statgen_pushButton_workDir + statgen_lineEdit_input + statgen_spinBox_stepsFirst + statgen_spinBox_stepsLast + statgen_doubleSpinBox_cellX + statgen_doubleSpinBox_cellY + statgen_doubleSpinBox_cellZ + statgen_spinBox_atoms0 + statgen_checkBox_atoms1 + statgen_spinBox_atoms1 + statgen_checkBox_atoms2 + statgen_spinBox_atoms2 + statgen_checkBox_atoms3 + statgen_spinBox_atoms3 + statgen_comboBox_int + statgen_doubleSpinBox_int + stagen_pushButton_intSave + statgen_pushButton_intAdd + statgen_listWidget_int + stagen_pushButton_intRem + statgen_lineEdit_output + statgen_pushButton_output + statgen_checkBox_depth + statgen_spinBox_depth + statgen_checkBox_log + statgen_lineEdit_log + statgen_pushButton_log + statgen_pushButton_clear + statgen_pushButton_start + envir_lineEdit_workDir + envir_pushButton_workDir + envir_lineEdit_input + envir_pushButton_input + envir_doubleSpinBox_cellX + envir_doubleSpinBox_cellY + envir_doubleSpinBox_cellZ + envir_lineEdit_output + envir_pushButton_output + envir_spinBox_molecule + envir_doubleSpinBox_radius + envir_checkBox_log + envir_lineEdit_log + envir_pushButton_log + envir_pushButton_clear + envir_pushButton_start + radf_lineEdit_workDir + radf_pushButton_workDir + radf_lineEdit_input + radf_spinBox_stepsFirst + radf_spinBox_stepsLast + radf_doubleSpinBox_cellX + radf_doubleSpinBox_cellY + radf_doubleSpinBox_cellZ + radf_lineEdit_output + radf_pushButton_output + radf_comboBox_atom + radf_spinBox_atoms0 + radf_spinBox_atoms1 + radf_spinBox_atoms2 + radf_spinBox_atoms3 + radf_spinBox_atoms4 + radf_spinBox_atoms5 + radf_doubleSpinBox_radMin + radf_doubleSpinBox_radMax + radf_doubleSpinBox_radStep + radf_checkBox_ang + radf_doubleSpinBox_angMin + radf_doubleSpinBox_angMax + radf_doubleSpinBox_angStep + radf_checkBox_matrix + radf_checkBox_log + radf_lineEdit_log + radf_pushButton_log + radf_pushButton_clear + radf_pushButton_start + pdb_comboBox_mode + pdb_lineEdit_workDir + pdb_pushButton_workDir + pdb_lineEdit_input + pdb_pushButton_input + pdb_lineEdit_agl + pdb_pushButton_agl + pdb_doubleSpinBox_cellX + pdb_doubleSpinBox_cellY + pdb_doubleSpinBox_cellZ + pdb_lineEdit_output + pdb_pushButton_output + pdb_checkBox_log + pdb_lineEdit_log + pdb_pushButton_log + pdb_pushButton_clear + pdb_pushButton_start + + + + + actionExit + triggered() + MainWindow + close() + + + -1 + -1 + + + 199 + 149 + + + + + diff --git a/mathmech/mathmech b/mathmech/mathmech new file mode 100755 index 0000000..02c5ccd Binary files /dev/null and b/mathmech/mathmech differ diff --git a/mathmech/mathmech.pro b/mathmech/mathmech.pro new file mode 100644 index 0000000..e02e06c --- /dev/null +++ b/mathmech/mathmech.pro @@ -0,0 +1,20 @@ +###################################################################### +# Automatically generated by qmake (2.01a) ?? ??? 5 17:39:40 2013 +###################################################################### + +TEMPLATE = app +TARGET = +DEPENDPATH += . +INCLUDEPATH += . + +# Input +HEADERS += mainwindow.h \ + errorwindow.h \ + clear_items.h \ + start_events.h +FORMS += mainwindow.ui \ + errorwindow.ui +SOURCES += main.cpp mainwindow.cpp \ + errorwindow.cpp \ + clear_items.cpp \ + start_events.cpp diff --git a/mathmech/mathmech.pro.user b/mathmech/mathmech.pro.user new file mode 100644 index 0000000..0fb0724 --- /dev/null +++ b/mathmech/mathmech.pro.user @@ -0,0 +1,257 @@ + + + + + + ProjectExplorer.Project.ActiveTarget + 0 + + + ProjectExplorer.Project.EditorSettings + + true + false + true + + Cpp + + CppGlobal + + + + QmlJS + + QmlJSGlobal + + + 2 + UTF-8 + false + 4 + false + true + 1 + true + 0 + true + 0 + 8 + true + 1 + true + true + true + false + + + + ProjectExplorer.Project.PluginSettings + + + + ProjectExplorer.Project.Target.0 + + Desktop + Desktop + {a22d6db7-e0a5-452b-9173-b8efacd95ba3} + 0 + 0 + 0 + + + + true + qmake + + QtProjectManager.QMakeBuildStep + false + true + + false + + + true + Сборка + + Qt4ProjectManager.MakeStep + + -w + -r + + false + + + + 2 + Сборка + + ProjectExplorer.BuildSteps.Build + + + + true + Сборка + + Qt4ProjectManager.MakeStep + + -w + -r + + true + clean + + + 1 + Очистка + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Отладка + + Qt4ProjectManager.Qt4BuildConfiguration + 2 + /home/arcanis/build-mathmech-Desktop-Debug + true + + + + + true + qmake + + QtProjectManager.QMakeBuildStep + false + true + + false + + + true + Сборка + + Qt4ProjectManager.MakeStep + + -w + -r + + false + + + + 2 + Сборка + + ProjectExplorer.BuildSteps.Build + + + + true + Сборка + + Qt4ProjectManager.MakeStep + + -w + -r + + true + clean + + + 1 + Очистка + + ProjectExplorer.BuildSteps.Clean + + 2 + false + + Выпуск + + Qt4ProjectManager.Qt4BuildConfiguration + 0 + /home/arcanis/build-mathmech-Desktop-Release + true + + 2 + + + 0 + Установка + + ProjectExplorer.BuildSteps.Deploy + + 1 + Локальная установка + + ProjectExplorer.DefaultDeployConfiguration + + 1 + + + true + + false + false + false + false + true + 0.01 + 10 + true + 25 + + true + valgrind + + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + + 2 + + mathmech + + Qt4ProjectManager.Qt4RunConfiguration:/home/arcanis/mathmech/mathmech.pro + + mathmech.pro + false + false + + 3768 + true + false + false + false + true + + 1 + + + + ProjectExplorer.Project.TargetCount + 1 + + + ProjectExplorer.Project.Updater.EnvironmentId + {ab3ec085-9c1a-4bfc-af86-f7898da68a64} + + + ProjectExplorer.Project.Updater.FileVersion + 14 + + diff --git a/mathmech/moc_clear_items.cpp b/mathmech/moc_clear_items.cpp new file mode 100644 index 0000000..677f6c9 --- /dev/null +++ b/mathmech/moc_clear_items.cpp @@ -0,0 +1,80 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'clear_items.h' +** +** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.5) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include "clear_items.h" +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'clear_items.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 63 +#error "This file was generated using the moc from 4.8.5. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +static const uint qt_meta_data_Clear_items[] = { + + // content: + 6, // revision + 0, // classname + 0, 0, // classinfo + 0, 0, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + 0 // eod +}; + +static const char qt_meta_stringdata_Clear_items[] = { + "Clear_items\0" +}; + +void Clear_items::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + Q_UNUSED(_o); + Q_UNUSED(_id); + Q_UNUSED(_c); + Q_UNUSED(_a); +} + +const QMetaObjectExtraData Clear_items::staticMetaObjectExtraData = { + 0, qt_static_metacall +}; + +const QMetaObject Clear_items::staticMetaObject = { + { &QWidget::staticMetaObject, qt_meta_stringdata_Clear_items, + qt_meta_data_Clear_items, &staticMetaObjectExtraData } +}; + +#ifdef Q_NO_DATA_RELOCATION +const QMetaObject &Clear_items::getStaticMetaObject() { return staticMetaObject; } +#endif //Q_NO_DATA_RELOCATION + +const QMetaObject *Clear_items::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject; +} + +void *Clear_items::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_Clear_items)) + return static_cast(const_cast< Clear_items*>(this)); + return QWidget::qt_metacast(_clname); +} + +int Clear_items::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QWidget::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + return _id; +} +QT_END_MOC_NAMESPACE diff --git a/mathmech/moc_errorwindow.cpp b/mathmech/moc_errorwindow.cpp new file mode 100644 index 0000000..aa21ed5 --- /dev/null +++ b/mathmech/moc_errorwindow.cpp @@ -0,0 +1,80 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'errorwindow.h' +** +** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.5) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include "errorwindow.h" +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'errorwindow.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 63 +#error "This file was generated using the moc from 4.8.5. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +static const uint qt_meta_data_ErrorWindow[] = { + + // content: + 6, // revision + 0, // classname + 0, 0, // classinfo + 0, 0, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + 0 // eod +}; + +static const char qt_meta_stringdata_ErrorWindow[] = { + "ErrorWindow\0" +}; + +void ErrorWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + Q_UNUSED(_o); + Q_UNUSED(_id); + Q_UNUSED(_c); + Q_UNUSED(_a); +} + +const QMetaObjectExtraData ErrorWindow::staticMetaObjectExtraData = { + 0, qt_static_metacall +}; + +const QMetaObject ErrorWindow::staticMetaObject = { + { &QMainWindow::staticMetaObject, qt_meta_stringdata_ErrorWindow, + qt_meta_data_ErrorWindow, &staticMetaObjectExtraData } +}; + +#ifdef Q_NO_DATA_RELOCATION +const QMetaObject &ErrorWindow::getStaticMetaObject() { return staticMetaObject; } +#endif //Q_NO_DATA_RELOCATION + +const QMetaObject *ErrorWindow::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject; +} + +void *ErrorWindow::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_ErrorWindow)) + return static_cast(const_cast< ErrorWindow*>(this)); + return QMainWindow::qt_metacast(_clname); +} + +int ErrorWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QMainWindow::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + return _id; +} +QT_END_MOC_NAMESPACE diff --git a/mathmech/moc_mainwindow.cpp b/mathmech/moc_mainwindow.cpp new file mode 100644 index 0000000..93fa8e6 --- /dev/null +++ b/mathmech/moc_mainwindow.cpp @@ -0,0 +1,215 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'mainwindow.h' +** +** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.5) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include "mainwindow.h" +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'mainwindow.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 63 +#error "This file was generated using the moc from 4.8.5. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +static const uint qt_meta_data_MainWindow[] = { + + // content: + 6, // revision + 0, // classname + 0, 0, // classinfo + 42, 14, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + // slots: signature, parameters, type, tag, flags + 17, 12, 11, 11, 0x08, + 55, 12, 11, 11, 0x08, + 99, 12, 11, 11, 0x08, + 141, 12, 11, 11, 0x08, + 186, 12, 11, 11, 0x08, + 231, 12, 11, 11, 0x08, + 276, 12, 11, 11, 0x08, + 322, 316, 11, 11, 0x08, + 369, 12, 11, 11, 0x08, + 408, 12, 11, 11, 0x08, + 447, 316, 11, 11, 0x08, + 493, 12, 11, 11, 0x08, + 531, 11, 11, 11, 0x08, + 567, 11, 11, 11, 0x08, + 601, 11, 11, 11, 0x08, + 635, 11, 11, 11, 0x08, + 667, 11, 11, 11, 0x08, + 707, 11, 11, 11, 0x08, + 746, 11, 11, 11, 0x08, + 782, 11, 11, 11, 0x08, + 820, 11, 11, 11, 0x08, + 856, 11, 11, 11, 0x08, + 893, 11, 11, 11, 0x08, + 927, 11, 11, 11, 0x08, + 964, 11, 11, 11, 0x08, + 1000, 11, 11, 11, 0x08, + 1033, 11, 11, 11, 0x08, + 1069, 11, 11, 11, 0x08, + 1103, 11, 11, 11, 0x08, + 1135, 11, 11, 11, 0x08, + 1170, 11, 11, 11, 0x08, + 1202, 11, 11, 11, 0x08, + 1236, 11, 11, 11, 0x08, + 1274, 11, 11, 11, 0x08, + 1310, 11, 11, 11, 0x08, + 1345, 11, 11, 11, 0x08, + 1379, 316, 11, 11, 0x08, + 1428, 11, 11, 11, 0x08, + 1467, 11, 11, 11, 0x08, + 1506, 11, 11, 11, 0x08, + 1544, 11, 11, 11, 0x08, + 1578, 11, 11, 11, 0x08, + + 0 // eod +}; + +static const char qt_meta_stringdata_MainWindow[] = { + "MainWindow\0\0arg1\0on_trj_checkBox_log_stateChanged(int)\0" + "on_statgen_checkBox_depth_stateChanged(int)\0" + "on_statgen_checkBox_log_stateChanged(int)\0" + "on_statgen_checkBox_atoms1_stateChanged(int)\0" + "on_statgen_checkBox_atoms2_stateChanged(int)\0" + "on_statgen_checkBox_atoms3_stateChanged(int)\0" + "on_envir_checkBox_log_stateChanged(int)\0" + "index\0on_radf_comboBox_atom_currentIndexChanged(int)\0" + "on_radf_checkBox_ang_stateChanged(int)\0" + "on_radf_checkBox_log_stateChanged(int)\0" + "on_pdb_comboBox_mode_currentIndexChanged(int)\0" + "on_pdb_checkBox_log_stateChanged(int)\0" + "on_trj_pushButton_workDir_clicked()\0" + "on_trj_pushButton_input_clicked()\0" + "on_trj_pushButton_atoms_clicked()\0" + "on_trj_pushButton_log_clicked()\0" + "on_statgen_pushButton_workDir_clicked()\0" + "on_statgen_pushButton_output_clicked()\0" + "on_statgen_pushButton_log_clicked()\0" + "on_envir_pushButton_workDir_clicked()\0" + "on_envir_pushButton_input_clicked()\0" + "on_envir_pushButton_output_clicked()\0" + "on_envir_pushButton_log_clicked()\0" + "on_radf_pushButton_workDir_clicked()\0" + "on_radf_pushButton_output_clicked()\0" + "on_radf_pushButton_log_clicked()\0" + "on_pdb_pushButton_workDir_clicked()\0" + "on_pdb_pushButton_input_clicked()\0" + "on_pdb_pushButton_agl_clicked()\0" + "on_pdb_pushButton_output_clicked()\0" + "on_pdb_pushButton_log_clicked()\0" + "on_trj_pushButton_clear_clicked()\0" + "on_statgen_pushButton_clear_clicked()\0" + "on_envir_pushButton_clear_clicked()\0" + "on_radf_pushButton_clear_clicked()\0" + "on_pdb_pushButton_clear_clicked()\0" + "on_statgen_comboBox_int_currentIndexChanged(int)\0" + "on_stagen_pushButton_intSave_clicked()\0" + "on_statgen_pushButton_intAdd_clicked()\0" + "on_stagen_pushButton_intRem_clicked()\0" + "on_trj_pushButton_start_clicked()\0" + "on_statgen_pushButton_start_clicked()\0" +}; + +void MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + if (_c == QMetaObject::InvokeMetaMethod) { + Q_ASSERT(staticMetaObject.cast(_o)); + MainWindow *_t = static_cast(_o); + switch (_id) { + case 0: _t->on_trj_checkBox_log_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 1: _t->on_statgen_checkBox_depth_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 2: _t->on_statgen_checkBox_log_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 3: _t->on_statgen_checkBox_atoms1_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 4: _t->on_statgen_checkBox_atoms2_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 5: _t->on_statgen_checkBox_atoms3_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 6: _t->on_envir_checkBox_log_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 7: _t->on_radf_comboBox_atom_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 8: _t->on_radf_checkBox_ang_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 9: _t->on_radf_checkBox_log_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 10: _t->on_pdb_comboBox_mode_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 11: _t->on_pdb_checkBox_log_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 12: _t->on_trj_pushButton_workDir_clicked(); break; + case 13: _t->on_trj_pushButton_input_clicked(); break; + case 14: _t->on_trj_pushButton_atoms_clicked(); break; + case 15: _t->on_trj_pushButton_log_clicked(); break; + case 16: _t->on_statgen_pushButton_workDir_clicked(); break; + case 17: _t->on_statgen_pushButton_output_clicked(); break; + case 18: _t->on_statgen_pushButton_log_clicked(); break; + case 19: _t->on_envir_pushButton_workDir_clicked(); break; + case 20: _t->on_envir_pushButton_input_clicked(); break; + case 21: _t->on_envir_pushButton_output_clicked(); break; + case 22: _t->on_envir_pushButton_log_clicked(); break; + case 23: _t->on_radf_pushButton_workDir_clicked(); break; + case 24: _t->on_radf_pushButton_output_clicked(); break; + case 25: _t->on_radf_pushButton_log_clicked(); break; + case 26: _t->on_pdb_pushButton_workDir_clicked(); break; + case 27: _t->on_pdb_pushButton_input_clicked(); break; + case 28: _t->on_pdb_pushButton_agl_clicked(); break; + case 29: _t->on_pdb_pushButton_output_clicked(); break; + case 30: _t->on_pdb_pushButton_log_clicked(); break; + case 31: _t->on_trj_pushButton_clear_clicked(); break; + case 32: _t->on_statgen_pushButton_clear_clicked(); break; + case 33: _t->on_envir_pushButton_clear_clicked(); break; + case 34: _t->on_radf_pushButton_clear_clicked(); break; + case 35: _t->on_pdb_pushButton_clear_clicked(); break; + case 36: _t->on_statgen_comboBox_int_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break; + case 37: _t->on_stagen_pushButton_intSave_clicked(); break; + case 38: _t->on_statgen_pushButton_intAdd_clicked(); break; + case 39: _t->on_stagen_pushButton_intRem_clicked(); break; + case 40: _t->on_trj_pushButton_start_clicked(); break; + case 41: _t->on_statgen_pushButton_start_clicked(); break; + default: ; + } + } +} + +const QMetaObjectExtraData MainWindow::staticMetaObjectExtraData = { + 0, qt_static_metacall +}; + +const QMetaObject MainWindow::staticMetaObject = { + { &QMainWindow::staticMetaObject, qt_meta_stringdata_MainWindow, + qt_meta_data_MainWindow, &staticMetaObjectExtraData } +}; + +#ifdef Q_NO_DATA_RELOCATION +const QMetaObject &MainWindow::getStaticMetaObject() { return staticMetaObject; } +#endif //Q_NO_DATA_RELOCATION + +const QMetaObject *MainWindow::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject; +} + +void *MainWindow::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_MainWindow)) + return static_cast(const_cast< MainWindow*>(this)); + return QMainWindow::qt_metacast(_clname); +} + +int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QMainWindow::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + if (_c == QMetaObject::InvokeMetaMethod) { + if (_id < 42) + qt_static_metacall(this, _c, _id, _a); + _id -= 42; + } + return _id; +} +QT_END_MOC_NAMESPACE diff --git a/mathmech/moc_start_events.cpp b/mathmech/moc_start_events.cpp new file mode 100644 index 0000000..cf96002 --- /dev/null +++ b/mathmech/moc_start_events.cpp @@ -0,0 +1,80 @@ +/**************************************************************************** +** Meta object code from reading C++ file 'start_events.h' +** +** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.5) +** +** WARNING! All changes made in this file will be lost! +*****************************************************************************/ + +#include "start_events.h" +#if !defined(Q_MOC_OUTPUT_REVISION) +#error "The header file 'start_events.h' doesn't include ." +#elif Q_MOC_OUTPUT_REVISION != 63 +#error "This file was generated using the moc from 4.8.5. It" +#error "cannot be used with the include files from this version of Qt." +#error "(The moc has changed too much.)" +#endif + +QT_BEGIN_MOC_NAMESPACE +static const uint qt_meta_data_Start_events[] = { + + // content: + 6, // revision + 0, // classname + 0, 0, // classinfo + 0, 0, // methods + 0, 0, // properties + 0, 0, // enums/sets + 0, 0, // constructors + 0, // flags + 0, // signalCount + + 0 // eod +}; + +static const char qt_meta_stringdata_Start_events[] = { + "Start_events\0" +}; + +void Start_events::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a) +{ + Q_UNUSED(_o); + Q_UNUSED(_id); + Q_UNUSED(_c); + Q_UNUSED(_a); +} + +const QMetaObjectExtraData Start_events::staticMetaObjectExtraData = { + 0, qt_static_metacall +}; + +const QMetaObject Start_events::staticMetaObject = { + { &QWidget::staticMetaObject, qt_meta_stringdata_Start_events, + qt_meta_data_Start_events, &staticMetaObjectExtraData } +}; + +#ifdef Q_NO_DATA_RELOCATION +const QMetaObject &Start_events::getStaticMetaObject() { return staticMetaObject; } +#endif //Q_NO_DATA_RELOCATION + +const QMetaObject *Start_events::metaObject() const +{ + return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject; +} + +void *Start_events::qt_metacast(const char *_clname) +{ + if (!_clname) return 0; + if (!strcmp(_clname, qt_meta_stringdata_Start_events)) + return static_cast(const_cast< Start_events*>(this)); + return QWidget::qt_metacast(_clname); +} + +int Start_events::qt_metacall(QMetaObject::Call _c, int _id, void **_a) +{ + _id = QWidget::qt_metacall(_c, _id, _a); + if (_id < 0) + return _id; + return _id; +} +QT_END_MOC_NAMESPACE diff --git a/mathmech/start_events.cpp b/mathmech/start_events.cpp new file mode 100644 index 0000000..73f7758 --- /dev/null +++ b/mathmech/start_events.cpp @@ -0,0 +1,296 @@ +#include + +#include "start_events.h" + +#include "mainwindow.h" +#include "ui_mainwindow.h" +#include "errorwindow.h" +#include "ui_errorwindow.h" + +#include +#include + +Start_events::Start_events(MainWindow *wid) : + parent(wid) +{ + +} + +void Start_events::start_trj(QString mm_trj_path) +{ + errorwin = new ErrorWindow(parent); + parent->ui->statusBar->showMessage(QApplication::translate("MainWindow", "Processing 'trj'...")); + parent->ui->statusBar->showMessage(QApplication::translate("MainWindow", "Processing 'trj'...")); + +// read variables + QString workDir = parent->ui->trj_lineEdit_workDir->text(); + QString input = parent->ui->trj_lineEdit_input->text(); + QString type; + switch (parent->ui->trj_comboBox_type->currentIndex()) + { + case 0: + type = QString("gmx"); + break; + case 1: + type = QString("puma"); + break; + } + QString steps = QString::number(parent->ui->trj_spinBox_steps->value()); + QString atomType = parent->ui->trj_lineEdit_atoms->text(); + QString mask = parent->ui->trj_lineEdit_output->text(); + QString totalTypes = QString::number(parent->ui->trj_spinBox_totalTypes->value()); + QString log; + if (parent->ui->trj_checkBox_log->checkState() == 2) + log = parent->ui->trj_lineEdit_log->text(); + +// error check + if ((workDir == "") || (!QDir(workDir).exists())) + { + errorwin->set_message(parent->language, 0); + errorwin->show(); + return; + } + if ((input == "") || (!QFile(input).exists())) + { + errorwin->set_message(parent->language, 1); + errorwin->show(); + return; + } + if (steps == "") + { + errorwin->set_message(parent->language, 2); + errorwin->show(); + return; + } + if ((atomType == "") || (!QFile(atomType).exists())) + { + errorwin->set_message(parent->language, 3); + errorwin->show(); + return; + } + if (mask == "") + { + errorwin->set_message(parent->language, 4); + errorwin->show(); + return; + } + if (totalTypes == "") + { + errorwin->set_message(parent->language, 5); + errorwin->show(); + return; + } + if ((parent->ui->trj_checkBox_log->checkState() == 2) && (log == "")) + { + errorwin->set_message(parent->language, 6); + errorwin->show(); + return; + } + if (!QFile(mm_trj_path).exists()) + { + errorwin->set_message(parent->language, 7); + errorwin->show(); + return; + } + +// exec + parent->ui->tabWidget->setDisabled(true); + QString command; + command.append(mm_trj_path); +#ifdef _WIN32 + if (input.contains("\\")) +#elif __linux + if (input.contains("/")) +#else + return; +#endif + command.append(" -i " + QFileInfo(input).absoluteFilePath()); + else + command.append(" -i " + QFileInfo(QDir(workDir), input).absoluteFilePath()); + command.append(" -t " + type); + command.append(" -s " + steps); +#ifdef _WIN32 + if (atomType.contains("\\")) +#elif __linux + if (atomType.contains("/")) +#else + return; +#endif + command.append(" -a " + QFileInfo(atomType).absoluteFilePath()); + else + command.append(" -a " + QFileInfo(QDir(workDir), atomType).absoluteFilePath()); + command.append(" -o " + QFileInfo(QDir(workDir), mask).absoluteFilePath()); + command.append(" -tt " + totalTypes); + if (parent->ui->trj_checkBox_log->checkState() == 2) +#ifdef _WIN32 + if (log.contains("\\")) +#elif __linux + if (log.contains("/")) +#else + return; +#endif + command.append(" -l " + QFileInfo(log).absoluteFilePath()); + else + command.append(" -l " + QFileInfo(QDir(workDir), log).absoluteFilePath()); + command.append(" -q"); + + system(command.toStdString().c_str()); + parent->ui->tabWidget->setEnabled(true); + parent->ui->statusBar->showMessage(QApplication::translate("MainWindow", "Done")); + delete errorwin; +} + +void Start_events::start_statgen(QString mm_statgen_path) +{ + errorwin = new ErrorWindow(parent); + parent->ui->statusBar->showMessage(QApplication::translate("MainWindow", "Processing 'statgen'...")); + parent->ui->statusBar->showMessage(QApplication::translate("MainWindow", "Processing 'statgen'...")); + +// read variables + QString workDir = parent->ui->statgen_lineEdit_workDir->text(); + QString mask = parent->ui->statgen_lineEdit_input->text(); + QString firstStep = QString::number(parent->ui->statgen_spinBox_stepsFirst->value()); + QString lastStep = QString::number(parent->ui->statgen_spinBox_stepsLast->value()); + QString cellX, cellY, cellZ; + cellX.setNum(parent->ui->statgen_doubleSpinBox_cellX->value(), 'f', 4); + cellY.setNum(parent->ui->statgen_doubleSpinBox_cellY->value(), 'f', 4); + cellZ.setNum(parent->ui->statgen_doubleSpinBox_cellZ->value(), 'f', 4); + QString atom0 = QString::number(parent->ui->statgen_spinBox_atoms0->value()); + QString atom1, atom2, atom3; + if (parent->ui->statgen_checkBox_atoms1->checkState() == 2) + atom1.setNum(parent->ui->statgen_spinBox_atoms1->value()); + if (parent->ui->statgen_checkBox_atoms2->checkState() == 2) + atom2.setNum(parent->ui->statgen_spinBox_atoms2->value()); + if (parent->ui->statgen_checkBox_atoms3->checkState() == 2) + atom3.setNum(parent->ui->statgen_spinBox_atoms3->value()); + QString inter; + for (int i=0; iui->statgen_listWidget_int->count(); i++) + inter.append(" -r " + parent->ui->statgen_listWidget_int->item(i)->text()); + QString output = parent->ui->statgen_lineEdit_output->text(); + QString depth; + if (parent->ui->statgen_checkBox_depth->checkState() == 2) + depth.setNum(parent->ui->statgen_spinBox_depth->value()); + QString log; + if (parent->ui->statgen_checkBox_log->checkState() == 2) + log = parent->ui->statgen_lineEdit_log->text(); + +// error check + if ((workDir == "") || (!QDir(workDir).exists())) + { + errorwin->set_message(parent->language, 0); + errorwin->show(); + return; + } + if (mask == "") + { + errorwin->set_message(parent->language, 1); + errorwin->show(); + return; + } + if ((firstStep == "") || (lastStep == "")) + { + errorwin->set_message(parent->language, 2); + errorwin->show(); + return; + } + if ((cellX == "") || (cellY == "") || (cellZ == "")) + { + errorwin->set_message(parent->language, 8); + errorwin->show(); + return; + } + if ((atom0 == "") || + ((atom1 == "") && (parent->ui->statgen_checkBox_atoms1->checkState() == 2)) || + ((atom2 == "") && (parent->ui->statgen_checkBox_atoms2->checkState() == 2)) || + ((atom3 == "") && (parent->ui->statgen_checkBox_atoms3->checkState() == 2))) + { + errorwin->set_message(parent->language, 9); + errorwin->show(); + return; + } + if (parent->ui->statgen_listWidget_int->count() == 0) + { + errorwin->set_message(parent->language, 10); + errorwin->show(); + return; + } + if (output == "") + { + errorwin->set_message(parent->language, 4); + errorwin->show(); + return; + } + if ((parent->ui->statgen_checkBox_depth->checkState() == 2) && (depth == "")) + { + errorwin->set_message(parent->language, 11); + errorwin->show(); + return; + } + if ((parent->ui->statgen_checkBox_log->checkState() == 2) && (log == "")) + { + errorwin->set_message(parent->language, 6); + errorwin->show(); + return; + } + if (!QFile(mm_statgen_path).exists()) + { + errorwin->set_message(parent->language, 7); + errorwin->show(); + return; + } + +// exec + parent->ui->tabWidget->setDisabled(true); + QString command; + command.append(mm_statgen_path); +#ifdef _WIN32 + if (mask.contains("\\")) +#elif __linux + if (mask.contains("/")) +#else + return; +#endif + command.append(" -i " + QFileInfo(mask).absoluteFilePath()); + else + command.append(" -i " + QFileInfo(QDir(workDir), mask).absoluteFilePath()); + command.append(" -s " + firstStep + "," + lastStep); + command.append(" -c " + cellX + "," + cellY + "," + cellZ); + command.append(" -a " + atom0); + if (parent->ui->statgen_checkBox_atoms1->checkState() == 2) + command.append("," + atom1); + if (parent->ui->statgen_checkBox_atoms2->checkState() == 2) + command.append("," + atom2); + if (parent->ui->statgen_checkBox_atoms3->checkState() == 2) + command.append("," + atom3); + command.append(inter); +#ifdef _WIN32 + if (output.contains("\\")) +#elif __linux + if (output.contains("/")) +#else + return; +#endif + command.append(" -o " + QFileInfo(output).absoluteFilePath()); + else + command.append(" -o " + QFileInfo(QDir(workDir), output).absoluteFilePath()); + if (parent->ui->statgen_checkBox_depth->checkState() == 2) + command.append(" -g " + depth); + if (parent->ui->statgen_checkBox_log->checkState() == 2) +#ifdef _WIN32 + if (log.contains("\\")) +#elif __linux + if (log.contains("/")) +#else + return; +#endif + command.append(" -l " + QFileInfo(log).absoluteFilePath()); + else + command.append(" -l " + QFileInfo(QDir(workDir), log).absoluteFilePath()); + command.append(" -q"); + + system(command.toStdString().c_str()); +// execv(command.toStdString().c_str(), NULL); + parent->ui->tabWidget->setEnabled(true); + parent->ui->statusBar->showMessage(QApplication::translate("MainWindow", "Done")); + delete errorwin; +} diff --git a/mathmech/start_events.h b/mathmech/start_events.h new file mode 100644 index 0000000..4155ee1 --- /dev/null +++ b/mathmech/start_events.h @@ -0,0 +1,28 @@ +#ifndef START_EVENTS_H +#define START_EVENTS_H + +#include + +class MainWindow; +class ErrorWindow; + +class Start_events : public QWidget +{ + Q_OBJECT +public: + explicit Start_events(MainWindow *wid = 0); + void start_trj(QString mm_trj_path); + void start_statgen(QString mm_statgen_path); + +signals: + +public slots: + +private slots: + +private: + MainWindow *parent; + ErrorWindow *errorwin; +}; + +#endif /* START_EVENTS_H */ diff --git a/mathmech/ui_errorwindow.h b/mathmech/ui_errorwindow.h new file mode 100644 index 0000000..83a8103 --- /dev/null +++ b/mathmech/ui_errorwindow.h @@ -0,0 +1,112 @@ +/******************************************************************************** +** Form generated from reading UI file 'errorwindow.ui' +** +** Created by: Qt User Interface Compiler version 4.8.5 +** +** WARNING! All changes made in this file will be lost when recompiling UI file! +********************************************************************************/ + +#ifndef UI_ERRORWINDOW_H +#define UI_ERRORWINDOW_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class Ui_ErrorWindow +{ +public: + QWidget *centralwidget; + QVBoxLayout *verticalLayout; + QSpacerItem *verticalSpacer_2; + QHBoxLayout *horizontalLayout_3; + QLabel *label; + QSpacerItem *verticalSpacer; + QHBoxLayout *horizontalLayout; + QSpacerItem *horizontalSpacer; + QPushButton *pushButton; + QSpacerItem *horizontalSpacer_2; + + void setupUi(QMainWindow *ErrorWindow) + { + if (ErrorWindow->objectName().isEmpty()) + ErrorWindow->setObjectName(QString::fromUtf8("ErrorWindow")); + ErrorWindow->resize(287, 101); + centralwidget = new QWidget(ErrorWindow); + centralwidget->setObjectName(QString::fromUtf8("centralwidget")); + verticalLayout = new QVBoxLayout(centralwidget); + verticalLayout->setObjectName(QString::fromUtf8("verticalLayout")); + verticalSpacer_2 = new QSpacerItem(20, 10, QSizePolicy::Minimum, QSizePolicy::Expanding); + + verticalLayout->addItem(verticalSpacer_2); + + horizontalLayout_3 = new QHBoxLayout(); + horizontalLayout_3->setObjectName(QString::fromUtf8("horizontalLayout_3")); + label = new QLabel(centralwidget); + label->setObjectName(QString::fromUtf8("label")); + label->setMinimumSize(QSize(0, 30)); + label->setAlignment(Qt::AlignCenter); + + horizontalLayout_3->addWidget(label); + + + verticalLayout->addLayout(horizontalLayout_3); + + verticalSpacer = new QSpacerItem(20, 10, QSizePolicy::Minimum, QSizePolicy::Expanding); + + verticalLayout->addItem(verticalSpacer); + + horizontalLayout = new QHBoxLayout(); + horizontalLayout->setObjectName(QString::fromUtf8("horizontalLayout")); + horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + horizontalLayout->addItem(horizontalSpacer); + + pushButton = new QPushButton(centralwidget); + pushButton->setObjectName(QString::fromUtf8("pushButton")); + pushButton->setMinimumSize(QSize(80, 23)); + + horizontalLayout->addWidget(pushButton); + + horizontalSpacer_2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + horizontalLayout->addItem(horizontalSpacer_2); + + + verticalLayout->addLayout(horizontalLayout); + + ErrorWindow->setCentralWidget(centralwidget); + + retranslateUi(ErrorWindow); + QObject::connect(pushButton, SIGNAL(clicked()), ErrorWindow, SLOT(close())); + + QMetaObject::connectSlotsByName(ErrorWindow); + } // setupUi + + void retranslateUi(QMainWindow *ErrorWindow) + { + ErrorWindow->setWindowTitle(QApplication::translate("ErrorWindow", "Error", 0, QApplication::UnicodeUTF8)); + label->setText(QApplication::translate("ErrorWindow", "Error text", 0, QApplication::UnicodeUTF8)); + pushButton->setText(QApplication::translate("ErrorWindow", "Ok", 0, QApplication::UnicodeUTF8)); + } // retranslateUi + +}; + +namespace Ui { + class ErrorWindow: public Ui_ErrorWindow {}; +} // namespace Ui + +QT_END_NAMESPACE + +#endif // UI_ERRORWINDOW_H diff --git a/mathmech/ui_mainwindow.h b/mathmech/ui_mainwindow.h new file mode 100644 index 0000000..7f3e891 --- /dev/null +++ b/mathmech/ui_mainwindow.h @@ -0,0 +1,2223 @@ +/******************************************************************************** +** Form generated from reading UI file 'mainwindow.ui' +** +** Created by: Qt User Interface Compiler version 4.8.5 +** +** WARNING! All changes made in this file will be lost when recompiling UI file! +********************************************************************************/ + +#ifndef UI_MAINWINDOW_H +#define UI_MAINWINDOW_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +QT_BEGIN_NAMESPACE + +class Ui_MainWindow +{ +public: + QAction *actionExit; + QAction *actionHelp; + QAction *actionAbout; + QWidget *centralWidget; + QGridLayout *gridLayout; + QTabWidget *tabWidget; + QWidget *trj; + QVBoxLayout *verticalLayout; + QHBoxLayout *trj_layout_workDir; + QLabel *trj_label_workDir; + QLineEdit *trj_lineEdit_workDir; + QPushButton *trj_pushButton_workDir; + QHBoxLayout *trj_layout_input; + QLabel *trj_label_input; + QLineEdit *trj_lineEdit_input; + QPushButton *trj_pushButton_input; + QHBoxLayout *trj_layout_opt_1; + QLabel *trj_label_type; + QComboBox *trj_comboBox_type; + QSpacerItem *horizontalSpacer_2; + QLabel *trj_label_steps; + QSpinBox *trj_spinBox_steps; + QSpacerItem *horizontalSpacer_7; + QHBoxLayout *trj_layout_atoms; + QLabel *trj_label_atoms; + QLineEdit *trj_lineEdit_atoms; + QPushButton *trj_pushButton_atoms; + QHBoxLayout *trj_layout_output; + QLabel *trj_label_output; + QLineEdit *trj_lineEdit_output; + QHBoxLayout *trj_layout_opt_2; + QLabel *trj_label_totalTypes; + QSpinBox *trj_spinBox_totalTypes; + QCheckBox *trj_checkBox_log; + QLineEdit *trj_lineEdit_log; + QPushButton *trj_pushButton_log; + QSpacerItem *verticalSpacer; + QHBoxLayout *trj_layout_buttons; + QPushButton *trj_pushButton_clear; + QSpacerItem *horizontalSpacer; + QPushButton *trj_pushButton_start; + QWidget *statgen; + QVBoxLayout *verticalLayout_2; + QHBoxLayout *statgen_layout_workDir; + QLabel *statgen_label_workDir; + QLineEdit *statgen_lineEdit_workDir; + QPushButton *statgen_pushButton_workDir; + QHBoxLayout *statgen_layout_input; + QLabel *statgen_label_input; + QLineEdit *statgen_lineEdit_input; + QHBoxLayout *statgen_layout_steps; + QLabel *statgen_label_steps; + QLabel *statgen_label_stepsFirst; + QSpinBox *statgen_spinBox_stepsFirst; + QSpacerItem *horizontalSpacer_4; + QLabel *statgen_label_stepsLast; + QSpinBox *statgen_spinBox_stepsLast; + QSpacerItem *horizontalSpacer_6; + QHBoxLayout *statgen_layout_cell; + QLabel *statgen_label_cell; + QLabel *statgen_label_cellX; + QDoubleSpinBox *statgen_doubleSpinBox_cellX; + QLabel *statgen_label_cellY; + QDoubleSpinBox *statgen_doubleSpinBox_cellY; + QLabel *statgen_label_cellZ; + QDoubleSpinBox *statgen_doubleSpinBox_cellZ; + QHBoxLayout *statgen_layout_atoms; + QLabel *statgen_label_atoms0; + QSpinBox *statgen_spinBox_atoms0; + QCheckBox *statgen_checkBox_atoms1; + QSpinBox *statgen_spinBox_atoms1; + QCheckBox *statgen_checkBox_atoms2; + QSpinBox *statgen_spinBox_atoms2; + QCheckBox *statgen_checkBox_atoms3; + QSpinBox *statgen_spinBox_atoms3; + QHBoxLayout *statgen_layout_int; + QLabel *statgen_label_int; + QComboBox *statgen_comboBox_int; + QDoubleSpinBox *statgen_doubleSpinBox_int; + QPushButton *stagen_pushButton_intSave; + QPushButton *statgen_pushButton_intAdd; + QListWidget *statgen_listWidget_int; + QHBoxLayout *stagen_layout_intRem; + QSpacerItem *horizontalSpacer_5; + QPushButton *stagen_pushButton_intRem; + QHBoxLayout *statgen_layout_output; + QLabel *statgen_label_output; + QLineEdit *statgen_lineEdit_output; + QPushButton *statgen_pushButton_output; + QHBoxLayout *statgen_layout_opt; + QCheckBox *statgen_checkBox_depth; + QSpinBox *statgen_spinBox_depth; + QCheckBox *statgen_checkBox_log; + QLineEdit *statgen_lineEdit_log; + QPushButton *statgen_pushButton_log; + QHBoxLayout *statgen_layout_buttons; + QPushButton *statgen_pushButton_clear; + QSpacerItem *horizontalSpacer_3; + QPushButton *statgen_pushButton_start; + QWidget *envir; + QVBoxLayout *verticalLayout_3; + QHBoxLayout *envir_layout_workDir; + QLabel *envir_label_workDir; + QLineEdit *envir_lineEdit_workDir; + QPushButton *envir_pushButton_workDir; + QHBoxLayout *envir_layout_input; + QLabel *envir_label_input; + QLineEdit *envir_lineEdit_input; + QPushButton *envir_pushButton_input; + QHBoxLayout *envir_layout_cell; + QLabel *envir_label_cell; + QLabel *envir_label_cellX; + QDoubleSpinBox *envir_doubleSpinBox_cellX; + QLabel *envir_label_cellY; + QDoubleSpinBox *envir_doubleSpinBox_cellY; + QLabel *envir_label_cellZ; + QDoubleSpinBox *envir_doubleSpinBox_cellZ; + QHBoxLayout *envir_layout_output; + QLabel *envir_label_output; + QLineEdit *envir_lineEdit_output; + QPushButton *envir_pushButton_output; + QHBoxLayout *envir_layout_opt_1; + QLabel *envir_label_molecule; + QSpinBox *envir_spinBox_molecule; + QSpacerItem *horizontalSpacer_8; + QLabel *envir_label_radius; + QDoubleSpinBox *envir_doubleSpinBox_radius; + QSpacerItem *horizontalSpacer_9; + QHBoxLayout *envir_layout_opt_2; + QCheckBox *envir_checkBox_log; + QLineEdit *envir_lineEdit_log; + QPushButton *envir_pushButton_log; + QSpacerItem *verticalSpacer_2; + QHBoxLayout *envir_layout_buttons; + QPushButton *envir_pushButton_clear; + QSpacerItem *horizontalSpacer_10; + QPushButton *envir_pushButton_start; + QWidget *radf; + QVBoxLayout *verticalLayout_4; + QHBoxLayout *radf_layout_workDir; + QLabel *radf_label_workDir; + QLineEdit *radf_lineEdit_workDir; + QPushButton *radf_pushButton_workDir; + QHBoxLayout *radf_layout_input; + QLabel *radf_label_input; + QLineEdit *radf_lineEdit_input; + QHBoxLayout *radf_layout_steps; + QLabel *radf_label_steps; + QLabel *radf_label_stepsFirst; + QSpinBox *radf_spinBox_stepsFirst; + QSpacerItem *horizontalSpacer_11; + QLabel *radf_label_stepsLast; + QSpinBox *radf_spinBox_stepsLast; + QSpacerItem *horizontalSpacer_12; + QHBoxLayout *radf_layout_cell; + QLabel *radf_label_cell; + QLabel *radf_label_cellX; + QDoubleSpinBox *radf_doubleSpinBox_cellX; + QLabel *radf_label_cellY; + QDoubleSpinBox *radf_doubleSpinBox_cellY; + QLabel *radf_label_cellZ; + QDoubleSpinBox *radf_doubleSpinBox_cellZ; + QHBoxLayout *radf_layout_output; + QLabel *radf_label_output; + QLineEdit *radf_lineEdit_output; + QPushButton *radf_pushButton_output; + QHBoxLayout *radf_layout_atom1; + QComboBox *radf_comboBox_atom; + QLabel *radf_label_atoms0; + QSpinBox *radf_spinBox_atoms0; + QLabel *radf_label_atoms1; + QSpinBox *radf_spinBox_atoms1; + QLabel *radf_label_atoms2; + QSpinBox *radf_spinBox_atoms2; + QHBoxLayout *radf_layout_atom2; + QSpacerItem *horizontalSpacer_14; + QLabel *radf_label_atoms3; + QSpinBox *radf_spinBox_atoms3; + QLabel *radf_label_atoms4; + QSpinBox *radf_spinBox_atoms4; + QLabel *radf_label_atoms5; + QSpinBox *radf_spinBox_atoms5; + QHBoxLayout *radf_layout_rad; + QLabel *radf_label_rad; + QLabel *radf_label_radMin; + QDoubleSpinBox *radf_doubleSpinBox_radMin; + QLabel *radf_label_radMax; + QDoubleSpinBox *radf_doubleSpinBox_radMax; + QLabel *radf_label_radStep; + QDoubleSpinBox *radf_doubleSpinBox_radStep; + QHBoxLayout *radf_layout_ang; + QCheckBox *radf_checkBox_ang; + QLabel *radf_label_angMin; + QDoubleSpinBox *radf_doubleSpinBox_angMin; + QLabel *radf_label_angMax; + QDoubleSpinBox *radf_doubleSpinBox_angMax; + QLabel *radf_label_angStep; + QDoubleSpinBox *radf_doubleSpinBox_angStep; + QHBoxLayout *radf_layout_opt; + QCheckBox *radf_checkBox_matrix; + QCheckBox *radf_checkBox_log; + QLineEdit *radf_lineEdit_log; + QPushButton *radf_pushButton_log; + QSpacerItem *verticalSpacer_3; + QHBoxLayout *radf_layout_buttons; + QPushButton *radf_pushButton_clear; + QSpacerItem *horizontalSpacer_13; + QPushButton *radf_pushButton_start; + QWidget *pdb; + QVBoxLayout *verticalLayout_5; + QComboBox *pdb_comboBox_mode; + QHBoxLayout *pdb_layout_workDir; + QLabel *pdb_label_workDir; + QLineEdit *pdb_lineEdit_workDir; + QPushButton *pdb_pushButton_workDir; + QHBoxLayout *pdb_layout_input; + QLabel *pdb_label_input; + QLineEdit *pdb_lineEdit_input; + QPushButton *pdb_pushButton_input; + QHBoxLayout *pdb_layout_agl; + QLabel *pdb_label_agl; + QLineEdit *pdb_lineEdit_agl; + QPushButton *pdb_pushButton_agl; + QHBoxLayout *pdb_layout_cell; + QLabel *pdb_label_cell; + QLabel *pdb_label_cellX; + QDoubleSpinBox *pdb_doubleSpinBox_cellX; + QLabel *pdb_label_cellY; + QDoubleSpinBox *pdb_doubleSpinBox_cellY; + QLabel *pdb_label_cellZ; + QDoubleSpinBox *pdb_doubleSpinBox_cellZ; + QHBoxLayout *pdb_layout_output; + QLabel *pdb_label_output; + QLineEdit *pdb_lineEdit_output; + QPushButton *pdb_pushButton_output; + QHBoxLayout *pdb_layout_opt; + QCheckBox *pdb_checkBox_log; + QLineEdit *pdb_lineEdit_log; + QPushButton *pdb_pushButton_log; + QSpacerItem *verticalSpacer_4; + QHBoxLayout *pdb_layout_buttons; + QPushButton *pdb_pushButton_clear; + QSpacerItem *horizontalSpacer_15; + QPushButton *pdb_pushButton_start; + QMenuBar *menuBar; + QMenu *menuMenu; + QMenu *menuHelp; + QToolBar *mainToolBar; + QStatusBar *statusBar; + + void setupUi(QMainWindow *MainWindow) + { + if (MainWindow->objectName().isEmpty()) + MainWindow->setObjectName(QString::fromUtf8("MainWindow")); + MainWindow->resize(564, 554); + actionExit = new QAction(MainWindow); + actionExit->setObjectName(QString::fromUtf8("actionExit")); + actionHelp = new QAction(MainWindow); + actionHelp->setObjectName(QString::fromUtf8("actionHelp")); + actionAbout = new QAction(MainWindow); + actionAbout->setObjectName(QString::fromUtf8("actionAbout")); + centralWidget = new QWidget(MainWindow); + centralWidget->setObjectName(QString::fromUtf8("centralWidget")); + gridLayout = new QGridLayout(centralWidget); + gridLayout->setSpacing(6); + gridLayout->setContentsMargins(11, 11, 11, 11); + gridLayout->setObjectName(QString::fromUtf8("gridLayout")); + tabWidget = new QTabWidget(centralWidget); + tabWidget->setObjectName(QString::fromUtf8("tabWidget")); + trj = new QWidget(); + trj->setObjectName(QString::fromUtf8("trj")); + verticalLayout = new QVBoxLayout(trj); + verticalLayout->setSpacing(6); + verticalLayout->setContentsMargins(11, 11, 11, 11); + verticalLayout->setObjectName(QString::fromUtf8("verticalLayout")); + trj_layout_workDir = new QHBoxLayout(); + trj_layout_workDir->setSpacing(6); + trj_layout_workDir->setObjectName(QString::fromUtf8("trj_layout_workDir")); + trj_label_workDir = new QLabel(trj); + trj_label_workDir->setObjectName(QString::fromUtf8("trj_label_workDir")); + trj_label_workDir->setMinimumSize(QSize(110, 23)); + + trj_layout_workDir->addWidget(trj_label_workDir); + + trj_lineEdit_workDir = new QLineEdit(trj); + trj_lineEdit_workDir->setObjectName(QString::fromUtf8("trj_lineEdit_workDir")); + trj_lineEdit_workDir->setMinimumSize(QSize(280, 23)); + + trj_layout_workDir->addWidget(trj_lineEdit_workDir); + + trj_pushButton_workDir = new QPushButton(trj); + trj_pushButton_workDir->setObjectName(QString::fromUtf8("trj_pushButton_workDir")); + trj_pushButton_workDir->setMinimumSize(QSize(80, 23)); + trj_pushButton_workDir->setAutoDefault(true); + + trj_layout_workDir->addWidget(trj_pushButton_workDir); + + + verticalLayout->addLayout(trj_layout_workDir); + + trj_layout_input = new QHBoxLayout(); + trj_layout_input->setSpacing(6); + trj_layout_input->setObjectName(QString::fromUtf8("trj_layout_input")); + trj_label_input = new QLabel(trj); + trj_label_input->setObjectName(QString::fromUtf8("trj_label_input")); + trj_label_input->setMinimumSize(QSize(110, 23)); + + trj_layout_input->addWidget(trj_label_input); + + trj_lineEdit_input = new QLineEdit(trj); + trj_lineEdit_input->setObjectName(QString::fromUtf8("trj_lineEdit_input")); + trj_lineEdit_input->setMinimumSize(QSize(280, 23)); + + trj_layout_input->addWidget(trj_lineEdit_input); + + trj_pushButton_input = new QPushButton(trj); + trj_pushButton_input->setObjectName(QString::fromUtf8("trj_pushButton_input")); + trj_pushButton_input->setMinimumSize(QSize(80, 23)); + trj_pushButton_input->setAutoDefault(true); + + trj_layout_input->addWidget(trj_pushButton_input); + + + verticalLayout->addLayout(trj_layout_input); + + trj_layout_opt_1 = new QHBoxLayout(); + trj_layout_opt_1->setSpacing(6); + trj_layout_opt_1->setObjectName(QString::fromUtf8("trj_layout_opt_1")); + trj_label_type = new QLabel(trj); + trj_label_type->setObjectName(QString::fromUtf8("trj_label_type")); + trj_label_type->setMinimumSize(QSize(110, 23)); + + trj_layout_opt_1->addWidget(trj_label_type); + + trj_comboBox_type = new QComboBox(trj); + trj_comboBox_type->setObjectName(QString::fromUtf8("trj_comboBox_type")); + trj_comboBox_type->setMinimumSize(QSize(130, 23)); + + trj_layout_opt_1->addWidget(trj_comboBox_type); + + horizontalSpacer_2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + trj_layout_opt_1->addItem(horizontalSpacer_2); + + trj_label_steps = new QLabel(trj); + trj_label_steps->setObjectName(QString::fromUtf8("trj_label_steps")); + trj_label_steps->setMinimumSize(QSize(110, 23)); + + trj_layout_opt_1->addWidget(trj_label_steps); + + trj_spinBox_steps = new QSpinBox(trj); + trj_spinBox_steps->setObjectName(QString::fromUtf8("trj_spinBox_steps")); + trj_spinBox_steps->setMinimumSize(QSize(75, 23)); + trj_spinBox_steps->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + trj_spinBox_steps->setMinimum(1); + trj_spinBox_steps->setMaximum(999); + + trj_layout_opt_1->addWidget(trj_spinBox_steps); + + horizontalSpacer_7 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + trj_layout_opt_1->addItem(horizontalSpacer_7); + + + verticalLayout->addLayout(trj_layout_opt_1); + + trj_layout_atoms = new QHBoxLayout(); + trj_layout_atoms->setSpacing(6); + trj_layout_atoms->setObjectName(QString::fromUtf8("trj_layout_atoms")); + trj_label_atoms = new QLabel(trj); + trj_label_atoms->setObjectName(QString::fromUtf8("trj_label_atoms")); + trj_label_atoms->setMinimumSize(QSize(110, 23)); + + trj_layout_atoms->addWidget(trj_label_atoms); + + trj_lineEdit_atoms = new QLineEdit(trj); + trj_lineEdit_atoms->setObjectName(QString::fromUtf8("trj_lineEdit_atoms")); + trj_lineEdit_atoms->setMinimumSize(QSize(280, 23)); + + trj_layout_atoms->addWidget(trj_lineEdit_atoms); + + trj_pushButton_atoms = new QPushButton(trj); + trj_pushButton_atoms->setObjectName(QString::fromUtf8("trj_pushButton_atoms")); + trj_pushButton_atoms->setMinimumSize(QSize(80, 23)); + trj_pushButton_atoms->setAutoDefault(true); + + trj_layout_atoms->addWidget(trj_pushButton_atoms); + + + verticalLayout->addLayout(trj_layout_atoms); + + trj_layout_output = new QHBoxLayout(); + trj_layout_output->setSpacing(6); + trj_layout_output->setObjectName(QString::fromUtf8("trj_layout_output")); + trj_label_output = new QLabel(trj); + trj_label_output->setObjectName(QString::fromUtf8("trj_label_output")); + trj_label_output->setMinimumSize(QSize(110, 23)); + + trj_layout_output->addWidget(trj_label_output); + + trj_lineEdit_output = new QLineEdit(trj); + trj_lineEdit_output->setObjectName(QString::fromUtf8("trj_lineEdit_output")); + trj_lineEdit_output->setMinimumSize(QSize(365, 23)); + + trj_layout_output->addWidget(trj_lineEdit_output); + + + verticalLayout->addLayout(trj_layout_output); + + trj_layout_opt_2 = new QHBoxLayout(); + trj_layout_opt_2->setSpacing(6); + trj_layout_opt_2->setObjectName(QString::fromUtf8("trj_layout_opt_2")); + trj_label_totalTypes = new QLabel(trj); + trj_label_totalTypes->setObjectName(QString::fromUtf8("trj_label_totalTypes")); + trj_label_totalTypes->setMinimumSize(QSize(110, 23)); + + trj_layout_opt_2->addWidget(trj_label_totalTypes); + + trj_spinBox_totalTypes = new QSpinBox(trj); + trj_spinBox_totalTypes->setObjectName(QString::fromUtf8("trj_spinBox_totalTypes")); + trj_spinBox_totalTypes->setMinimumSize(QSize(80, 23)); + trj_spinBox_totalTypes->setLayoutDirection(Qt::LeftToRight); + trj_spinBox_totalTypes->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + trj_spinBox_totalTypes->setMinimum(1024); + trj_spinBox_totalTypes->setMaximum(999999); + + trj_layout_opt_2->addWidget(trj_spinBox_totalTypes); + + trj_checkBox_log = new QCheckBox(trj); + trj_checkBox_log->setObjectName(QString::fromUtf8("trj_checkBox_log")); + trj_checkBox_log->setMinimumSize(QSize(110, 23)); + trj_checkBox_log->setChecked(true); + + trj_layout_opt_2->addWidget(trj_checkBox_log); + + trj_lineEdit_log = new QLineEdit(trj); + trj_lineEdit_log->setObjectName(QString::fromUtf8("trj_lineEdit_log")); + trj_lineEdit_log->setMinimumSize(QSize(80, 23)); + + trj_layout_opt_2->addWidget(trj_lineEdit_log); + + trj_pushButton_log = new QPushButton(trj); + trj_pushButton_log->setObjectName(QString::fromUtf8("trj_pushButton_log")); + trj_pushButton_log->setMinimumSize(QSize(80, 23)); + trj_pushButton_log->setAutoDefault(true); + + trj_layout_opt_2->addWidget(trj_pushButton_log); + + + verticalLayout->addLayout(trj_layout_opt_2); + + verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding); + + verticalLayout->addItem(verticalSpacer); + + trj_layout_buttons = new QHBoxLayout(); + trj_layout_buttons->setSpacing(6); + trj_layout_buttons->setObjectName(QString::fromUtf8("trj_layout_buttons")); + trj_pushButton_clear = new QPushButton(trj); + trj_pushButton_clear->setObjectName(QString::fromUtf8("trj_pushButton_clear")); + trj_pushButton_clear->setMinimumSize(QSize(80, 23)); + trj_pushButton_clear->setAutoDefault(true); + + trj_layout_buttons->addWidget(trj_pushButton_clear); + + horizontalSpacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + trj_layout_buttons->addItem(horizontalSpacer); + + trj_pushButton_start = new QPushButton(trj); + trj_pushButton_start->setObjectName(QString::fromUtf8("trj_pushButton_start")); + trj_pushButton_start->setMinimumSize(QSize(80, 23)); + trj_pushButton_start->setMaximumSize(QSize(16777215, 16777215)); + trj_pushButton_start->setAutoDefault(true); + + trj_layout_buttons->addWidget(trj_pushButton_start); + + + verticalLayout->addLayout(trj_layout_buttons); + + tabWidget->addTab(trj, QString()); + statgen = new QWidget(); + statgen->setObjectName(QString::fromUtf8("statgen")); + verticalLayout_2 = new QVBoxLayout(statgen); + verticalLayout_2->setSpacing(6); + verticalLayout_2->setContentsMargins(11, 11, 11, 11); + verticalLayout_2->setObjectName(QString::fromUtf8("verticalLayout_2")); + statgen_layout_workDir = new QHBoxLayout(); + statgen_layout_workDir->setSpacing(6); + statgen_layout_workDir->setObjectName(QString::fromUtf8("statgen_layout_workDir")); + statgen_label_workDir = new QLabel(statgen); + statgen_label_workDir->setObjectName(QString::fromUtf8("statgen_label_workDir")); + statgen_label_workDir->setMinimumSize(QSize(110, 23)); + + statgen_layout_workDir->addWidget(statgen_label_workDir); + + statgen_lineEdit_workDir = new QLineEdit(statgen); + statgen_lineEdit_workDir->setObjectName(QString::fromUtf8("statgen_lineEdit_workDir")); + statgen_lineEdit_workDir->setMinimumSize(QSize(280, 23)); + + statgen_layout_workDir->addWidget(statgen_lineEdit_workDir); + + statgen_pushButton_workDir = new QPushButton(statgen); + statgen_pushButton_workDir->setObjectName(QString::fromUtf8("statgen_pushButton_workDir")); + statgen_pushButton_workDir->setMinimumSize(QSize(80, 23)); + statgen_pushButton_workDir->setAutoDefault(true); + + statgen_layout_workDir->addWidget(statgen_pushButton_workDir); + + + verticalLayout_2->addLayout(statgen_layout_workDir); + + statgen_layout_input = new QHBoxLayout(); + statgen_layout_input->setSpacing(6); + statgen_layout_input->setObjectName(QString::fromUtf8("statgen_layout_input")); + statgen_label_input = new QLabel(statgen); + statgen_label_input->setObjectName(QString::fromUtf8("statgen_label_input")); + statgen_label_input->setMinimumSize(QSize(110, 23)); + + statgen_layout_input->addWidget(statgen_label_input); + + statgen_lineEdit_input = new QLineEdit(statgen); + statgen_lineEdit_input->setObjectName(QString::fromUtf8("statgen_lineEdit_input")); + statgen_lineEdit_input->setMinimumSize(QSize(280, 23)); + + statgen_layout_input->addWidget(statgen_lineEdit_input); + + + verticalLayout_2->addLayout(statgen_layout_input); + + statgen_layout_steps = new QHBoxLayout(); + statgen_layout_steps->setSpacing(6); + statgen_layout_steps->setObjectName(QString::fromUtf8("statgen_layout_steps")); + statgen_label_steps = new QLabel(statgen); + statgen_label_steps->setObjectName(QString::fromUtf8("statgen_label_steps")); + statgen_label_steps->setMinimumSize(QSize(110, 23)); + + statgen_layout_steps->addWidget(statgen_label_steps); + + statgen_label_stepsFirst = new QLabel(statgen); + statgen_label_stepsFirst->setObjectName(QString::fromUtf8("statgen_label_stepsFirst")); + statgen_label_stepsFirst->setMinimumSize(QSize(75, 23)); + + statgen_layout_steps->addWidget(statgen_label_stepsFirst); + + statgen_spinBox_stepsFirst = new QSpinBox(statgen); + statgen_spinBox_stepsFirst->setObjectName(QString::fromUtf8("statgen_spinBox_stepsFirst")); + statgen_spinBox_stepsFirst->setMinimumSize(QSize(75, 23)); + statgen_spinBox_stepsFirst->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + statgen_spinBox_stepsFirst->setMinimum(1); + statgen_spinBox_stepsFirst->setMaximum(999); + + statgen_layout_steps->addWidget(statgen_spinBox_stepsFirst); + + horizontalSpacer_4 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + statgen_layout_steps->addItem(horizontalSpacer_4); + + statgen_label_stepsLast = new QLabel(statgen); + statgen_label_stepsLast->setObjectName(QString::fromUtf8("statgen_label_stepsLast")); + statgen_label_stepsLast->setMinimumSize(QSize(75, 23)); + + statgen_layout_steps->addWidget(statgen_label_stepsLast); + + statgen_spinBox_stepsLast = new QSpinBox(statgen); + statgen_spinBox_stepsLast->setObjectName(QString::fromUtf8("statgen_spinBox_stepsLast")); + statgen_spinBox_stepsLast->setMinimumSize(QSize(75, 23)); + statgen_spinBox_stepsLast->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + statgen_spinBox_stepsLast->setMinimum(1); + statgen_spinBox_stepsLast->setMaximum(999); + + statgen_layout_steps->addWidget(statgen_spinBox_stepsLast); + + horizontalSpacer_6 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + statgen_layout_steps->addItem(horizontalSpacer_6); + + + verticalLayout_2->addLayout(statgen_layout_steps); + + statgen_layout_cell = new QHBoxLayout(); + statgen_layout_cell->setSpacing(6); + statgen_layout_cell->setObjectName(QString::fromUtf8("statgen_layout_cell")); + statgen_label_cell = new QLabel(statgen); + statgen_label_cell->setObjectName(QString::fromUtf8("statgen_label_cell")); + statgen_label_cell->setMinimumSize(QSize(110, 23)); + + statgen_layout_cell->addWidget(statgen_label_cell); + + statgen_label_cellX = new QLabel(statgen); + statgen_label_cellX->setObjectName(QString::fromUtf8("statgen_label_cellX")); + statgen_label_cellX->setMinimumSize(QSize(50, 23)); + + statgen_layout_cell->addWidget(statgen_label_cellX); + + statgen_doubleSpinBox_cellX = new QDoubleSpinBox(statgen); + statgen_doubleSpinBox_cellX->setObjectName(QString::fromUtf8("statgen_doubleSpinBox_cellX")); + QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed); + sizePolicy.setHorizontalStretch(0); + sizePolicy.setVerticalStretch(0); + sizePolicy.setHeightForWidth(statgen_doubleSpinBox_cellX->sizePolicy().hasHeightForWidth()); + statgen_doubleSpinBox_cellX->setSizePolicy(sizePolicy); + statgen_doubleSpinBox_cellX->setMinimumSize(QSize(55, 23)); + statgen_doubleSpinBox_cellX->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + statgen_doubleSpinBox_cellX->setDecimals(4); + statgen_doubleSpinBox_cellX->setMinimum(0.1); + statgen_doubleSpinBox_cellX->setMaximum(999.99); + + statgen_layout_cell->addWidget(statgen_doubleSpinBox_cellX); + + statgen_label_cellY = new QLabel(statgen); + statgen_label_cellY->setObjectName(QString::fromUtf8("statgen_label_cellY")); + statgen_label_cellY->setMinimumSize(QSize(50, 23)); + + statgen_layout_cell->addWidget(statgen_label_cellY); + + statgen_doubleSpinBox_cellY = new QDoubleSpinBox(statgen); + statgen_doubleSpinBox_cellY->setObjectName(QString::fromUtf8("statgen_doubleSpinBox_cellY")); + sizePolicy.setHeightForWidth(statgen_doubleSpinBox_cellY->sizePolicy().hasHeightForWidth()); + statgen_doubleSpinBox_cellY->setSizePolicy(sizePolicy); + statgen_doubleSpinBox_cellY->setMinimumSize(QSize(55, 23)); + statgen_doubleSpinBox_cellY->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + statgen_doubleSpinBox_cellY->setDecimals(4); + statgen_doubleSpinBox_cellY->setMinimum(0.1); + statgen_doubleSpinBox_cellY->setMaximum(999.99); + + statgen_layout_cell->addWidget(statgen_doubleSpinBox_cellY); + + statgen_label_cellZ = new QLabel(statgen); + statgen_label_cellZ->setObjectName(QString::fromUtf8("statgen_label_cellZ")); + statgen_label_cellZ->setMinimumSize(QSize(50, 23)); + + statgen_layout_cell->addWidget(statgen_label_cellZ); + + statgen_doubleSpinBox_cellZ = new QDoubleSpinBox(statgen); + statgen_doubleSpinBox_cellZ->setObjectName(QString::fromUtf8("statgen_doubleSpinBox_cellZ")); + sizePolicy.setHeightForWidth(statgen_doubleSpinBox_cellZ->sizePolicy().hasHeightForWidth()); + statgen_doubleSpinBox_cellZ->setSizePolicy(sizePolicy); + statgen_doubleSpinBox_cellZ->setMinimumSize(QSize(55, 23)); + statgen_doubleSpinBox_cellZ->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + statgen_doubleSpinBox_cellZ->setDecimals(4); + statgen_doubleSpinBox_cellZ->setMinimum(0.1); + statgen_doubleSpinBox_cellZ->setMaximum(999.99); + + statgen_layout_cell->addWidget(statgen_doubleSpinBox_cellZ); + + + verticalLayout_2->addLayout(statgen_layout_cell); + + statgen_layout_atoms = new QHBoxLayout(); + statgen_layout_atoms->setSpacing(6); + statgen_layout_atoms->setObjectName(QString::fromUtf8("statgen_layout_atoms")); + statgen_label_atoms0 = new QLabel(statgen); + statgen_label_atoms0->setObjectName(QString::fromUtf8("statgen_label_atoms0")); + QSizePolicy sizePolicy1(QSizePolicy::Minimum, QSizePolicy::Fixed); + sizePolicy1.setHorizontalStretch(0); + sizePolicy1.setVerticalStretch(0); + sizePolicy1.setHeightForWidth(statgen_label_atoms0->sizePolicy().hasHeightForWidth()); + statgen_label_atoms0->setSizePolicy(sizePolicy1); + statgen_label_atoms0->setMinimumSize(QSize(45, 23)); + + statgen_layout_atoms->addWidget(statgen_label_atoms0); + + statgen_spinBox_atoms0 = new QSpinBox(statgen); + statgen_spinBox_atoms0->setObjectName(QString::fromUtf8("statgen_spinBox_atoms0")); + sizePolicy.setHeightForWidth(statgen_spinBox_atoms0->sizePolicy().hasHeightForWidth()); + statgen_spinBox_atoms0->setSizePolicy(sizePolicy); + statgen_spinBox_atoms0->setMinimumSize(QSize(50, 23)); + statgen_spinBox_atoms0->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + statgen_layout_atoms->addWidget(statgen_spinBox_atoms0); + + statgen_checkBox_atoms1 = new QCheckBox(statgen); + statgen_checkBox_atoms1->setObjectName(QString::fromUtf8("statgen_checkBox_atoms1")); + statgen_checkBox_atoms1->setMinimumSize(QSize(65, 23)); + + statgen_layout_atoms->addWidget(statgen_checkBox_atoms1); + + statgen_spinBox_atoms1 = new QSpinBox(statgen); + statgen_spinBox_atoms1->setObjectName(QString::fromUtf8("statgen_spinBox_atoms1")); + statgen_spinBox_atoms1->setEnabled(false); + sizePolicy.setHeightForWidth(statgen_spinBox_atoms1->sizePolicy().hasHeightForWidth()); + statgen_spinBox_atoms1->setSizePolicy(sizePolicy); + statgen_spinBox_atoms1->setMinimumSize(QSize(50, 23)); + statgen_spinBox_atoms1->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + statgen_layout_atoms->addWidget(statgen_spinBox_atoms1); + + statgen_checkBox_atoms2 = new QCheckBox(statgen); + statgen_checkBox_atoms2->setObjectName(QString::fromUtf8("statgen_checkBox_atoms2")); + statgen_checkBox_atoms2->setEnabled(false); + statgen_checkBox_atoms2->setMinimumSize(QSize(65, 23)); + + statgen_layout_atoms->addWidget(statgen_checkBox_atoms2); + + statgen_spinBox_atoms2 = new QSpinBox(statgen); + statgen_spinBox_atoms2->setObjectName(QString::fromUtf8("statgen_spinBox_atoms2")); + statgen_spinBox_atoms2->setEnabled(false); + sizePolicy.setHeightForWidth(statgen_spinBox_atoms2->sizePolicy().hasHeightForWidth()); + statgen_spinBox_atoms2->setSizePolicy(sizePolicy); + statgen_spinBox_atoms2->setMinimumSize(QSize(50, 23)); + statgen_spinBox_atoms2->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + statgen_layout_atoms->addWidget(statgen_spinBox_atoms2); + + statgen_checkBox_atoms3 = new QCheckBox(statgen); + statgen_checkBox_atoms3->setObjectName(QString::fromUtf8("statgen_checkBox_atoms3")); + statgen_checkBox_atoms3->setEnabled(false); + statgen_checkBox_atoms3->setMinimumSize(QSize(65, 23)); + + statgen_layout_atoms->addWidget(statgen_checkBox_atoms3); + + statgen_spinBox_atoms3 = new QSpinBox(statgen); + statgen_spinBox_atoms3->setObjectName(QString::fromUtf8("statgen_spinBox_atoms3")); + statgen_spinBox_atoms3->setEnabled(false); + sizePolicy.setHeightForWidth(statgen_spinBox_atoms3->sizePolicy().hasHeightForWidth()); + statgen_spinBox_atoms3->setSizePolicy(sizePolicy); + statgen_spinBox_atoms3->setMinimumSize(QSize(50, 23)); + statgen_spinBox_atoms3->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + statgen_layout_atoms->addWidget(statgen_spinBox_atoms3); + + + verticalLayout_2->addLayout(statgen_layout_atoms); + + statgen_layout_int = new QHBoxLayout(); + statgen_layout_int->setSpacing(6); + statgen_layout_int->setObjectName(QString::fromUtf8("statgen_layout_int")); + statgen_label_int = new QLabel(statgen); + statgen_label_int->setObjectName(QString::fromUtf8("statgen_label_int")); + statgen_label_int->setMinimumSize(QSize(110, 23)); + + statgen_layout_int->addWidget(statgen_label_int); + + statgen_comboBox_int = new QComboBox(statgen); + statgen_comboBox_int->setObjectName(QString::fromUtf8("statgen_comboBox_int")); + sizePolicy.setHeightForWidth(statgen_comboBox_int->sizePolicy().hasHeightForWidth()); + statgen_comboBox_int->setSizePolicy(sizePolicy); + statgen_comboBox_int->setMinimumSize(QSize(90, 23)); + + statgen_layout_int->addWidget(statgen_comboBox_int); + + statgen_doubleSpinBox_int = new QDoubleSpinBox(statgen); + statgen_doubleSpinBox_int->setObjectName(QString::fromUtf8("statgen_doubleSpinBox_int")); + sizePolicy.setHeightForWidth(statgen_doubleSpinBox_int->sizePolicy().hasHeightForWidth()); + statgen_doubleSpinBox_int->setSizePolicy(sizePolicy); + statgen_doubleSpinBox_int->setMinimumSize(QSize(90, 23)); + statgen_doubleSpinBox_int->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + statgen_doubleSpinBox_int->setDecimals(3); + statgen_doubleSpinBox_int->setMinimum(0); + statgen_doubleSpinBox_int->setValue(0); + + statgen_layout_int->addWidget(statgen_doubleSpinBox_int); + + stagen_pushButton_intSave = new QPushButton(statgen); + stagen_pushButton_intSave->setObjectName(QString::fromUtf8("stagen_pushButton_intSave")); + stagen_pushButton_intSave->setMinimumSize(QSize(80, 23)); + stagen_pushButton_intSave->setAutoDefault(true); + + statgen_layout_int->addWidget(stagen_pushButton_intSave); + + statgen_pushButton_intAdd = new QPushButton(statgen); + statgen_pushButton_intAdd->setObjectName(QString::fromUtf8("statgen_pushButton_intAdd")); + statgen_pushButton_intAdd->setMinimumSize(QSize(80, 23)); + statgen_pushButton_intAdd->setAutoDefault(true); + + statgen_layout_int->addWidget(statgen_pushButton_intAdd); + + + verticalLayout_2->addLayout(statgen_layout_int); + + statgen_listWidget_int = new QListWidget(statgen); + statgen_listWidget_int->setObjectName(QString::fromUtf8("statgen_listWidget_int")); + statgen_listWidget_int->setMinimumSize(QSize(484, 85)); + statgen_listWidget_int->setEditTriggers(QAbstractItemView::NoEditTriggers); + + verticalLayout_2->addWidget(statgen_listWidget_int); + + stagen_layout_intRem = new QHBoxLayout(); + stagen_layout_intRem->setSpacing(6); + stagen_layout_intRem->setObjectName(QString::fromUtf8("stagen_layout_intRem")); + horizontalSpacer_5 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + stagen_layout_intRem->addItem(horizontalSpacer_5); + + stagen_pushButton_intRem = new QPushButton(statgen); + stagen_pushButton_intRem->setObjectName(QString::fromUtf8("stagen_pushButton_intRem")); + stagen_pushButton_intRem->setMinimumSize(QSize(80, 23)); + stagen_pushButton_intRem->setAutoDefault(true); + + stagen_layout_intRem->addWidget(stagen_pushButton_intRem); + + + verticalLayout_2->addLayout(stagen_layout_intRem); + + statgen_layout_output = new QHBoxLayout(); + statgen_layout_output->setSpacing(6); + statgen_layout_output->setObjectName(QString::fromUtf8("statgen_layout_output")); + statgen_label_output = new QLabel(statgen); + statgen_label_output->setObjectName(QString::fromUtf8("statgen_label_output")); + statgen_label_output->setMinimumSize(QSize(110, 23)); + + statgen_layout_output->addWidget(statgen_label_output); + + statgen_lineEdit_output = new QLineEdit(statgen); + statgen_lineEdit_output->setObjectName(QString::fromUtf8("statgen_lineEdit_output")); + statgen_lineEdit_output->setMinimumSize(QSize(280, 23)); + + statgen_layout_output->addWidget(statgen_lineEdit_output); + + statgen_pushButton_output = new QPushButton(statgen); + statgen_pushButton_output->setObjectName(QString::fromUtf8("statgen_pushButton_output")); + statgen_pushButton_output->setMinimumSize(QSize(80, 23)); + statgen_pushButton_output->setAutoDefault(true); + + statgen_layout_output->addWidget(statgen_pushButton_output); + + + verticalLayout_2->addLayout(statgen_layout_output); + + statgen_layout_opt = new QHBoxLayout(); + statgen_layout_opt->setSpacing(6); + statgen_layout_opt->setObjectName(QString::fromUtf8("statgen_layout_opt")); + statgen_checkBox_depth = new QCheckBox(statgen); + statgen_checkBox_depth->setObjectName(QString::fromUtf8("statgen_checkBox_depth")); + statgen_checkBox_depth->setMinimumSize(QSize(110, 23)); + statgen_checkBox_depth->setChecked(true); + + statgen_layout_opt->addWidget(statgen_checkBox_depth); + + statgen_spinBox_depth = new QSpinBox(statgen); + statgen_spinBox_depth->setObjectName(QString::fromUtf8("statgen_spinBox_depth")); + statgen_spinBox_depth->setMinimumSize(QSize(80, 23)); + statgen_spinBox_depth->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + statgen_spinBox_depth->setMinimum(3); + statgen_spinBox_depth->setMaximum(1000); + statgen_spinBox_depth->setValue(10); + + statgen_layout_opt->addWidget(statgen_spinBox_depth); + + statgen_checkBox_log = new QCheckBox(statgen); + statgen_checkBox_log->setObjectName(QString::fromUtf8("statgen_checkBox_log")); + statgen_checkBox_log->setMinimumSize(QSize(110, 23)); + statgen_checkBox_log->setChecked(true); + + statgen_layout_opt->addWidget(statgen_checkBox_log); + + statgen_lineEdit_log = new QLineEdit(statgen); + statgen_lineEdit_log->setObjectName(QString::fromUtf8("statgen_lineEdit_log")); + statgen_lineEdit_log->setMinimumSize(QSize(80, 23)); + + statgen_layout_opt->addWidget(statgen_lineEdit_log); + + statgen_pushButton_log = new QPushButton(statgen); + statgen_pushButton_log->setObjectName(QString::fromUtf8("statgen_pushButton_log")); + statgen_pushButton_log->setMinimumSize(QSize(80, 23)); + statgen_pushButton_log->setAutoDefault(true); + + statgen_layout_opt->addWidget(statgen_pushButton_log); + + + verticalLayout_2->addLayout(statgen_layout_opt); + + statgen_layout_buttons = new QHBoxLayout(); + statgen_layout_buttons->setSpacing(6); + statgen_layout_buttons->setObjectName(QString::fromUtf8("statgen_layout_buttons")); + statgen_pushButton_clear = new QPushButton(statgen); + statgen_pushButton_clear->setObjectName(QString::fromUtf8("statgen_pushButton_clear")); + statgen_pushButton_clear->setMinimumSize(QSize(80, 23)); + statgen_pushButton_clear->setAutoDefault(true); + + statgen_layout_buttons->addWidget(statgen_pushButton_clear); + + horizontalSpacer_3 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + statgen_layout_buttons->addItem(horizontalSpacer_3); + + statgen_pushButton_start = new QPushButton(statgen); + statgen_pushButton_start->setObjectName(QString::fromUtf8("statgen_pushButton_start")); + statgen_pushButton_start->setMinimumSize(QSize(80, 23)); + statgen_pushButton_start->setMaximumSize(QSize(16777215, 16777215)); + statgen_pushButton_start->setAutoDefault(true); + + statgen_layout_buttons->addWidget(statgen_pushButton_start); + + + verticalLayout_2->addLayout(statgen_layout_buttons); + + tabWidget->addTab(statgen, QString()); + envir = new QWidget(); + envir->setObjectName(QString::fromUtf8("envir")); + verticalLayout_3 = new QVBoxLayout(envir); + verticalLayout_3->setSpacing(6); + verticalLayout_3->setContentsMargins(11, 11, 11, 11); + verticalLayout_3->setObjectName(QString::fromUtf8("verticalLayout_3")); + envir_layout_workDir = new QHBoxLayout(); + envir_layout_workDir->setSpacing(6); + envir_layout_workDir->setObjectName(QString::fromUtf8("envir_layout_workDir")); + envir_label_workDir = new QLabel(envir); + envir_label_workDir->setObjectName(QString::fromUtf8("envir_label_workDir")); + envir_label_workDir->setMinimumSize(QSize(110, 23)); + + envir_layout_workDir->addWidget(envir_label_workDir); + + envir_lineEdit_workDir = new QLineEdit(envir); + envir_lineEdit_workDir->setObjectName(QString::fromUtf8("envir_lineEdit_workDir")); + envir_lineEdit_workDir->setMinimumSize(QSize(280, 23)); + + envir_layout_workDir->addWidget(envir_lineEdit_workDir); + + envir_pushButton_workDir = new QPushButton(envir); + envir_pushButton_workDir->setObjectName(QString::fromUtf8("envir_pushButton_workDir")); + envir_pushButton_workDir->setMinimumSize(QSize(80, 23)); + envir_pushButton_workDir->setAutoDefault(true); + + envir_layout_workDir->addWidget(envir_pushButton_workDir); + + + verticalLayout_3->addLayout(envir_layout_workDir); + + envir_layout_input = new QHBoxLayout(); + envir_layout_input->setSpacing(6); + envir_layout_input->setObjectName(QString::fromUtf8("envir_layout_input")); + envir_label_input = new QLabel(envir); + envir_label_input->setObjectName(QString::fromUtf8("envir_label_input")); + envir_label_input->setMinimumSize(QSize(110, 23)); + + envir_layout_input->addWidget(envir_label_input); + + envir_lineEdit_input = new QLineEdit(envir); + envir_lineEdit_input->setObjectName(QString::fromUtf8("envir_lineEdit_input")); + envir_lineEdit_input->setMinimumSize(QSize(280, 23)); + + envir_layout_input->addWidget(envir_lineEdit_input); + + envir_pushButton_input = new QPushButton(envir); + envir_pushButton_input->setObjectName(QString::fromUtf8("envir_pushButton_input")); + envir_pushButton_input->setMinimumSize(QSize(80, 23)); + envir_pushButton_input->setAutoDefault(true); + + envir_layout_input->addWidget(envir_pushButton_input); + + + verticalLayout_3->addLayout(envir_layout_input); + + envir_layout_cell = new QHBoxLayout(); + envir_layout_cell->setSpacing(6); + envir_layout_cell->setObjectName(QString::fromUtf8("envir_layout_cell")); + envir_label_cell = new QLabel(envir); + envir_label_cell->setObjectName(QString::fromUtf8("envir_label_cell")); + envir_label_cell->setMinimumSize(QSize(110, 23)); + + envir_layout_cell->addWidget(envir_label_cell); + + envir_label_cellX = new QLabel(envir); + envir_label_cellX->setObjectName(QString::fromUtf8("envir_label_cellX")); + envir_label_cellX->setMinimumSize(QSize(50, 23)); + + envir_layout_cell->addWidget(envir_label_cellX); + + envir_doubleSpinBox_cellX = new QDoubleSpinBox(envir); + envir_doubleSpinBox_cellX->setObjectName(QString::fromUtf8("envir_doubleSpinBox_cellX")); + sizePolicy.setHeightForWidth(envir_doubleSpinBox_cellX->sizePolicy().hasHeightForWidth()); + envir_doubleSpinBox_cellX->setSizePolicy(sizePolicy); + envir_doubleSpinBox_cellX->setMinimumSize(QSize(55, 23)); + envir_doubleSpinBox_cellX->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + envir_doubleSpinBox_cellX->setDecimals(4); + envir_doubleSpinBox_cellX->setMinimum(0.1); + envir_doubleSpinBox_cellX->setMaximum(999.99); + + envir_layout_cell->addWidget(envir_doubleSpinBox_cellX); + + envir_label_cellY = new QLabel(envir); + envir_label_cellY->setObjectName(QString::fromUtf8("envir_label_cellY")); + envir_label_cellY->setMinimumSize(QSize(50, 23)); + + envir_layout_cell->addWidget(envir_label_cellY); + + envir_doubleSpinBox_cellY = new QDoubleSpinBox(envir); + envir_doubleSpinBox_cellY->setObjectName(QString::fromUtf8("envir_doubleSpinBox_cellY")); + sizePolicy.setHeightForWidth(envir_doubleSpinBox_cellY->sizePolicy().hasHeightForWidth()); + envir_doubleSpinBox_cellY->setSizePolicy(sizePolicy); + envir_doubleSpinBox_cellY->setMinimumSize(QSize(55, 23)); + envir_doubleSpinBox_cellY->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + envir_doubleSpinBox_cellY->setDecimals(4); + envir_doubleSpinBox_cellY->setMinimum(0.1); + envir_doubleSpinBox_cellY->setMaximum(999.99); + + envir_layout_cell->addWidget(envir_doubleSpinBox_cellY); + + envir_label_cellZ = new QLabel(envir); + envir_label_cellZ->setObjectName(QString::fromUtf8("envir_label_cellZ")); + envir_label_cellZ->setMinimumSize(QSize(50, 23)); + + envir_layout_cell->addWidget(envir_label_cellZ); + + envir_doubleSpinBox_cellZ = new QDoubleSpinBox(envir); + envir_doubleSpinBox_cellZ->setObjectName(QString::fromUtf8("envir_doubleSpinBox_cellZ")); + sizePolicy.setHeightForWidth(envir_doubleSpinBox_cellZ->sizePolicy().hasHeightForWidth()); + envir_doubleSpinBox_cellZ->setSizePolicy(sizePolicy); + envir_doubleSpinBox_cellZ->setMinimumSize(QSize(55, 23)); + envir_doubleSpinBox_cellZ->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + envir_doubleSpinBox_cellZ->setDecimals(4); + envir_doubleSpinBox_cellZ->setMinimum(0.1); + envir_doubleSpinBox_cellZ->setMaximum(999.99); + + envir_layout_cell->addWidget(envir_doubleSpinBox_cellZ); + + + verticalLayout_3->addLayout(envir_layout_cell); + + envir_layout_output = new QHBoxLayout(); + envir_layout_output->setSpacing(6); + envir_layout_output->setObjectName(QString::fromUtf8("envir_layout_output")); + envir_label_output = new QLabel(envir); + envir_label_output->setObjectName(QString::fromUtf8("envir_label_output")); + envir_label_output->setMinimumSize(QSize(110, 23)); + + envir_layout_output->addWidget(envir_label_output); + + envir_lineEdit_output = new QLineEdit(envir); + envir_lineEdit_output->setObjectName(QString::fromUtf8("envir_lineEdit_output")); + envir_lineEdit_output->setMinimumSize(QSize(280, 23)); + + envir_layout_output->addWidget(envir_lineEdit_output); + + envir_pushButton_output = new QPushButton(envir); + envir_pushButton_output->setObjectName(QString::fromUtf8("envir_pushButton_output")); + envir_pushButton_output->setMinimumSize(QSize(80, 23)); + envir_pushButton_output->setAutoDefault(true); + + envir_layout_output->addWidget(envir_pushButton_output); + + + verticalLayout_3->addLayout(envir_layout_output); + + envir_layout_opt_1 = new QHBoxLayout(); + envir_layout_opt_1->setSpacing(6); + envir_layout_opt_1->setObjectName(QString::fromUtf8("envir_layout_opt_1")); + envir_label_molecule = new QLabel(envir); + envir_label_molecule->setObjectName(QString::fromUtf8("envir_label_molecule")); + envir_label_molecule->setMinimumSize(QSize(110, 23)); + + envir_layout_opt_1->addWidget(envir_label_molecule); + + envir_spinBox_molecule = new QSpinBox(envir); + envir_spinBox_molecule->setObjectName(QString::fromUtf8("envir_spinBox_molecule")); + envir_spinBox_molecule->setMinimumSize(QSize(75, 23)); + envir_spinBox_molecule->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + envir_spinBox_molecule->setMinimum(1); + envir_spinBox_molecule->setMaximum(9999); + + envir_layout_opt_1->addWidget(envir_spinBox_molecule); + + horizontalSpacer_8 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + envir_layout_opt_1->addItem(horizontalSpacer_8); + + envir_label_radius = new QLabel(envir); + envir_label_radius->setObjectName(QString::fromUtf8("envir_label_radius")); + envir_label_radius->setMinimumSize(QSize(110, 23)); + + envir_layout_opt_1->addWidget(envir_label_radius); + + envir_doubleSpinBox_radius = new QDoubleSpinBox(envir); + envir_doubleSpinBox_radius->setObjectName(QString::fromUtf8("envir_doubleSpinBox_radius")); + envir_doubleSpinBox_radius->setMinimumSize(QSize(75, 23)); + envir_doubleSpinBox_radius->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + envir_doubleSpinBox_radius->setDecimals(3); + + envir_layout_opt_1->addWidget(envir_doubleSpinBox_radius); + + horizontalSpacer_9 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + envir_layout_opt_1->addItem(horizontalSpacer_9); + + + verticalLayout_3->addLayout(envir_layout_opt_1); + + envir_layout_opt_2 = new QHBoxLayout(); + envir_layout_opt_2->setSpacing(6); + envir_layout_opt_2->setObjectName(QString::fromUtf8("envir_layout_opt_2")); + envir_checkBox_log = new QCheckBox(envir); + envir_checkBox_log->setObjectName(QString::fromUtf8("envir_checkBox_log")); + envir_checkBox_log->setMinimumSize(QSize(110, 23)); + envir_checkBox_log->setChecked(true); + + envir_layout_opt_2->addWidget(envir_checkBox_log); + + envir_lineEdit_log = new QLineEdit(envir); + envir_lineEdit_log->setObjectName(QString::fromUtf8("envir_lineEdit_log")); + envir_lineEdit_log->setMinimumSize(QSize(173, 23)); + + envir_layout_opt_2->addWidget(envir_lineEdit_log); + + envir_pushButton_log = new QPushButton(envir); + envir_pushButton_log->setObjectName(QString::fromUtf8("envir_pushButton_log")); + envir_pushButton_log->setMinimumSize(QSize(80, 23)); + envir_pushButton_log->setAutoDefault(true); + + envir_layout_opt_2->addWidget(envir_pushButton_log); + + + verticalLayout_3->addLayout(envir_layout_opt_2); + + verticalSpacer_2 = new QSpacerItem(20, 177, QSizePolicy::Minimum, QSizePolicy::Expanding); + + verticalLayout_3->addItem(verticalSpacer_2); + + envir_layout_buttons = new QHBoxLayout(); + envir_layout_buttons->setSpacing(6); + envir_layout_buttons->setObjectName(QString::fromUtf8("envir_layout_buttons")); + envir_pushButton_clear = new QPushButton(envir); + envir_pushButton_clear->setObjectName(QString::fromUtf8("envir_pushButton_clear")); + envir_pushButton_clear->setMinimumSize(QSize(80, 23)); + envir_pushButton_clear->setAutoDefault(true); + + envir_layout_buttons->addWidget(envir_pushButton_clear); + + horizontalSpacer_10 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + envir_layout_buttons->addItem(horizontalSpacer_10); + + envir_pushButton_start = new QPushButton(envir); + envir_pushButton_start->setObjectName(QString::fromUtf8("envir_pushButton_start")); + envir_pushButton_start->setMinimumSize(QSize(80, 23)); + envir_pushButton_start->setMaximumSize(QSize(16777215, 16777215)); + envir_pushButton_start->setAutoDefault(true); + + envir_layout_buttons->addWidget(envir_pushButton_start); + + + verticalLayout_3->addLayout(envir_layout_buttons); + + tabWidget->addTab(envir, QString()); + radf = new QWidget(); + radf->setObjectName(QString::fromUtf8("radf")); + verticalLayout_4 = new QVBoxLayout(radf); + verticalLayout_4->setSpacing(6); + verticalLayout_4->setContentsMargins(11, 11, 11, 11); + verticalLayout_4->setObjectName(QString::fromUtf8("verticalLayout_4")); + radf_layout_workDir = new QHBoxLayout(); + radf_layout_workDir->setSpacing(6); + radf_layout_workDir->setObjectName(QString::fromUtf8("radf_layout_workDir")); + radf_label_workDir = new QLabel(radf); + radf_label_workDir->setObjectName(QString::fromUtf8("radf_label_workDir")); + radf_label_workDir->setMinimumSize(QSize(110, 23)); + + radf_layout_workDir->addWidget(radf_label_workDir); + + radf_lineEdit_workDir = new QLineEdit(radf); + radf_lineEdit_workDir->setObjectName(QString::fromUtf8("radf_lineEdit_workDir")); + radf_lineEdit_workDir->setMinimumSize(QSize(280, 23)); + + radf_layout_workDir->addWidget(radf_lineEdit_workDir); + + radf_pushButton_workDir = new QPushButton(radf); + radf_pushButton_workDir->setObjectName(QString::fromUtf8("radf_pushButton_workDir")); + radf_pushButton_workDir->setMinimumSize(QSize(80, 23)); + radf_pushButton_workDir->setAutoDefault(true); + + radf_layout_workDir->addWidget(radf_pushButton_workDir); + + + verticalLayout_4->addLayout(radf_layout_workDir); + + radf_layout_input = new QHBoxLayout(); + radf_layout_input->setSpacing(6); + radf_layout_input->setObjectName(QString::fromUtf8("radf_layout_input")); + radf_label_input = new QLabel(radf); + radf_label_input->setObjectName(QString::fromUtf8("radf_label_input")); + radf_label_input->setMinimumSize(QSize(110, 23)); + + radf_layout_input->addWidget(radf_label_input); + + radf_lineEdit_input = new QLineEdit(radf); + radf_lineEdit_input->setObjectName(QString::fromUtf8("radf_lineEdit_input")); + radf_lineEdit_input->setMinimumSize(QSize(280, 23)); + + radf_layout_input->addWidget(radf_lineEdit_input); + + + verticalLayout_4->addLayout(radf_layout_input); + + radf_layout_steps = new QHBoxLayout(); + radf_layout_steps->setSpacing(6); + radf_layout_steps->setObjectName(QString::fromUtf8("radf_layout_steps")); + radf_label_steps = new QLabel(radf); + radf_label_steps->setObjectName(QString::fromUtf8("radf_label_steps")); + radf_label_steps->setMinimumSize(QSize(110, 23)); + + radf_layout_steps->addWidget(radf_label_steps); + + radf_label_stepsFirst = new QLabel(radf); + radf_label_stepsFirst->setObjectName(QString::fromUtf8("radf_label_stepsFirst")); + radf_label_stepsFirst->setMinimumSize(QSize(75, 23)); + + radf_layout_steps->addWidget(radf_label_stepsFirst); + + radf_spinBox_stepsFirst = new QSpinBox(radf); + radf_spinBox_stepsFirst->setObjectName(QString::fromUtf8("radf_spinBox_stepsFirst")); + radf_spinBox_stepsFirst->setMinimumSize(QSize(75, 23)); + radf_spinBox_stepsFirst->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_spinBox_stepsFirst->setMinimum(1); + radf_spinBox_stepsFirst->setMaximum(999); + + radf_layout_steps->addWidget(radf_spinBox_stepsFirst); + + horizontalSpacer_11 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + radf_layout_steps->addItem(horizontalSpacer_11); + + radf_label_stepsLast = new QLabel(radf); + radf_label_stepsLast->setObjectName(QString::fromUtf8("radf_label_stepsLast")); + radf_label_stepsLast->setMinimumSize(QSize(75, 23)); + + radf_layout_steps->addWidget(radf_label_stepsLast); + + radf_spinBox_stepsLast = new QSpinBox(radf); + radf_spinBox_stepsLast->setObjectName(QString::fromUtf8("radf_spinBox_stepsLast")); + radf_spinBox_stepsLast->setMinimumSize(QSize(75, 23)); + radf_spinBox_stepsLast->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_spinBox_stepsLast->setMinimum(1); + radf_spinBox_stepsLast->setMaximum(999); + + radf_layout_steps->addWidget(radf_spinBox_stepsLast); + + horizontalSpacer_12 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + radf_layout_steps->addItem(horizontalSpacer_12); + + + verticalLayout_4->addLayout(radf_layout_steps); + + radf_layout_cell = new QHBoxLayout(); + radf_layout_cell->setSpacing(6); + radf_layout_cell->setObjectName(QString::fromUtf8("radf_layout_cell")); + radf_label_cell = new QLabel(radf); + radf_label_cell->setObjectName(QString::fromUtf8("radf_label_cell")); + radf_label_cell->setMinimumSize(QSize(110, 23)); + + radf_layout_cell->addWidget(radf_label_cell); + + radf_label_cellX = new QLabel(radf); + radf_label_cellX->setObjectName(QString::fromUtf8("radf_label_cellX")); + radf_label_cellX->setMinimumSize(QSize(50, 23)); + + radf_layout_cell->addWidget(radf_label_cellX); + + radf_doubleSpinBox_cellX = new QDoubleSpinBox(radf); + radf_doubleSpinBox_cellX->setObjectName(QString::fromUtf8("radf_doubleSpinBox_cellX")); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_cellX->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_cellX->setSizePolicy(sizePolicy); + radf_doubleSpinBox_cellX->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_cellX->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_cellX->setDecimals(4); + radf_doubleSpinBox_cellX->setMinimum(0.1); + radf_doubleSpinBox_cellX->setMaximum(999.99); + + radf_layout_cell->addWidget(radf_doubleSpinBox_cellX); + + radf_label_cellY = new QLabel(radf); + radf_label_cellY->setObjectName(QString::fromUtf8("radf_label_cellY")); + radf_label_cellY->setMinimumSize(QSize(50, 23)); + + radf_layout_cell->addWidget(radf_label_cellY); + + radf_doubleSpinBox_cellY = new QDoubleSpinBox(radf); + radf_doubleSpinBox_cellY->setObjectName(QString::fromUtf8("radf_doubleSpinBox_cellY")); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_cellY->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_cellY->setSizePolicy(sizePolicy); + radf_doubleSpinBox_cellY->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_cellY->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_cellY->setDecimals(4); + radf_doubleSpinBox_cellY->setMinimum(0.1); + radf_doubleSpinBox_cellY->setMaximum(999.99); + + radf_layout_cell->addWidget(radf_doubleSpinBox_cellY); + + radf_label_cellZ = new QLabel(radf); + radf_label_cellZ->setObjectName(QString::fromUtf8("radf_label_cellZ")); + radf_label_cellZ->setMinimumSize(QSize(50, 23)); + + radf_layout_cell->addWidget(radf_label_cellZ); + + radf_doubleSpinBox_cellZ = new QDoubleSpinBox(radf); + radf_doubleSpinBox_cellZ->setObjectName(QString::fromUtf8("radf_doubleSpinBox_cellZ")); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_cellZ->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_cellZ->setSizePolicy(sizePolicy); + radf_doubleSpinBox_cellZ->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_cellZ->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_cellZ->setDecimals(4); + radf_doubleSpinBox_cellZ->setMinimum(0.1); + radf_doubleSpinBox_cellZ->setMaximum(999.99); + + radf_layout_cell->addWidget(radf_doubleSpinBox_cellZ); + + + verticalLayout_4->addLayout(radf_layout_cell); + + radf_layout_output = new QHBoxLayout(); + radf_layout_output->setSpacing(6); + radf_layout_output->setObjectName(QString::fromUtf8("radf_layout_output")); + radf_label_output = new QLabel(radf); + radf_label_output->setObjectName(QString::fromUtf8("radf_label_output")); + radf_label_output->setMinimumSize(QSize(110, 23)); + + radf_layout_output->addWidget(radf_label_output); + + radf_lineEdit_output = new QLineEdit(radf); + radf_lineEdit_output->setObjectName(QString::fromUtf8("radf_lineEdit_output")); + radf_lineEdit_output->setMinimumSize(QSize(280, 23)); + + radf_layout_output->addWidget(radf_lineEdit_output); + + radf_pushButton_output = new QPushButton(radf); + radf_pushButton_output->setObjectName(QString::fromUtf8("radf_pushButton_output")); + radf_pushButton_output->setMinimumSize(QSize(80, 23)); + radf_pushButton_output->setAutoDefault(true); + + radf_layout_output->addWidget(radf_pushButton_output); + + + verticalLayout_4->addLayout(radf_layout_output); + + radf_layout_atom1 = new QHBoxLayout(); + radf_layout_atom1->setSpacing(6); + radf_layout_atom1->setObjectName(QString::fromUtf8("radf_layout_atom1")); + radf_comboBox_atom = new QComboBox(radf); + radf_comboBox_atom->setObjectName(QString::fromUtf8("radf_comboBox_atom")); + radf_comboBox_atom->setMinimumSize(QSize(150, 23)); + + radf_layout_atom1->addWidget(radf_comboBox_atom); + + radf_label_atoms0 = new QLabel(radf); + radf_label_atoms0->setObjectName(QString::fromUtf8("radf_label_atoms0")); + sizePolicy1.setHeightForWidth(radf_label_atoms0->sizePolicy().hasHeightForWidth()); + radf_label_atoms0->setSizePolicy(sizePolicy1); + radf_label_atoms0->setMinimumSize(QSize(45, 23)); + + radf_layout_atom1->addWidget(radf_label_atoms0); + + radf_spinBox_atoms0 = new QSpinBox(radf); + radf_spinBox_atoms0->setObjectName(QString::fromUtf8("radf_spinBox_atoms0")); + sizePolicy.setHeightForWidth(radf_spinBox_atoms0->sizePolicy().hasHeightForWidth()); + radf_spinBox_atoms0->setSizePolicy(sizePolicy); + radf_spinBox_atoms0->setMinimumSize(QSize(50, 23)); + radf_spinBox_atoms0->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + radf_layout_atom1->addWidget(radf_spinBox_atoms0); + + radf_label_atoms1 = new QLabel(radf); + radf_label_atoms1->setObjectName(QString::fromUtf8("radf_label_atoms1")); + sizePolicy1.setHeightForWidth(radf_label_atoms1->sizePolicy().hasHeightForWidth()); + radf_label_atoms1->setSizePolicy(sizePolicy1); + radf_label_atoms1->setMinimumSize(QSize(45, 23)); + + radf_layout_atom1->addWidget(radf_label_atoms1); + + radf_spinBox_atoms1 = new QSpinBox(radf); + radf_spinBox_atoms1->setObjectName(QString::fromUtf8("radf_spinBox_atoms1")); + radf_spinBox_atoms1->setEnabled(false); + sizePolicy.setHeightForWidth(radf_spinBox_atoms1->sizePolicy().hasHeightForWidth()); + radf_spinBox_atoms1->setSizePolicy(sizePolicy); + radf_spinBox_atoms1->setMinimumSize(QSize(50, 23)); + radf_spinBox_atoms1->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + radf_layout_atom1->addWidget(radf_spinBox_atoms1); + + radf_label_atoms2 = new QLabel(radf); + radf_label_atoms2->setObjectName(QString::fromUtf8("radf_label_atoms2")); + sizePolicy1.setHeightForWidth(radf_label_atoms2->sizePolicy().hasHeightForWidth()); + radf_label_atoms2->setSizePolicy(sizePolicy1); + radf_label_atoms2->setMinimumSize(QSize(45, 23)); + + radf_layout_atom1->addWidget(radf_label_atoms2); + + radf_spinBox_atoms2 = new QSpinBox(radf); + radf_spinBox_atoms2->setObjectName(QString::fromUtf8("radf_spinBox_atoms2")); + radf_spinBox_atoms2->setEnabled(false); + sizePolicy.setHeightForWidth(radf_spinBox_atoms2->sizePolicy().hasHeightForWidth()); + radf_spinBox_atoms2->setSizePolicy(sizePolicy); + radf_spinBox_atoms2->setMinimumSize(QSize(50, 23)); + radf_spinBox_atoms2->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + radf_layout_atom1->addWidget(radf_spinBox_atoms2); + + + verticalLayout_4->addLayout(radf_layout_atom1); + + radf_layout_atom2 = new QHBoxLayout(); + radf_layout_atom2->setSpacing(6); + radf_layout_atom2->setObjectName(QString::fromUtf8("radf_layout_atom2")); + horizontalSpacer_14 = new QSpacerItem(155, 23, QSizePolicy::Fixed, QSizePolicy::Minimum); + + radf_layout_atom2->addItem(horizontalSpacer_14); + + radf_label_atoms3 = new QLabel(radf); + radf_label_atoms3->setObjectName(QString::fromUtf8("radf_label_atoms3")); + sizePolicy1.setHeightForWidth(radf_label_atoms3->sizePolicy().hasHeightForWidth()); + radf_label_atoms3->setSizePolicy(sizePolicy1); + radf_label_atoms3->setMinimumSize(QSize(45, 23)); + + radf_layout_atom2->addWidget(radf_label_atoms3); + + radf_spinBox_atoms3 = new QSpinBox(radf); + radf_spinBox_atoms3->setObjectName(QString::fromUtf8("radf_spinBox_atoms3")); + sizePolicy.setHeightForWidth(radf_spinBox_atoms3->sizePolicy().hasHeightForWidth()); + radf_spinBox_atoms3->setSizePolicy(sizePolicy); + radf_spinBox_atoms3->setMinimumSize(QSize(50, 23)); + radf_spinBox_atoms3->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + radf_layout_atom2->addWidget(radf_spinBox_atoms3); + + radf_label_atoms4 = new QLabel(radf); + radf_label_atoms4->setObjectName(QString::fromUtf8("radf_label_atoms4")); + sizePolicy1.setHeightForWidth(radf_label_atoms4->sizePolicy().hasHeightForWidth()); + radf_label_atoms4->setSizePolicy(sizePolicy1); + radf_label_atoms4->setMinimumSize(QSize(45, 23)); + + radf_layout_atom2->addWidget(radf_label_atoms4); + + radf_spinBox_atoms4 = new QSpinBox(radf); + radf_spinBox_atoms4->setObjectName(QString::fromUtf8("radf_spinBox_atoms4")); + radf_spinBox_atoms4->setEnabled(false); + sizePolicy.setHeightForWidth(radf_spinBox_atoms4->sizePolicy().hasHeightForWidth()); + radf_spinBox_atoms4->setSizePolicy(sizePolicy); + radf_spinBox_atoms4->setMinimumSize(QSize(50, 23)); + radf_spinBox_atoms4->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + radf_layout_atom2->addWidget(radf_spinBox_atoms4); + + radf_label_atoms5 = new QLabel(radf); + radf_label_atoms5->setObjectName(QString::fromUtf8("radf_label_atoms5")); + sizePolicy1.setHeightForWidth(radf_label_atoms5->sizePolicy().hasHeightForWidth()); + radf_label_atoms5->setSizePolicy(sizePolicy1); + radf_label_atoms5->setMinimumSize(QSize(45, 23)); + + radf_layout_atom2->addWidget(radf_label_atoms5); + + radf_spinBox_atoms5 = new QSpinBox(radf); + radf_spinBox_atoms5->setObjectName(QString::fromUtf8("radf_spinBox_atoms5")); + radf_spinBox_atoms5->setEnabled(false); + sizePolicy.setHeightForWidth(radf_spinBox_atoms5->sizePolicy().hasHeightForWidth()); + radf_spinBox_atoms5->setSizePolicy(sizePolicy); + radf_spinBox_atoms5->setMinimumSize(QSize(50, 23)); + radf_spinBox_atoms5->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + + radf_layout_atom2->addWidget(radf_spinBox_atoms5); + + + verticalLayout_4->addLayout(radf_layout_atom2); + + radf_layout_rad = new QHBoxLayout(); + radf_layout_rad->setSpacing(6); + radf_layout_rad->setObjectName(QString::fromUtf8("radf_layout_rad")); + radf_label_rad = new QLabel(radf); + radf_label_rad->setObjectName(QString::fromUtf8("radf_label_rad")); + radf_label_rad->setMinimumSize(QSize(110, 23)); + + radf_layout_rad->addWidget(radf_label_rad); + + radf_label_radMin = new QLabel(radf); + radf_label_radMin->setObjectName(QString::fromUtf8("radf_label_radMin")); + radf_label_radMin->setMinimumSize(QSize(50, 23)); + + radf_layout_rad->addWidget(radf_label_radMin); + + radf_doubleSpinBox_radMin = new QDoubleSpinBox(radf); + radf_doubleSpinBox_radMin->setObjectName(QString::fromUtf8("radf_doubleSpinBox_radMin")); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_radMin->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_radMin->setSizePolicy(sizePolicy); + radf_doubleSpinBox_radMin->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_radMin->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_radMin->setDecimals(3); + radf_doubleSpinBox_radMin->setMinimum(0); + radf_doubleSpinBox_radMin->setMaximum(999.99); + radf_doubleSpinBox_radMin->setValue(2); + + radf_layout_rad->addWidget(radf_doubleSpinBox_radMin); + + radf_label_radMax = new QLabel(radf); + radf_label_radMax->setObjectName(QString::fromUtf8("radf_label_radMax")); + radf_label_radMax->setMinimumSize(QSize(50, 23)); + + radf_layout_rad->addWidget(radf_label_radMax); + + radf_doubleSpinBox_radMax = new QDoubleSpinBox(radf); + radf_doubleSpinBox_radMax->setObjectName(QString::fromUtf8("radf_doubleSpinBox_radMax")); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_radMax->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_radMax->setSizePolicy(sizePolicy); + radf_doubleSpinBox_radMax->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_radMax->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_radMax->setDecimals(3); + radf_doubleSpinBox_radMax->setMinimum(0.1); + radf_doubleSpinBox_radMax->setMaximum(999.99); + radf_doubleSpinBox_radMax->setValue(15); + + radf_layout_rad->addWidget(radf_doubleSpinBox_radMax); + + radf_label_radStep = new QLabel(radf); + radf_label_radStep->setObjectName(QString::fromUtf8("radf_label_radStep")); + radf_label_radStep->setMinimumSize(QSize(50, 23)); + + radf_layout_rad->addWidget(radf_label_radStep); + + radf_doubleSpinBox_radStep = new QDoubleSpinBox(radf); + radf_doubleSpinBox_radStep->setObjectName(QString::fromUtf8("radf_doubleSpinBox_radStep")); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_radStep->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_radStep->setSizePolicy(sizePolicy); + radf_doubleSpinBox_radStep->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_radStep->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_radStep->setDecimals(3); + radf_doubleSpinBox_radStep->setMinimum(0.001); + radf_doubleSpinBox_radStep->setMaximum(1); + radf_doubleSpinBox_radStep->setSingleStep(0.01); + radf_doubleSpinBox_radStep->setValue(0.02); + + radf_layout_rad->addWidget(radf_doubleSpinBox_radStep); + + + verticalLayout_4->addLayout(radf_layout_rad); + + radf_layout_ang = new QHBoxLayout(); + radf_layout_ang->setSpacing(6); + radf_layout_ang->setObjectName(QString::fromUtf8("radf_layout_ang")); + radf_checkBox_ang = new QCheckBox(radf); + radf_checkBox_ang->setObjectName(QString::fromUtf8("radf_checkBox_ang")); + radf_checkBox_ang->setMinimumSize(QSize(110, 23)); + + radf_layout_ang->addWidget(radf_checkBox_ang); + + radf_label_angMin = new QLabel(radf); + radf_label_angMin->setObjectName(QString::fromUtf8("radf_label_angMin")); + radf_label_angMin->setMinimumSize(QSize(50, 23)); + + radf_layout_ang->addWidget(radf_label_angMin); + + radf_doubleSpinBox_angMin = new QDoubleSpinBox(radf); + radf_doubleSpinBox_angMin->setObjectName(QString::fromUtf8("radf_doubleSpinBox_angMin")); + radf_doubleSpinBox_angMin->setEnabled(false); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_angMin->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_angMin->setSizePolicy(sizePolicy); + radf_doubleSpinBox_angMin->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_angMin->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_angMin->setDecimals(2); + radf_doubleSpinBox_angMin->setMinimum(0); + radf_doubleSpinBox_angMin->setMaximum(90); + radf_doubleSpinBox_angMin->setSingleStep(15); + radf_doubleSpinBox_angMin->setValue(0); + + radf_layout_ang->addWidget(radf_doubleSpinBox_angMin); + + radf_label_angMax = new QLabel(radf); + radf_label_angMax->setObjectName(QString::fromUtf8("radf_label_angMax")); + radf_label_angMax->setMinimumSize(QSize(50, 23)); + + radf_layout_ang->addWidget(radf_label_angMax); + + radf_doubleSpinBox_angMax = new QDoubleSpinBox(radf); + radf_doubleSpinBox_angMax->setObjectName(QString::fromUtf8("radf_doubleSpinBox_angMax")); + radf_doubleSpinBox_angMax->setEnabled(false); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_angMax->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_angMax->setSizePolicy(sizePolicy); + radf_doubleSpinBox_angMax->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_angMax->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_angMax->setDecimals(2); + radf_doubleSpinBox_angMax->setMinimum(0.1); + radf_doubleSpinBox_angMax->setMaximum(90); + radf_doubleSpinBox_angMax->setSingleStep(15); + radf_doubleSpinBox_angMax->setValue(90); + + radf_layout_ang->addWidget(radf_doubleSpinBox_angMax); + + radf_label_angStep = new QLabel(radf); + radf_label_angStep->setObjectName(QString::fromUtf8("radf_label_angStep")); + radf_label_angStep->setMinimumSize(QSize(50, 23)); + + radf_layout_ang->addWidget(radf_label_angStep); + + radf_doubleSpinBox_angStep = new QDoubleSpinBox(radf); + radf_doubleSpinBox_angStep->setObjectName(QString::fromUtf8("radf_doubleSpinBox_angStep")); + radf_doubleSpinBox_angStep->setEnabled(false); + sizePolicy.setHeightForWidth(radf_doubleSpinBox_angStep->sizePolicy().hasHeightForWidth()); + radf_doubleSpinBox_angStep->setSizePolicy(sizePolicy); + radf_doubleSpinBox_angStep->setMinimumSize(QSize(55, 23)); + radf_doubleSpinBox_angStep->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + radf_doubleSpinBox_angStep->setDecimals(2); + radf_doubleSpinBox_angStep->setMinimum(0.1); + radf_doubleSpinBox_angStep->setMaximum(90); + radf_doubleSpinBox_angStep->setSingleStep(15); + radf_doubleSpinBox_angStep->setValue(15); + + radf_layout_ang->addWidget(radf_doubleSpinBox_angStep); + + + verticalLayout_4->addLayout(radf_layout_ang); + + radf_layout_opt = new QHBoxLayout(); + radf_layout_opt->setSpacing(6); + radf_layout_opt->setObjectName(QString::fromUtf8("radf_layout_opt")); + radf_checkBox_matrix = new QCheckBox(radf); + radf_checkBox_matrix->setObjectName(QString::fromUtf8("radf_checkBox_matrix")); + radf_checkBox_matrix->setMinimumSize(QSize(110, 23)); + + radf_layout_opt->addWidget(radf_checkBox_matrix); + + radf_checkBox_log = new QCheckBox(radf); + radf_checkBox_log->setObjectName(QString::fromUtf8("radf_checkBox_log")); + radf_checkBox_log->setMinimumSize(QSize(110, 23)); + radf_checkBox_log->setChecked(true); + + radf_layout_opt->addWidget(radf_checkBox_log); + + radf_lineEdit_log = new QLineEdit(radf); + radf_lineEdit_log->setObjectName(QString::fromUtf8("radf_lineEdit_log")); + radf_lineEdit_log->setMinimumSize(QSize(150, 23)); + + radf_layout_opt->addWidget(radf_lineEdit_log); + + radf_pushButton_log = new QPushButton(radf); + radf_pushButton_log->setObjectName(QString::fromUtf8("radf_pushButton_log")); + radf_pushButton_log->setMinimumSize(QSize(80, 23)); + radf_pushButton_log->setAutoDefault(true); + + radf_layout_opt->addWidget(radf_pushButton_log); + + + verticalLayout_4->addLayout(radf_layout_opt); + + verticalSpacer_3 = new QSpacerItem(20, 47, QSizePolicy::Minimum, QSizePolicy::Expanding); + + verticalLayout_4->addItem(verticalSpacer_3); + + radf_layout_buttons = new QHBoxLayout(); + radf_layout_buttons->setSpacing(6); + radf_layout_buttons->setObjectName(QString::fromUtf8("radf_layout_buttons")); + radf_pushButton_clear = new QPushButton(radf); + radf_pushButton_clear->setObjectName(QString::fromUtf8("radf_pushButton_clear")); + radf_pushButton_clear->setMinimumSize(QSize(80, 23)); + radf_pushButton_clear->setAutoDefault(true); + + radf_layout_buttons->addWidget(radf_pushButton_clear); + + horizontalSpacer_13 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + radf_layout_buttons->addItem(horizontalSpacer_13); + + radf_pushButton_start = new QPushButton(radf); + radf_pushButton_start->setObjectName(QString::fromUtf8("radf_pushButton_start")); + radf_pushButton_start->setMinimumSize(QSize(80, 23)); + radf_pushButton_start->setMaximumSize(QSize(16777215, 16777215)); + radf_pushButton_start->setAutoDefault(true); + + radf_layout_buttons->addWidget(radf_pushButton_start); + + + verticalLayout_4->addLayout(radf_layout_buttons); + + tabWidget->addTab(radf, QString()); + pdb = new QWidget(); + pdb->setObjectName(QString::fromUtf8("pdb")); + verticalLayout_5 = new QVBoxLayout(pdb); + verticalLayout_5->setSpacing(6); + verticalLayout_5->setContentsMargins(11, 11, 11, 11); + verticalLayout_5->setObjectName(QString::fromUtf8("verticalLayout_5")); + pdb_comboBox_mode = new QComboBox(pdb); + pdb_comboBox_mode->setObjectName(QString::fromUtf8("pdb_comboBox_mode")); + + verticalLayout_5->addWidget(pdb_comboBox_mode); + + pdb_layout_workDir = new QHBoxLayout(); + pdb_layout_workDir->setSpacing(6); + pdb_layout_workDir->setObjectName(QString::fromUtf8("pdb_layout_workDir")); + pdb_label_workDir = new QLabel(pdb); + pdb_label_workDir->setObjectName(QString::fromUtf8("pdb_label_workDir")); + pdb_label_workDir->setMinimumSize(QSize(110, 23)); + + pdb_layout_workDir->addWidget(pdb_label_workDir); + + pdb_lineEdit_workDir = new QLineEdit(pdb); + pdb_lineEdit_workDir->setObjectName(QString::fromUtf8("pdb_lineEdit_workDir")); + pdb_lineEdit_workDir->setMinimumSize(QSize(280, 23)); + + pdb_layout_workDir->addWidget(pdb_lineEdit_workDir); + + pdb_pushButton_workDir = new QPushButton(pdb); + pdb_pushButton_workDir->setObjectName(QString::fromUtf8("pdb_pushButton_workDir")); + pdb_pushButton_workDir->setMinimumSize(QSize(80, 23)); + pdb_pushButton_workDir->setAutoDefault(true); + + pdb_layout_workDir->addWidget(pdb_pushButton_workDir); + + + verticalLayout_5->addLayout(pdb_layout_workDir); + + pdb_layout_input = new QHBoxLayout(); + pdb_layout_input->setSpacing(6); + pdb_layout_input->setObjectName(QString::fromUtf8("pdb_layout_input")); + pdb_label_input = new QLabel(pdb); + pdb_label_input->setObjectName(QString::fromUtf8("pdb_label_input")); + pdb_label_input->setMinimumSize(QSize(110, 23)); + + pdb_layout_input->addWidget(pdb_label_input); + + pdb_lineEdit_input = new QLineEdit(pdb); + pdb_lineEdit_input->setObjectName(QString::fromUtf8("pdb_lineEdit_input")); + pdb_lineEdit_input->setMinimumSize(QSize(280, 23)); + + pdb_layout_input->addWidget(pdb_lineEdit_input); + + pdb_pushButton_input = new QPushButton(pdb); + pdb_pushButton_input->setObjectName(QString::fromUtf8("pdb_pushButton_input")); + pdb_pushButton_input->setMinimumSize(QSize(80, 23)); + pdb_pushButton_input->setAutoDefault(true); + + pdb_layout_input->addWidget(pdb_pushButton_input); + + + verticalLayout_5->addLayout(pdb_layout_input); + + pdb_layout_agl = new QHBoxLayout(); + pdb_layout_agl->setSpacing(6); + pdb_layout_agl->setObjectName(QString::fromUtf8("pdb_layout_agl")); + pdb_label_agl = new QLabel(pdb); + pdb_label_agl->setObjectName(QString::fromUtf8("pdb_label_agl")); + pdb_label_agl->setMinimumSize(QSize(150, 23)); + + pdb_layout_agl->addWidget(pdb_label_agl); + + pdb_lineEdit_agl = new QLineEdit(pdb); + pdb_lineEdit_agl->setObjectName(QString::fromUtf8("pdb_lineEdit_agl")); + pdb_lineEdit_agl->setMinimumSize(QSize(280, 23)); + + pdb_layout_agl->addWidget(pdb_lineEdit_agl); + + pdb_pushButton_agl = new QPushButton(pdb); + pdb_pushButton_agl->setObjectName(QString::fromUtf8("pdb_pushButton_agl")); + pdb_pushButton_agl->setMinimumSize(QSize(80, 23)); + pdb_pushButton_agl->setAutoDefault(true); + + pdb_layout_agl->addWidget(pdb_pushButton_agl); + + + verticalLayout_5->addLayout(pdb_layout_agl); + + pdb_layout_cell = new QHBoxLayout(); + pdb_layout_cell->setSpacing(6); + pdb_layout_cell->setObjectName(QString::fromUtf8("pdb_layout_cell")); + pdb_label_cell = new QLabel(pdb); + pdb_label_cell->setObjectName(QString::fromUtf8("pdb_label_cell")); + pdb_label_cell->setMinimumSize(QSize(110, 23)); + + pdb_layout_cell->addWidget(pdb_label_cell); + + pdb_label_cellX = new QLabel(pdb); + pdb_label_cellX->setObjectName(QString::fromUtf8("pdb_label_cellX")); + pdb_label_cellX->setMinimumSize(QSize(50, 23)); + + pdb_layout_cell->addWidget(pdb_label_cellX); + + pdb_doubleSpinBox_cellX = new QDoubleSpinBox(pdb); + pdb_doubleSpinBox_cellX->setObjectName(QString::fromUtf8("pdb_doubleSpinBox_cellX")); + sizePolicy.setHeightForWidth(pdb_doubleSpinBox_cellX->sizePolicy().hasHeightForWidth()); + pdb_doubleSpinBox_cellX->setSizePolicy(sizePolicy); + pdb_doubleSpinBox_cellX->setMinimumSize(QSize(55, 23)); + pdb_doubleSpinBox_cellX->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + pdb_doubleSpinBox_cellX->setDecimals(4); + pdb_doubleSpinBox_cellX->setMinimum(0.1); + pdb_doubleSpinBox_cellX->setMaximum(999.99); + + pdb_layout_cell->addWidget(pdb_doubleSpinBox_cellX); + + pdb_label_cellY = new QLabel(pdb); + pdb_label_cellY->setObjectName(QString::fromUtf8("pdb_label_cellY")); + pdb_label_cellY->setMinimumSize(QSize(50, 23)); + + pdb_layout_cell->addWidget(pdb_label_cellY); + + pdb_doubleSpinBox_cellY = new QDoubleSpinBox(pdb); + pdb_doubleSpinBox_cellY->setObjectName(QString::fromUtf8("pdb_doubleSpinBox_cellY")); + sizePolicy.setHeightForWidth(pdb_doubleSpinBox_cellY->sizePolicy().hasHeightForWidth()); + pdb_doubleSpinBox_cellY->setSizePolicy(sizePolicy); + pdb_doubleSpinBox_cellY->setMinimumSize(QSize(55, 23)); + pdb_doubleSpinBox_cellY->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + pdb_doubleSpinBox_cellY->setDecimals(4); + pdb_doubleSpinBox_cellY->setMinimum(0.1); + pdb_doubleSpinBox_cellY->setMaximum(999.99); + + pdb_layout_cell->addWidget(pdb_doubleSpinBox_cellY); + + pdb_label_cellZ = new QLabel(pdb); + pdb_label_cellZ->setObjectName(QString::fromUtf8("pdb_label_cellZ")); + pdb_label_cellZ->setMinimumSize(QSize(50, 23)); + + pdb_layout_cell->addWidget(pdb_label_cellZ); + + pdb_doubleSpinBox_cellZ = new QDoubleSpinBox(pdb); + pdb_doubleSpinBox_cellZ->setObjectName(QString::fromUtf8("pdb_doubleSpinBox_cellZ")); + sizePolicy.setHeightForWidth(pdb_doubleSpinBox_cellZ->sizePolicy().hasHeightForWidth()); + pdb_doubleSpinBox_cellZ->setSizePolicy(sizePolicy); + pdb_doubleSpinBox_cellZ->setMinimumSize(QSize(55, 23)); + pdb_doubleSpinBox_cellZ->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter); + pdb_doubleSpinBox_cellZ->setDecimals(4); + pdb_doubleSpinBox_cellZ->setMinimum(0.1); + pdb_doubleSpinBox_cellZ->setMaximum(999.99); + + pdb_layout_cell->addWidget(pdb_doubleSpinBox_cellZ); + + + verticalLayout_5->addLayout(pdb_layout_cell); + + pdb_layout_output = new QHBoxLayout(); + pdb_layout_output->setSpacing(6); + pdb_layout_output->setObjectName(QString::fromUtf8("pdb_layout_output")); + pdb_label_output = new QLabel(pdb); + pdb_label_output->setObjectName(QString::fromUtf8("pdb_label_output")); + pdb_label_output->setMinimumSize(QSize(110, 23)); + + pdb_layout_output->addWidget(pdb_label_output); + + pdb_lineEdit_output = new QLineEdit(pdb); + pdb_lineEdit_output->setObjectName(QString::fromUtf8("pdb_lineEdit_output")); + pdb_lineEdit_output->setMinimumSize(QSize(280, 23)); + + pdb_layout_output->addWidget(pdb_lineEdit_output); + + pdb_pushButton_output = new QPushButton(pdb); + pdb_pushButton_output->setObjectName(QString::fromUtf8("pdb_pushButton_output")); + pdb_pushButton_output->setMinimumSize(QSize(80, 23)); + pdb_pushButton_output->setAutoDefault(true); + + pdb_layout_output->addWidget(pdb_pushButton_output); + + + verticalLayout_5->addLayout(pdb_layout_output); + + pdb_layout_opt = new QHBoxLayout(); + pdb_layout_opt->setSpacing(6); + pdb_layout_opt->setObjectName(QString::fromUtf8("pdb_layout_opt")); + pdb_checkBox_log = new QCheckBox(pdb); + pdb_checkBox_log->setObjectName(QString::fromUtf8("pdb_checkBox_log")); + pdb_checkBox_log->setMinimumSize(QSize(110, 23)); + pdb_checkBox_log->setChecked(true); + + pdb_layout_opt->addWidget(pdb_checkBox_log); + + pdb_lineEdit_log = new QLineEdit(pdb); + pdb_lineEdit_log->setObjectName(QString::fromUtf8("pdb_lineEdit_log")); + pdb_lineEdit_log->setMinimumSize(QSize(173, 23)); + + pdb_layout_opt->addWidget(pdb_lineEdit_log); + + pdb_pushButton_log = new QPushButton(pdb); + pdb_pushButton_log->setObjectName(QString::fromUtf8("pdb_pushButton_log")); + pdb_pushButton_log->setMinimumSize(QSize(80, 23)); + pdb_pushButton_log->setAutoDefault(true); + + pdb_layout_opt->addWidget(pdb_pushButton_log); + + + verticalLayout_5->addLayout(pdb_layout_opt); + + verticalSpacer_4 = new QSpacerItem(20, 147, QSizePolicy::Minimum, QSizePolicy::Expanding); + + verticalLayout_5->addItem(verticalSpacer_4); + + pdb_layout_buttons = new QHBoxLayout(); + pdb_layout_buttons->setSpacing(6); + pdb_layout_buttons->setObjectName(QString::fromUtf8("pdb_layout_buttons")); + pdb_pushButton_clear = new QPushButton(pdb); + pdb_pushButton_clear->setObjectName(QString::fromUtf8("pdb_pushButton_clear")); + pdb_pushButton_clear->setMinimumSize(QSize(80, 23)); + pdb_pushButton_clear->setAutoDefault(true); + + pdb_layout_buttons->addWidget(pdb_pushButton_clear); + + horizontalSpacer_15 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum); + + pdb_layout_buttons->addItem(horizontalSpacer_15); + + pdb_pushButton_start = new QPushButton(pdb); + pdb_pushButton_start->setObjectName(QString::fromUtf8("pdb_pushButton_start")); + pdb_pushButton_start->setMinimumSize(QSize(80, 23)); + pdb_pushButton_start->setMaximumSize(QSize(16777215, 16777215)); + pdb_pushButton_start->setAutoDefault(true); + + pdb_layout_buttons->addWidget(pdb_pushButton_start); + + + verticalLayout_5->addLayout(pdb_layout_buttons); + + tabWidget->addTab(pdb, QString()); + + gridLayout->addWidget(tabWidget, 0, 1, 1, 1); + + MainWindow->setCentralWidget(centralWidget); + menuBar = new QMenuBar(MainWindow); + menuBar->setObjectName(QString::fromUtf8("menuBar")); + menuBar->setGeometry(QRect(0, 0, 564, 20)); + menuMenu = new QMenu(menuBar); + menuMenu->setObjectName(QString::fromUtf8("menuMenu")); + menuHelp = new QMenu(menuBar); + menuHelp->setObjectName(QString::fromUtf8("menuHelp")); + MainWindow->setMenuBar(menuBar); + mainToolBar = new QToolBar(MainWindow); + mainToolBar->setObjectName(QString::fromUtf8("mainToolBar")); + MainWindow->addToolBar(Qt::TopToolBarArea, mainToolBar); + statusBar = new QStatusBar(MainWindow); + statusBar->setObjectName(QString::fromUtf8("statusBar")); + MainWindow->setStatusBar(statusBar); + QWidget::setTabOrder(tabWidget, trj_lineEdit_workDir); + QWidget::setTabOrder(trj_lineEdit_workDir, trj_pushButton_workDir); + QWidget::setTabOrder(trj_pushButton_workDir, trj_lineEdit_input); + QWidget::setTabOrder(trj_lineEdit_input, trj_pushButton_input); + QWidget::setTabOrder(trj_pushButton_input, trj_comboBox_type); + QWidget::setTabOrder(trj_comboBox_type, trj_spinBox_steps); + QWidget::setTabOrder(trj_spinBox_steps, trj_lineEdit_atoms); + QWidget::setTabOrder(trj_lineEdit_atoms, trj_pushButton_atoms); + QWidget::setTabOrder(trj_pushButton_atoms, trj_lineEdit_output); + QWidget::setTabOrder(trj_lineEdit_output, trj_spinBox_totalTypes); + QWidget::setTabOrder(trj_spinBox_totalTypes, trj_checkBox_log); + QWidget::setTabOrder(trj_checkBox_log, trj_lineEdit_log); + QWidget::setTabOrder(trj_lineEdit_log, trj_pushButton_log); + QWidget::setTabOrder(trj_pushButton_log, trj_pushButton_clear); + QWidget::setTabOrder(trj_pushButton_clear, trj_pushButton_start); + QWidget::setTabOrder(trj_pushButton_start, statgen_lineEdit_workDir); + QWidget::setTabOrder(statgen_lineEdit_workDir, statgen_pushButton_workDir); + QWidget::setTabOrder(statgen_pushButton_workDir, statgen_lineEdit_input); + QWidget::setTabOrder(statgen_lineEdit_input, statgen_spinBox_stepsFirst); + QWidget::setTabOrder(statgen_spinBox_stepsFirst, statgen_spinBox_stepsLast); + QWidget::setTabOrder(statgen_spinBox_stepsLast, statgen_doubleSpinBox_cellX); + QWidget::setTabOrder(statgen_doubleSpinBox_cellX, statgen_doubleSpinBox_cellY); + QWidget::setTabOrder(statgen_doubleSpinBox_cellY, statgen_doubleSpinBox_cellZ); + QWidget::setTabOrder(statgen_doubleSpinBox_cellZ, statgen_spinBox_atoms0); + QWidget::setTabOrder(statgen_spinBox_atoms0, statgen_checkBox_atoms1); + QWidget::setTabOrder(statgen_checkBox_atoms1, statgen_spinBox_atoms1); + QWidget::setTabOrder(statgen_spinBox_atoms1, statgen_checkBox_atoms2); + QWidget::setTabOrder(statgen_checkBox_atoms2, statgen_spinBox_atoms2); + QWidget::setTabOrder(statgen_spinBox_atoms2, statgen_checkBox_atoms3); + QWidget::setTabOrder(statgen_checkBox_atoms3, statgen_spinBox_atoms3); + QWidget::setTabOrder(statgen_spinBox_atoms3, statgen_comboBox_int); + QWidget::setTabOrder(statgen_comboBox_int, statgen_doubleSpinBox_int); + QWidget::setTabOrder(statgen_doubleSpinBox_int, stagen_pushButton_intSave); + QWidget::setTabOrder(stagen_pushButton_intSave, statgen_pushButton_intAdd); + QWidget::setTabOrder(statgen_pushButton_intAdd, statgen_listWidget_int); + QWidget::setTabOrder(statgen_listWidget_int, stagen_pushButton_intRem); + QWidget::setTabOrder(stagen_pushButton_intRem, statgen_lineEdit_output); + QWidget::setTabOrder(statgen_lineEdit_output, statgen_pushButton_output); + QWidget::setTabOrder(statgen_pushButton_output, statgen_checkBox_depth); + QWidget::setTabOrder(statgen_checkBox_depth, statgen_spinBox_depth); + QWidget::setTabOrder(statgen_spinBox_depth, statgen_checkBox_log); + QWidget::setTabOrder(statgen_checkBox_log, statgen_lineEdit_log); + QWidget::setTabOrder(statgen_lineEdit_log, statgen_pushButton_log); + QWidget::setTabOrder(statgen_pushButton_log, statgen_pushButton_clear); + QWidget::setTabOrder(statgen_pushButton_clear, statgen_pushButton_start); + QWidget::setTabOrder(statgen_pushButton_start, envir_lineEdit_workDir); + QWidget::setTabOrder(envir_lineEdit_workDir, envir_pushButton_workDir); + QWidget::setTabOrder(envir_pushButton_workDir, envir_lineEdit_input); + QWidget::setTabOrder(envir_lineEdit_input, envir_pushButton_input); + QWidget::setTabOrder(envir_pushButton_input, envir_doubleSpinBox_cellX); + QWidget::setTabOrder(envir_doubleSpinBox_cellX, envir_doubleSpinBox_cellY); + QWidget::setTabOrder(envir_doubleSpinBox_cellY, envir_doubleSpinBox_cellZ); + QWidget::setTabOrder(envir_doubleSpinBox_cellZ, envir_lineEdit_output); + QWidget::setTabOrder(envir_lineEdit_output, envir_pushButton_output); + QWidget::setTabOrder(envir_pushButton_output, envir_spinBox_molecule); + QWidget::setTabOrder(envir_spinBox_molecule, envir_doubleSpinBox_radius); + QWidget::setTabOrder(envir_doubleSpinBox_radius, envir_checkBox_log); + QWidget::setTabOrder(envir_checkBox_log, envir_lineEdit_log); + QWidget::setTabOrder(envir_lineEdit_log, envir_pushButton_log); + QWidget::setTabOrder(envir_pushButton_log, envir_pushButton_clear); + QWidget::setTabOrder(envir_pushButton_clear, envir_pushButton_start); + QWidget::setTabOrder(envir_pushButton_start, radf_lineEdit_workDir); + QWidget::setTabOrder(radf_lineEdit_workDir, radf_pushButton_workDir); + QWidget::setTabOrder(radf_pushButton_workDir, radf_lineEdit_input); + QWidget::setTabOrder(radf_lineEdit_input, radf_spinBox_stepsFirst); + QWidget::setTabOrder(radf_spinBox_stepsFirst, radf_spinBox_stepsLast); + QWidget::setTabOrder(radf_spinBox_stepsLast, radf_doubleSpinBox_cellX); + QWidget::setTabOrder(radf_doubleSpinBox_cellX, radf_doubleSpinBox_cellY); + QWidget::setTabOrder(radf_doubleSpinBox_cellY, radf_doubleSpinBox_cellZ); + QWidget::setTabOrder(radf_doubleSpinBox_cellZ, radf_lineEdit_output); + QWidget::setTabOrder(radf_lineEdit_output, radf_pushButton_output); + QWidget::setTabOrder(radf_pushButton_output, radf_comboBox_atom); + QWidget::setTabOrder(radf_comboBox_atom, radf_spinBox_atoms0); + QWidget::setTabOrder(radf_spinBox_atoms0, radf_spinBox_atoms1); + QWidget::setTabOrder(radf_spinBox_atoms1, radf_spinBox_atoms2); + QWidget::setTabOrder(radf_spinBox_atoms2, radf_spinBox_atoms3); + QWidget::setTabOrder(radf_spinBox_atoms3, radf_spinBox_atoms4); + QWidget::setTabOrder(radf_spinBox_atoms4, radf_spinBox_atoms5); + QWidget::setTabOrder(radf_spinBox_atoms5, radf_doubleSpinBox_radMin); + QWidget::setTabOrder(radf_doubleSpinBox_radMin, radf_doubleSpinBox_radMax); + QWidget::setTabOrder(radf_doubleSpinBox_radMax, radf_doubleSpinBox_radStep); + QWidget::setTabOrder(radf_doubleSpinBox_radStep, radf_checkBox_ang); + QWidget::setTabOrder(radf_checkBox_ang, radf_doubleSpinBox_angMin); + QWidget::setTabOrder(radf_doubleSpinBox_angMin, radf_doubleSpinBox_angMax); + QWidget::setTabOrder(radf_doubleSpinBox_angMax, radf_doubleSpinBox_angStep); + QWidget::setTabOrder(radf_doubleSpinBox_angStep, radf_checkBox_matrix); + QWidget::setTabOrder(radf_checkBox_matrix, radf_checkBox_log); + QWidget::setTabOrder(radf_checkBox_log, radf_lineEdit_log); + QWidget::setTabOrder(radf_lineEdit_log, radf_pushButton_log); + QWidget::setTabOrder(radf_pushButton_log, radf_pushButton_clear); + QWidget::setTabOrder(radf_pushButton_clear, radf_pushButton_start); + QWidget::setTabOrder(radf_pushButton_start, pdb_comboBox_mode); + QWidget::setTabOrder(pdb_comboBox_mode, pdb_lineEdit_workDir); + QWidget::setTabOrder(pdb_lineEdit_workDir, pdb_pushButton_workDir); + QWidget::setTabOrder(pdb_pushButton_workDir, pdb_lineEdit_input); + QWidget::setTabOrder(pdb_lineEdit_input, pdb_pushButton_input); + QWidget::setTabOrder(pdb_pushButton_input, pdb_lineEdit_agl); + QWidget::setTabOrder(pdb_lineEdit_agl, pdb_pushButton_agl); + QWidget::setTabOrder(pdb_pushButton_agl, pdb_doubleSpinBox_cellX); + QWidget::setTabOrder(pdb_doubleSpinBox_cellX, pdb_doubleSpinBox_cellY); + QWidget::setTabOrder(pdb_doubleSpinBox_cellY, pdb_doubleSpinBox_cellZ); + QWidget::setTabOrder(pdb_doubleSpinBox_cellZ, pdb_lineEdit_output); + QWidget::setTabOrder(pdb_lineEdit_output, pdb_pushButton_output); + QWidget::setTabOrder(pdb_pushButton_output, pdb_checkBox_log); + QWidget::setTabOrder(pdb_checkBox_log, pdb_lineEdit_log); + QWidget::setTabOrder(pdb_lineEdit_log, pdb_pushButton_log); + QWidget::setTabOrder(pdb_pushButton_log, pdb_pushButton_clear); + QWidget::setTabOrder(pdb_pushButton_clear, pdb_pushButton_start); + + menuBar->addAction(menuMenu->menuAction()); + menuBar->addAction(menuHelp->menuAction()); + menuMenu->addAction(actionExit); + menuHelp->addAction(actionHelp); + menuHelp->addAction(actionAbout); + + retranslateUi(MainWindow); + QObject::connect(actionExit, SIGNAL(triggered()), MainWindow, SLOT(close())); + + tabWidget->setCurrentIndex(0); + + + QMetaObject::connectSlotsByName(MainWindow); + } // setupUi + + void retranslateUi(QMainWindow *MainWindow) + { + MainWindow->setWindowTitle(QApplication::translate("MainWindow", "Mathematical Molecular Mechanics", 0, QApplication::UnicodeUTF8)); + actionExit->setText(QApplication::translate("MainWindow", "Exit", 0, QApplication::UnicodeUTF8)); + actionExit->setShortcut(QApplication::translate("MainWindow", "Ctrl+Q", 0, QApplication::UnicodeUTF8)); + actionHelp->setText(QApplication::translate("MainWindow", "Help", 0, QApplication::UnicodeUTF8)); + actionHelp->setShortcut(QApplication::translate("MainWindow", "F1", 0, QApplication::UnicodeUTF8)); + actionAbout->setText(QApplication::translate("MainWindow", "About", 0, QApplication::UnicodeUTF8)); + trj_label_workDir->setText(QApplication::translate("MainWindow", "Work directory", 0, QApplication::UnicodeUTF8)); + trj_pushButton_workDir->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + trj_label_input->setText(QApplication::translate("MainWindow", "Input file", 0, QApplication::UnicodeUTF8)); + trj_pushButton_input->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + trj_label_type->setText(QApplication::translate("MainWindow", "Type of trajectory", 0, QApplication::UnicodeUTF8)); + trj_comboBox_type->clear(); + trj_comboBox_type->insertItems(0, QStringList() + << QApplication::translate("MainWindow", "GROMACS text", 0, QApplication::UnicodeUTF8) + << QApplication::translate("MainWindow", "PUMA", 0, QApplication::UnicodeUTF8) + ); + trj_label_steps->setText(QApplication::translate("MainWindow", "Number of steps", 0, QApplication::UnicodeUTF8)); + trj_label_atoms->setText(QApplication::translate("MainWindow", "Atom type file", 0, QApplication::UnicodeUTF8)); + trj_pushButton_atoms->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + trj_label_output->setText(QApplication::translate("MainWindow", "Mask of output files", 0, QApplication::UnicodeUTF8)); + trj_label_totalTypes->setText(QApplication::translate("MainWindow", "Total atom types", 0, QApplication::UnicodeUTF8)); + trj_checkBox_log->setText(QApplication::translate("MainWindow", "Log", 0, QApplication::UnicodeUTF8)); + trj_pushButton_log->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + trj_pushButton_clear->setText(QApplication::translate("MainWindow", "Clear", 0, QApplication::UnicodeUTF8)); + trj_pushButton_start->setText(QApplication::translate("MainWindow", "Start", 0, QApplication::UnicodeUTF8)); + tabWidget->setTabText(tabWidget->indexOf(trj), QApplication::translate("MainWindow", "Generate trajectory", 0, QApplication::UnicodeUTF8)); + statgen_label_workDir->setText(QApplication::translate("MainWindow", "Work directory", 0, QApplication::UnicodeUTF8)); + statgen_pushButton_workDir->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + statgen_label_input->setText(QApplication::translate("MainWindow", "Mask of input files", 0, QApplication::UnicodeUTF8)); + statgen_label_steps->setText(QApplication::translate("MainWindow", "Steps", 0, QApplication::UnicodeUTF8)); + statgen_label_stepsFirst->setText(QApplication::translate("MainWindow", "first", 0, QApplication::UnicodeUTF8)); + statgen_label_stepsLast->setText(QApplication::translate("MainWindow", "last", 0, QApplication::UnicodeUTF8)); + statgen_label_cell->setText(QApplication::translate("MainWindow", "Cell, A", 0, QApplication::UnicodeUTF8)); + statgen_label_cellX->setText(QApplication::translate("MainWindow", "X", 0, QApplication::UnicodeUTF8)); + statgen_label_cellY->setText(QApplication::translate("MainWindow", "Y", 0, QApplication::UnicodeUTF8)); + statgen_label_cellZ->setText(QApplication::translate("MainWindow", "Z", 0, QApplication::UnicodeUTF8)); + statgen_label_atoms0->setText(QApplication::translate("MainWindow", "atom 0", 0, QApplication::UnicodeUTF8)); + statgen_checkBox_atoms1->setText(QApplication::translate("MainWindow", "atom 1", 0, QApplication::UnicodeUTF8)); + statgen_checkBox_atoms2->setText(QApplication::translate("MainWindow", "atom 2", 0, QApplication::UnicodeUTF8)); + statgen_checkBox_atoms3->setText(QApplication::translate("MainWindow", "atom 3", 0, QApplication::UnicodeUTF8)); + statgen_label_int->setText(QApplication::translate("MainWindow", "Interaction", 0, QApplication::UnicodeUTF8)); + statgen_comboBox_int->clear(); + statgen_comboBox_int->insertItems(0, QStringList() + << QApplication::translate("MainWindow", "0-0", 0, QApplication::UnicodeUTF8) + ); + stagen_pushButton_intSave->setText(QApplication::translate("MainWindow", "Save", 0, QApplication::UnicodeUTF8)); + statgen_pushButton_intAdd->setText(QApplication::translate("MainWindow", "Add", 0, QApplication::UnicodeUTF8)); + stagen_pushButton_intRem->setText(QApplication::translate("MainWindow", "Remove", 0, QApplication::UnicodeUTF8)); + statgen_label_output->setText(QApplication::translate("MainWindow", "Output file", 0, QApplication::UnicodeUTF8)); + statgen_pushButton_output->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + statgen_checkBox_depth->setText(QApplication::translate("MainWindow", "Depth of search", 0, QApplication::UnicodeUTF8)); + statgen_checkBox_log->setText(QApplication::translate("MainWindow", "Log", 0, QApplication::UnicodeUTF8)); + statgen_pushButton_log->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + statgen_pushButton_clear->setText(QApplication::translate("MainWindow", "Clear", 0, QApplication::UnicodeUTF8)); + statgen_pushButton_start->setText(QApplication::translate("MainWindow", "Start", 0, QApplication::UnicodeUTF8)); + tabWidget->setTabText(tabWidget->indexOf(statgen), QApplication::translate("MainWindow", "Agglomeration", 0, QApplication::UnicodeUTF8)); + envir_label_workDir->setText(QApplication::translate("MainWindow", "Work directory", 0, QApplication::UnicodeUTF8)); + envir_pushButton_workDir->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + envir_label_input->setText(QApplication::translate("MainWindow", "Input file", 0, QApplication::UnicodeUTF8)); + envir_pushButton_input->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + envir_label_cell->setText(QApplication::translate("MainWindow", "Cell, A", 0, QApplication::UnicodeUTF8)); + envir_label_cellX->setText(QApplication::translate("MainWindow", "X", 0, QApplication::UnicodeUTF8)); + envir_label_cellY->setText(QApplication::translate("MainWindow", "Y", 0, QApplication::UnicodeUTF8)); + envir_label_cellZ->setText(QApplication::translate("MainWindow", "Z", 0, QApplication::UnicodeUTF8)); + envir_label_output->setText(QApplication::translate("MainWindow", "Output file", 0, QApplication::UnicodeUTF8)); + envir_pushButton_output->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + envir_label_molecule->setText(QApplication::translate("MainWindow", "Molecule", 0, QApplication::UnicodeUTF8)); + envir_label_radius->setText(QApplication::translate("MainWindow", "Radius", 0, QApplication::UnicodeUTF8)); + envir_checkBox_log->setText(QApplication::translate("MainWindow", "Log", 0, QApplication::UnicodeUTF8)); + envir_pushButton_log->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + envir_pushButton_clear->setText(QApplication::translate("MainWindow", "Clear", 0, QApplication::UnicodeUTF8)); + envir_pushButton_start->setText(QApplication::translate("MainWindow", "Start", 0, QApplication::UnicodeUTF8)); + tabWidget->setTabText(tabWidget->indexOf(envir), QApplication::translate("MainWindow", "Environment", 0, QApplication::UnicodeUTF8)); + radf_label_workDir->setText(QApplication::translate("MainWindow", "Work directory", 0, QApplication::UnicodeUTF8)); + radf_pushButton_workDir->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + radf_label_input->setText(QApplication::translate("MainWindow", "Mask of input files", 0, QApplication::UnicodeUTF8)); + radf_label_steps->setText(QApplication::translate("MainWindow", "Steps", 0, QApplication::UnicodeUTF8)); + radf_label_stepsFirst->setText(QApplication::translate("MainWindow", "first", 0, QApplication::UnicodeUTF8)); + radf_label_stepsLast->setText(QApplication::translate("MainWindow", "last", 0, QApplication::UnicodeUTF8)); + radf_label_cell->setText(QApplication::translate("MainWindow", "Cell, A", 0, QApplication::UnicodeUTF8)); + radf_label_cellX->setText(QApplication::translate("MainWindow", "X", 0, QApplication::UnicodeUTF8)); + radf_label_cellY->setText(QApplication::translate("MainWindow", "Y", 0, QApplication::UnicodeUTF8)); + radf_label_cellZ->setText(QApplication::translate("MainWindow", "Z", 0, QApplication::UnicodeUTF8)); + radf_label_output->setText(QApplication::translate("MainWindow", "Output file", 0, QApplication::UnicodeUTF8)); + radf_pushButton_output->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + radf_comboBox_atom->clear(); + radf_comboBox_atom->insertItems(0, QStringList() + << QApplication::translate("MainWindow", "One atom function", 0, QApplication::UnicodeUTF8) + << QApplication::translate("MainWindow", "Three atom function", 0, QApplication::UnicodeUTF8) + ); + radf_label_atoms0->setText(QApplication::translate("MainWindow", "atom 1", 0, QApplication::UnicodeUTF8)); + radf_label_atoms1->setText(QApplication::translate("MainWindow", "atom 2", 0, QApplication::UnicodeUTF8)); + radf_label_atoms2->setText(QApplication::translate("MainWindow", "atom 3", 0, QApplication::UnicodeUTF8)); + radf_label_atoms3->setText(QApplication::translate("MainWindow", "atom 1", 0, QApplication::UnicodeUTF8)); + radf_label_atoms4->setText(QApplication::translate("MainWindow", "atom 2", 0, QApplication::UnicodeUTF8)); + radf_label_atoms5->setText(QApplication::translate("MainWindow", "atom 3", 0, QApplication::UnicodeUTF8)); + radf_label_rad->setText(QApplication::translate("MainWindow", "R, A", 0, QApplication::UnicodeUTF8)); + radf_label_radMin->setText(QApplication::translate("MainWindow", "min", 0, QApplication::UnicodeUTF8)); + radf_label_radMax->setText(QApplication::translate("MainWindow", "max", 0, QApplication::UnicodeUTF8)); + radf_label_radStep->setText(QApplication::translate("MainWindow", "step", 0, QApplication::UnicodeUTF8)); + radf_checkBox_ang->setText(QApplication::translate("MainWindow", "Angle, deg", 0, QApplication::UnicodeUTF8)); + radf_label_angMin->setText(QApplication::translate("MainWindow", "min", 0, QApplication::UnicodeUTF8)); + radf_label_angMax->setText(QApplication::translate("MainWindow", "max", 0, QApplication::UnicodeUTF8)); + radf_label_angStep->setText(QApplication::translate("MainWindow", "step", 0, QApplication::UnicodeUTF8)); + radf_checkBox_matrix->setText(QApplication::translate("MainWindow", "Matrix", 0, QApplication::UnicodeUTF8)); + radf_checkBox_log->setText(QApplication::translate("MainWindow", "Log", 0, QApplication::UnicodeUTF8)); + radf_pushButton_log->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + radf_pushButton_clear->setText(QApplication::translate("MainWindow", "Clear", 0, QApplication::UnicodeUTF8)); + radf_pushButton_start->setText(QApplication::translate("MainWindow", "Start", 0, QApplication::UnicodeUTF8)); + tabWidget->setTabText(tabWidget->indexOf(radf), QApplication::translate("MainWindow", "RADF", 0, QApplication::UnicodeUTF8)); + pdb_comboBox_mode->clear(); + pdb_comboBox_mode->insertItems(0, QStringList() + << QApplication::translate("MainWindow", "From agglomerate", 0, QApplication::UnicodeUTF8) + << QApplication::translate("MainWindow", "From trajectory snapshot", 0, QApplication::UnicodeUTF8) + ); + pdb_label_workDir->setText(QApplication::translate("MainWindow", "Work directory", 0, QApplication::UnicodeUTF8)); + pdb_pushButton_workDir->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + pdb_label_input->setText(QApplication::translate("MainWindow", "Input file", 0, QApplication::UnicodeUTF8)); + pdb_pushButton_input->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + pdb_label_agl->setText(QApplication::translate("MainWindow", "File with agglomerate", 0, QApplication::UnicodeUTF8)); + pdb_pushButton_agl->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + pdb_label_cell->setText(QApplication::translate("MainWindow", "Cell, A", 0, QApplication::UnicodeUTF8)); + pdb_label_cellX->setText(QApplication::translate("MainWindow", "X", 0, QApplication::UnicodeUTF8)); + pdb_label_cellY->setText(QApplication::translate("MainWindow", "Y", 0, QApplication::UnicodeUTF8)); + pdb_label_cellZ->setText(QApplication::translate("MainWindow", "Z", 0, QApplication::UnicodeUTF8)); + pdb_label_output->setText(QApplication::translate("MainWindow", "Output file", 0, QApplication::UnicodeUTF8)); + pdb_pushButton_output->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + pdb_checkBox_log->setText(QApplication::translate("MainWindow", "Log", 0, QApplication::UnicodeUTF8)); + pdb_pushButton_log->setText(QApplication::translate("MainWindow", "Browse", 0, QApplication::UnicodeUTF8)); + pdb_pushButton_clear->setText(QApplication::translate("MainWindow", "Clear", 0, QApplication::UnicodeUTF8)); + pdb_pushButton_start->setText(QApplication::translate("MainWindow", "Start", 0, QApplication::UnicodeUTF8)); + tabWidget->setTabText(tabWidget->indexOf(pdb), QApplication::translate("MainWindow", "Generate PDB", 0, QApplication::UnicodeUTF8)); + menuMenu->setTitle(QApplication::translate("MainWindow", "Menu", 0, QApplication::UnicodeUTF8)); + menuHelp->setTitle(QApplication::translate("MainWindow", "Help", 0, QApplication::UnicodeUTF8)); + } // retranslateUi + +}; + +namespace Ui { + class MainWindow: public Ui_MainWindow {}; +} // namespace Ui + +QT_END_NAMESPACE + +#endif // UI_MAINWINDOW_H diff --git a/mm_trj/src/main.c b/mm_trj/src/main.c index aab5a38..3e3642d 100644 --- a/mm_trj/src/main.c +++ b/mm_trj/src/main.c @@ -183,7 +183,7 @@ int main(int argc, char *argv[]) strcpy (output, argv[i+1]); i++; } - else if ((argv[i][0] == '-') && (argv[i][1] == 't') && (argv[i][1] == 't') && (argv[i][2] == '\0')) + else if ((argv[i][0] == '-') && (argv[i][1] == 't') && (argv[i][2] == 't') && (argv[i][3] == '\0')) // number of atom types { sscanf (argv[i+1], "%i", &total_types);