int main()
{
//init g_version
g_version.Major = 9;
g_version.Minor = 88;
g_version.BuildVersion = 777;
//register to module list
g_moduleUpgradeNO = registerModule(ModuleName_UPGRADE, ModuleVersion_UPGRADE, ModuleLogType_UPGRADE);
g_moduleBuildNO = registerModule(ModuleName_BUILD, ModuleVersion_BUILD, ModuleLogType_BUILD);
upgradeLogFatal("=====upgradeLogFatal==[%d]=--------------=\n", g_moduleUpgradeNO);
upgradeLogError("=====upgradeLogError==[%d]=--------------=\n", g_moduleUpgradeNO);
upgradeLogWarning("=====upgradeLogWarning==[%d]=--------------=\n", g_moduleUpgradeNO);
upgradeLogInfo("=====upgradeLogInfo==[%d]=--------------=\n", g_moduleUpgradeNO);
upgradeLogVerbose("=====upgradeLogVerbose==[%d]=--------------=\n", g_moduleUpgradeNO);
upgradeLogDebug("=====upgradeLogDebug==[%d]=--------------=\n", g_moduleUpgradeNO);
printf("==========================================\n");
buildLogFatal("=====buildLogFatal==[%d]=--------------=\n", g_moduleBuildNO);
buildLogError("=====buildLogError==[%d]=--------------=\n", g_moduleBuildNO);
buildLogWarning("=====buildLogWarning==[%d]=--------------=\n", g_moduleBuildNO);
buildLogInfo("=====buildLogInfo==[%d]=--------------=\n", g_moduleBuildNO);
buildLogVerbose("=====buildLogVerbose==[%d]=--------------=\n", g_moduleBuildNO);
buildLogDebug("=====buildLogDebug==[%d]=--------------=\n", g_moduleBuildNO);
return 0;
}
void Debug::Data::setBit(const char *_pbeg, const char *_pend){
std::string str;
str.assign(_pbeg, _pend - _pbeg);
std::string name;
uint32 lvls = -1;
{
std::string lvlstr;
size_t off = str.rfind(':');
if(off == string::npos){
name = str;
}else{
name = str.substr(0, off);
lvlstr = str.substr(off, str.size() - off);
}
if(lvlstr.size()){
lvls= parseLevels(lvlstr.c_str());
}
}
if(!cstring::ncasecmp(name.c_str(), "all", name.size())){
bs.set();
}else if(!cstring::ncasecmp(name.c_str(), "none", name.size())){
bs.reset();
}else{
unsigned pos = registerModule(name.c_str(), 0);
modvec[pos].lvlmsk = lvls;
bs.set(pos);
}
}
void InviwoApplicationQt::initialize(registerModuleFuncPtr regModuleFunc) {
LogInfoCustom("InviwoInfo", "Qt Version " << QT_VERSION_STR);
InviwoApplication::initialize(regModuleFunc);
// Since QtWidgets are not a module we have to register it our self
InviwoModule* module = new QtWidgetModule();
registerModule(module);
module->initialize();
}
void CGatewayProxySrv::onRegister(const char* name, const unsigned int id)
{
ReleaseInfoLog("register gateway module, service name = %s, id = %d", name, id);
// 注册模块实例
const unsigned short HandlerMessageModule = 0;
static CSrvMsgHandler msgHandler;
m_connectNotifyToHandler = &msgHandler;
registerModule(HandlerMessageModule, &msgHandler);
}
/**
* NOTE:
* 在使用之前先调用该函数，对该模块的log组件进行初始化
*
**/
int log_views_init()
{
//register to module list
g_moduleViewsNO = registerModule(ModuleName_Views, ModuleVersion_Views, ModuleLogType_Views);
printf("====================log_views_init======================\n");
#if 1
viewsLogFatal("=====viewsLogFatal==[%d]=--------------=\n", g_moduleViewsNO);
viewsLogError("=====viewsLogError==[%d]=--------------=\n", g_moduleViewsNO);
viewsLogWarning("=====viewsLogWarning==[%d]=--------------=\n", g_moduleViewsNO);
viewsLogInfo("=====viewsLogInfo==[%d]=--------------=\n", g_moduleViewsNO);
viewsLogVerbose("=====viewsLogVerbose==[%d]=--------------=\n", g_moduleViewsNO);
viewsLogDebug("=====viewsLogDebug==[%d]=--------------=\n", g_moduleViewsNO);
#endif
return 0;
}
/**
* NOTE:
* 在使用之前先调用该函数，对该模块的log组件进行初始化
*
**/
int log_monitor_init()
{
//register to module list
g_moduleMonitorNO = registerModule(ModuleName_Monitor, ModuleVersion_Monitor, ModuleLogType_Monitor);
printf("==========================================\n");
#if 1
monitorLogFatal("=====monitorLogFatal==[%d]=--------------=\n", g_moduleMonitorNO);
monitorLogError("=====monitorLogError==[%d]=--------------=\n", g_moduleMonitorNO);
monitorLogWarning("=====monitorLogWarning==[%d]=--------------=\n", g_moduleMonitorNO);
monitorLogInfo("=====monitorLogInfo==[%d]=--------------=\n", g_moduleMonitorNO);
monitorLogVerbose("=====monitorLogVerbose==[%d]=--------------=\n", g_moduleMonitorNO);
monitorLogDebug("=====monitorLogDebug==[%d]=--------------=\n", g_moduleMonitorNO);
#endif
return 0;
}
/**
* NOTE:
* 在使用之前先调用该函数，对该模块的log组件进行初始化
*
**/
int log_media_info_init()
{
//register to module list
g_moduleMediaInfoNO = registerModule(ModuleName_MediaInfo, ModuleVersion_MediaInfo, ModuleLogType_MediaInfo);
printf("=================log_media_info_init=========================\n");
#if 1
media_infoLogFatal("=====media_infoLogFatal==[%d]=--------------=\n", g_moduleMediaInfoNO);
media_infoLogError("=====media_infoLogError==[%d]=--------------=\n", g_moduleMediaInfoNO);
media_infoLogWarning("=====media_infoLogWarning==[%d]=--------------=\n", g_moduleMediaInfoNO);
media_infoLogInfo("=====media_infoLogInfo==[%d]=--------------=\n", g_moduleMediaInfoNO);
media_infoLogVerbose("=====media_infoLogVerbose==[%d]=--------------=\n", g_moduleMediaInfoNO);
media_infoLogDebug("=====media_infoLogDebug==[%d]=--------------=\n", g_moduleMediaInfoNO);
#endif
return 0;
}
ScriptComponent::ScriptComponent(Core::Engine &engine, ECS::Entity &parent, std::string className):Component(engine,parent), scObj_(nullptr),
ctx_(nullptr),scType_(nullptr){
std::string moduleName = className + ".as";
bool c = loadScript(moduleName);
if(!c) {
xLOG[Util::LogType::ERROR]("ScriptComponent :: ctor") << "Unable to load Scipt " << moduleName << ". Invalid Path?" << "\0";
throw Util::RunTimeError(xLOG.prev());
}
registerModule(moduleName);
c = loadType(className);
if(!c) {
xLOG[Util::LogType::ERROR]("ScriptComponent :: ctor") << "Couldn't load type for class: " << className << ". Wrong Name?" << "\0";
throw Util::RunTimeError(xLOG.prev());
}
c = loadObject();
if(!c) {
xLOG[Util::LogType::ERROR]("ScriptComponent :: ctor") << "Couldn't load object for class: " << className << ". Wait how can this even happen... You done f****d it up!" << "\0";
throw Util::RunTimeError(xLOG.prev());
}
extractVitalFunctions();
engine_.scriptEngine().registerScriptComponent(this);
}
//---------------------------------------------registerModules
bool ModuleRegistry::registerModules(NUGGET::IClayNugget* pNugget)
{
unsigned int uNumModules = pNugget->getNumModules();
if(uNumModules == 0)
{
return false;
}
for(unsigned int i=0; i<uNumModules; ++i)
{
const char* uri = pNugget->getModuleURI(i);
tModuleFactory fac = pNugget->getModuleFactory(i);
if(!uri || !fac)
{
return false;
}
if(!registerModule(uri, fac))
{
return false;
}
}
return true;
}
RecognitionConfigMultiKCMView(QWidget* parent, const QVariantList& args=QVariantList()) :
MultiKCMView(parent, args) {
registerModule(new NetworkSettings(parent, args), KIcon("simond"), i18n("Server"));
registerModule(new SynchronisationSettings(parent, args), KIcon("view-refresh"), i18n("Synchronization"));
}
/**
* The main initialisation method to setup pins and interrupts
*/
void DWire::_initMain( void ) {
// Initialise the receiver buffer and related variables
rxReadIndex = 0;
rxReadLength = 0;
requestDone = false;
sendStop = true;
switch (module) {
#ifdef USING_EUSCI_B0
case EUSCI_B0_BASE:
pTxBuffer = EUSCIB0_txBuffer;
pTxBufferIndex = &EUSCIB0_txBufferIndex;
pTxBufferSize = &EUSCIB0_txBufferSize;
pRxBuffer = EUSCIB0_rxBuffer;
pRxBufferIndex = &EUSCIB0_rxBufferIndex;
pRxBufferSize = &EUSCIB0_rxBufferSize;
modulePort = EUSCI_B0_PORT;
modulePins = EUSCI_B0_PINS;
intModule = INT_EUSCIB0;
MAP_I2C_registerInterrupt(module, EUSCIB0_IRQHandler);
break;
#endif
#ifdef USING_EUSCI_B1
case EUSCI_B1_BASE:
pTxBuffer = EUSCIB1_txBuffer;
pTxBufferIndex = &EUSCIB1_txBufferIndex;
pTxBufferSize = &EUSCIB1_txBufferSize;
pRxBuffer = EUSCIB1_rxBuffer;
pRxBufferIndex = &EUSCIB1_rxBufferIndex;
pRxBufferSize = &EUSCIB1_rxBufferSize;
modulePort = EUSCI_B1_PORT;
modulePins = EUSCI_B1_PINS;
intModule = INT_EUSCIB1;
MAP_I2C_registerInterrupt(module, EUSCIB1_IRQHandler);
break;
#endif
#ifdef USING_EUSCI_B2
case EUSCI_B2_BASE:
pTxBuffer = EUSCIB2_txBuffer;
pTxBufferIndex = &EUSCIB2_txBufferIndex;
pTxBufferSize = &EUSCIB2_txBufferSize;
pRxBuffer = EUSCIB2_rxBuffer;
pRxBufferIndex = &EUSCIB2_rxBufferIndex;
pRxBufferSize = &EUSCIB2_rxBufferSize;
modulePort = EUSCI_B2_PORT;
modulePins = EUSCI_B2_PINS;
intModule = INT_EUSCIB2;
MAP_I2C_registerInterrupt(module, EUSCIB2_IRQHandler);
break;
#endif
#ifdef USING_EUSCI_B3
case EUSCI_B3_BASE:
pTxBuffer = EUSCIB3_txBuffer;
pTxBufferIndex = &EUSCIB3_txBufferIndex;
pTxBufferSize = &EUSCIB3_txBufferSize;
pRxBuffer = EUSCIB3_rxBuffer;
pRxBufferIndex = &EUSCIB3_rxBufferIndex;
pRxBufferSize = &EUSCIB3_rxBufferSize;
modulePort = EUSCI_B3_PORT;
modulePins = EUSCI_B3_PINS;
intModule = INT_EUSCIB3;
MAP_I2C_registerInterrupt(module, EUSCIB3_IRQHandler);
break;
#endif
default:
return;
}
// Register this instance in the 'moduleMap'
registerModule(this);
}
void registerLegacyModules(gmx::CommandLineModuleManager *manager)
{
// Modules from this directory (were in src/kernel/).
registerModule(manager, &gmx_check, "check",
"Check and compare files");
registerModule(manager, &gmx_dump, "dump",
"Make binary files human readable");
registerModule(manager, &gmx_grompp, "grompp",
"Make a run input file");
registerModule(manager, &gmx_pdb2gmx, "pdb2gmx",
"Convert coordinate files to topology and FF-compliant coordinate files");
registerModule(manager, &gmx_convert_tpr, "convert-tpr",
"Make a modifed run-input file");
registerObsoleteTool(manager, "tpbconv");
registerModule(manager, &gmx_protonate, "protonate",
"Protonate structures");
registerModule(manager, &gmx_x2top, "x2top",
"Generate a primitive topology from coordinates");
registerModuleNoNice(manager, &gmx_mdrun, "mdrun",
"Perform a simulation, do a normal mode analysis or an energy minimization");
// Modules from gmx_ana.h.
registerModule(manager, &gmx_do_dssp, "do_dssp",
"Assign secondary structure and calculate solvent accessible surface area");
registerModule(manager, &gmx_editconf, "editconf",
"Convert and manipulates structure files");
registerModule(manager, &gmx_eneconv, "eneconv",
"Convert energy files");
registerModule(manager, &gmx_solvate, "solvate",
"Solvate a system");
registerModule(manager, &gmx_insert_molecules, "insert-molecules",
"Insert molecules into existing vacancies");
registerObsoleteTool(manager, "genbox");
registerModule(manager, &gmx_genconf, "genconf",
"Multiply a conformation in 'random' orientations");
registerModule(manager, &gmx_genion, "genion",
"Generate monoatomic ions on energetically favorable positions");
registerModule(manager, &gmx_genpr, "genrestr",
"Generate position restraints or distance restraints for index groups");
registerModule(manager, &gmx_make_edi, "make_edi",
"Generate input files for essential dynamics sampling");
registerModule(manager, &gmx_make_ndx, "make_ndx",
"Make index files");
registerModule(manager, &gmx_mk_angndx, "mk_angndx",
"Generate index files for 'gmx angle'");
registerModule(manager, &gmx_trjcat, "trjcat",
"Concatenate trajectory files");
registerModule(manager, &gmx_trjconv, "trjconv",
"Convert and manipulates trajectory files");
registerModule(manager, &gmx_trjorder, "trjorder",
"Order molecules according to their distance to a group");
registerModule(manager, &gmx_xpm2ps, "xpm2ps",
"Convert XPM (XPixelMap) matrices to postscript or XPM");
registerModule(manager, &gmx_anadock, "anadock",
"Cluster structures from Autodock runs");
registerModule(manager, &gmx_anaeig, "anaeig",
"Analyze eigenvectors/normal modes");
registerModule(manager, &gmx_analyze, "analyze",
"Analyze data sets");
registerModule(manager, &gmx_g_angle, "angle",
"Calculate distributions and correlations for angles and dihedrals");
registerModule(manager, &gmx_bar, "bar",
"Calculate free energy difference estimates through Bennett's acceptance ratio");
registerObsoleteTool(manager, "bond");
registerObsoleteTool(manager, "dist");
registerObsoleteTool(manager, "sas");
registerObsoleteTool(manager, "sgangle");
registerModule(manager, &gmx_bundle, "bundle",
"Analyze bundles of axes, e.g., helices");
registerModule(manager, &gmx_chi, "chi",
"Calculate everything you want to know about chi and other dihedrals");
registerModule(manager, &gmx_cluster, "cluster",
"Cluster structures");
registerModule(manager, &gmx_clustsize, "clustsize",
"Calculate size distributions of atomic clusters");
registerModule(manager, &gmx_confrms, "confrms",
"Fit two structures and calculates the RMSD");
registerModule(manager, &gmx_covar, "covar",
"Calculate and diagonalize the covariance matrix");
registerModule(manager, &gmx_current, "current",
"Calculate dielectric constants and current autocorrelation function");
registerModule(manager, &gmx_density, "density",
"Calculate the density of the system");
registerModule(manager, &gmx_densmap, "densmap",
"Calculate 2D planar or axial-radial density maps");
registerModule(manager, &gmx_densorder, "densorder",
"Calculate surface fluctuations");
registerModule(manager, &gmx_dielectric, "dielectric",
"Calculate frequency dependent dielectric constants");
registerModule(manager, &gmx_dipoles, "dipoles",
"Compute the total dipole plus fluctuations");
registerModule(manager, &gmx_disre, "disre",
"Analyze distance restraints");
registerModule(manager, &gmx_dos, "dos",
"Analyze density of states and properties based on that");
registerModule(manager, &gmx_dyecoupl, "dyecoupl",
"Extract dye dynamics from trajectories");
registerModule(manager, &gmx_dyndom, "dyndom",
"Interpolate and extrapolate structure rotations");
registerModule(manager, &gmx_enemat, "enemat",
"Extract an energy matrix from an energy file");
registerModule(manager, &gmx_energy, "energy",
"Writes energies to xvg files and display averages");
registerModule(manager, &gmx_filter, "filter",
"Frequency filter trajectories, useful for making smooth movies");
registerModule(manager, &gmx_gyrate, "gyrate",
"Calculate the radius of gyration");
registerModule(manager, &gmx_h2order, "h2order",
"Compute the orientation of water molecules");
registerModule(manager, &gmx_hbond, "hbond",
"Compute and analyze hydrogen bonds");
registerModule(manager, &gmx_helix, "helix",
"Calculate basic properties of alpha helices");
registerModule(manager, &gmx_helixorient, "helixorient",
"Calculate local pitch/bending/rotation/orientation inside helices");
registerModule(manager, &gmx_hydorder, "hydorder",
"Compute tetrahedrality parameters around a given atom");
registerModule(manager, &gmx_lie, "lie",
"Estimate free energy from linear combinations");
registerModule(manager, &gmx_mdmat, "mdmat",
"Calculate residue contact maps");
registerModule(manager, &gmx_mindist, "mindist",
"Calculate the minimum distance between two groups");
registerModule(manager, &gmx_morph, "morph",
"Interpolate linearly between conformations");
registerModule(manager, &gmx_msd, "msd",
"Calculates mean square displacements");
registerModule(manager, &gmx_nmeig, "nmeig",
"Diagonalize the Hessian for normal mode analysis");
registerModule(manager, &gmx_nmens, "nmens",
"Generate an ensemble of structures from the normal modes");
registerModule(manager, &gmx_nmtraj, "nmtraj",
"Generate a virtual oscillating trajectory from an eigenvector");
registerModule(manager, &gmx_options, "options", NULL);
registerModule(manager, &gmx_order, "order",
"Compute the order parameter per atom for carbon tails");
registerModule(manager, &gmx_pme_error, "pme_error",
"Estimate the error of using PME with a given input file");
registerModule(manager, &gmx_polystat, "polystat",
"Calculate static properties of polymers");
registerModule(manager, &gmx_potential, "potential",
"Calculate the electrostatic potential across the box");
registerModule(manager, &gmx_principal, "principal",
"Calculate principal axes of inertia for a group of atoms");
registerModule(manager, &gmx_rama, "rama",
"Compute Ramachandran plots");
registerModule(manager, &gmx_rms, "rms",
"Calculate RMSDs with a reference structure and RMSD matrices");
registerModule(manager, &gmx_rmsdist, "rmsdist",
"Calculate atom pair distances averaged with power -2, -3 or -6");
registerModule(manager, &gmx_rmsf, "rmsf",
"Calculate atomic fluctuations");
registerModule(manager, &gmx_rotacf, "rotacf",
"Calculate the rotational correlation function for molecules");
registerModule(manager, &gmx_rotmat, "rotmat",
"Plot the rotation matrix for fitting to a reference structure");
registerModule(manager, &gmx_saltbr, "saltbr",
"Compute salt bridges");
registerModule(manager, &gmx_sans, "sans",
"Compute small angle neutron scattering spectra");
registerModule(manager, &gmx_saxs, "saxs",
"Compute small angle X-ray scattering spectra");
registerModule(manager, &gmx_sham, "sham",
"Compute free energies or other histograms from histograms");
registerModule(manager, &gmx_sigeps, "sigeps",
"Convert c6/12 or c6/cn combinations to and from sigma/epsilon");
registerModule(manager, &gmx_sorient, "sorient",
"Analyze solvent orientation around solutes");
registerModule(manager, &gmx_spatial, "spatial",
"Calculate the spatial distribution function");
registerModule(manager, &gmx_spol, "spol",
"Analyze solvent dipole orientation and polarization around solutes");
registerModule(manager, &gmx_tcaf, "tcaf",
"Calculate viscosities of liquids");
registerModule(manager, &gmx_traj, "traj",
"Plot x, v, f, box, temperature and rotational energy from trajectories");
registerModule(manager, &gmx_tune_pme, "tune_pme",
"Time mdrun as a function of PME ranks to optimize settings");
registerModule(manager, &gmx_vanhove, "vanhove",
"Compute Van Hove displacement and correlation functions");
registerModule(manager, &gmx_velacc, "velacc",
"Calculate velocity autocorrelation functions");
registerModule(manager, &gmx_wham, "wham",
"Perform weighted histogram analysis after umbrella sampling");
registerModule(manager, &gmx_wheel, "wheel",
"Plot helical wheels");
registerModuleNoNice(manager, &gmx_view, "view",
"View a trajectory on an X-Windows terminal");
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Generating topologies and coordinates");
group.addModuleWithDescription("editconf", "Edit the box and write subgroups");
group.addModule("protonate");
group.addModule("x2top");
group.addModule("solvate");
group.addModule("insert-molecules");
group.addModule("genconf");
group.addModule("genion");
group.addModule("genrestr");
group.addModule("pdb2gmx");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Running a simulation");
group.addModule("grompp");
group.addModule("mdrun");
group.addModule("convert-tpr");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Viewing trajectories");
group.addModule("nmtraj");
group.addModule("view");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Processing energies");
group.addModule("enemat");
group.addModule("energy");
group.addModuleWithDescription("mdrun", "(Re)calculate energies for trajectory frames with -rerun");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Converting files");
group.addModule("editconf");
group.addModule("eneconv");
group.addModule("sigeps");
group.addModule("trjcat");
group.addModule("trjconv");
group.addModule("xpm2ps");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Tools");
group.addModule("analyze");
group.addModule("dyndom");
group.addModule("filter");
group.addModule("lie");
group.addModule("morph");
group.addModule("pme_error");
group.addModule("sham");
group.addModule("spatial");
group.addModule("traj");
group.addModule("tune_pme");
group.addModule("wham");
group.addModule("check");
group.addModule("dump");
group.addModule("make_ndx");
group.addModule("mk_angndx");
group.addModule("trjorder");
group.addModule("xpm2ps");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Distances between structures");
group.addModule("cluster");
group.addModule("confrms");
group.addModule("rms");
group.addModule("rmsf");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Distances in structures over time");
group.addModule("mindist");
group.addModule("mdmat");
group.addModule("polystat");
group.addModule("rmsdist");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Mass distribution properties over time");
group.addModule("gyrate");
group.addModule("msd");
group.addModule("polystat");
group.addModule("rdf");
group.addModule("rotacf");
group.addModule("rotmat");
group.addModule("sans");
group.addModule("saxs");
group.addModule("traj");
group.addModule("vanhove");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Analyzing bonded interactions");
group.addModule("angle");
group.addModule("mk_angndx");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Structural properties");
group.addModule("anadock");
group.addModule("bundle");
group.addModule("clustsize");
group.addModule("disre");
group.addModule("hbond");
group.addModule("order");
group.addModule("principal");
group.addModule("rdf");
group.addModule("saltbr");
group.addModule("sorient");
group.addModule("spol");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Kinetic properties");
group.addModule("bar");
group.addModule("current");
group.addModule("dos");
group.addModule("dyecoupl");
group.addModule("principal");
group.addModule("tcaf");
group.addModule("traj");
group.addModule("vanhove");
group.addModule("velacc");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Electrostatic properties");
group.addModule("current");
group.addModule("dielectric");
group.addModule("dipoles");
group.addModule("potential");
group.addModule("spol");
group.addModule("genion");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Protein-specific analysis");
group.addModule("do_dssp");
group.addModule("chi");
group.addModule("helix");
group.addModule("helixorient");
group.addModule("rama");
group.addModule("wheel");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Interfaces");
group.addModule("bundle");
group.addModule("density");
group.addModule("densmap");
group.addModule("densorder");
group.addModule("h2order");
group.addModule("hydorder");
group.addModule("order");
group.addModule("potential");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Covariance analysis");
group.addModuleWithDescription("anaeig", "Analyze the eigenvectors");
group.addModule("covar");
group.addModule("make_edi");
}
{
gmx::CommandLineModuleGroup group =
manager->addModuleGroup("Normal modes");
group.addModuleWithDescription("anaeig", "Analyze the normal modes");
group.addModule("nmeig");
group.addModule("nmtraj");
group.addModule("nmens");
group.addModule("grompp");
group.addModuleWithDescription("mdrun", "Find a potential energy minimum and calculate the Hessian");
}
}
void InviwoApplication::initialize(registerModuleFuncPtr regModuleFunc) {
printApplicationInfo();
// initialize singletons
postProgress("Initializing singletons");
RenderContext::init();
ResourceManager::init();
PickingManager::init();
DataReaderFactory::init();
dataReaderFactory_ = DataReaderFactory::getPtr();
DataWriterFactory::init();
dataWriterFactory_ = DataWriterFactory::getPtr();
DialogFactory::init();
dialogFactory_ = DialogFactory::getPtr();
MeshDrawerFactory::init();
meshDrawerFactory_ = MeshDrawerFactory::getPtr();
MetaDataFactory::init();
metaDataFactory_ = MetaDataFactory::getPtr();
PortFactory::init();
portFactory_ = PortFactory::getPtr();
PortInspectorFactory::init();
portInspectorFactory_ = PortInspectorFactory::getPtr();
ProcessorFactory::init();
processorFactory_ = ProcessorFactory::getPtr();
ProcessorWidgetFactory::init();
processorWidgetFactory_ = ProcessorWidgetFactory::getPtr();
PropertyFactory::init();
propertyFactory_ = PropertyFactory::getPtr();
PropertyWidgetFactory::init();
propertyWidgetFactory_ = PropertyWidgetFactory::getPtr();
PropertyConverterManager::init();
propertyConverterManager_ = PropertyConverterManager::getPtr();
RepresentationConverterFactory::init();
representationConverterFactory_ = RepresentationConverterFactory::getPtr();
// Create and register core
InviwoCore* ivwCore = new InviwoCore(this);
registerModule(ivwCore);
// Load settings from core
auto coreSettings = ivwCore->getSettings();
for (auto setting : coreSettings) setting->loadFromDisk();
// Create and register other modules
(*regModuleFunc)(this);
for (auto& module : modules_) {
for (auto& elem : module->getCapabilities()) {
elem->retrieveStaticInfo();
elem->printInfo();
}
}
// Load settings from other modules
postProgress("Loading settings...");
auto settings = getModuleSettings(1);
for (auto setting : settings) setting->loadFromDisk();
auto sys = getSettingsByType<SystemSettings>();
if (sys && !commandLineParser_.getQuitApplicationAfterStartup()) {
pool_.setSize(static_cast<size_t>(sys->poolSize_.get()));
sys->poolSize_.onChange(
[this, sys]() { pool_.setSize(static_cast<size_t>(sys->poolSize_.get())); });
}
initialized_ = true;
}
bool IServerApp::installModule( uint16_t nModuleType )
{
auto pAsy = createModule(nModuleType) ;
return registerModule(pAsy,nModuleType) ;
}
