void PreconditionerML::createMLList ( list_Type& list, const GetPot& dataFile, const std::string& section, const std::string& subSection, const bool& verbose ) { list.setName ( "ML paramters list" ); std::string defList = dataFile ( (section + "/" + subSection + "/default_parameter_list").data(), "SA" ); if ( defList != "none" ) { ML_Epetra::SetDefaults ( defList, list ); } bool found; bool MLPrintParameterList = dataFile ( (section + "/displayList").data(), false, found ); Int MLOutput = dataFile ( (section + "/" + subSection + "/MLOuput").data(), 0, found); if ( found ) { list.set ( "ML output", MLOutput ); } Int printUnused = dataFile ( (section + "/" + subSection + "/print_unused").data(), -2, found); if ( found ) { list.set ( "print unused", printUnused ); } Int PDEEquations = dataFile ( (section + "/" + subSection + "/pde_equations").data(), 1, found); if ( found ) { list.set ( "PDE equations", PDEEquations ); } Int CycleApplications = dataFile ( (section + "/" + subSection + "/cycle_applications").data(), 1, found); if ( found ) { list.set ( "cycle applications", CycleApplications ); } Int MaxLevels = dataFile ( (section + "/" + subSection + "/max_levels").data(), 2, found); if ( found ) { list.set ( "max levels", MaxLevels ); } std::string IncOrDec = dataFile ( (section + "/" + subSection + "/inc_or_dec").data(), "increasing", found); if ( found ) { list.set ( "increasing or decreasing", IncOrDec ); } std::string precType = dataFile ( (section + "/" + subSection + "/prec_type").data(), "MGV", found); if ( found ) { list.set ( "prec type", precType ); } // Int NumProjectedModes = dataFile( (section + "/" + subSection + "/number_of_prejected_modes").data(), 0 ); // if ( found ) list.set( "ML print parameter list", MLPrintParameterList ); std::string eigenAnalysisType = dataFile ( (section + "/" + subSection + "/eigne-analysis/type").data(), "cg", found ); if ( found ) { list.set ( "eigen-analysis: type", eigenAnalysisType ); } Int eigenAnalysisIterations = dataFile ( (section + "/" + subSection + "/eigne-analysis/iterations").data(), 10, found ); if ( found ) { list.set ( "eigen-analysis: iterations", eigenAnalysisIterations ); } // Aggregation options std::string AggregationType = dataFile ( (section + "/" + subSection + "/aggregation/type").data(), "Uncoupled", found ); if ( found ) { list.set ( "aggregation: type", AggregationType ); } bool AggregationBlockScaling = dataFile ( (section + "/" + subSection + "/aggregation/block_scaling").data(), false, found ); if ( found ) { list.set ( "aggregation: block scaling", AggregationBlockScaling ); } Real AggregationThreshold = dataFile ( (section + "/" + subSection + "/aggregation/threshold").data(), 0.0 , found ); if ( found ) { list.set ( "aggregation: threshold", AggregationThreshold ); } Real AggregationDampingFactor = dataFile ( (section + "/" + subSection + "/aggregation/damping_factor").data(), 4. / 3. , found ); if ( found ) { list.set ( "aggregation: damping factor", AggregationDampingFactor ); } Int AggregationSmoothingSweeps = dataFile ( (section + "/" + subSection + "/aggregation/smoothing_sweeps").data(), 1, found ); if ( found ) { list.set ( "aggregation: smoothing sweeps", AggregationSmoothingSweeps ); } Int AggregationGlobalAggregates = dataFile ( (section + "/" + subSection + "/aggregation/global_aggregates").data(), 1, found ); if ( found ) { list.set ( "aggregation: global aggregates", AggregationGlobalAggregates ); } Int AggregationLocalAggregates = dataFile ( (section + "/" + subSection + "/aggregation/local_aggregates").data(), 1, found ); if ( found ) { list.set ( "aggregation: local aggregates", AggregationLocalAggregates ); } Int AggregationNodesPerAggregate = dataFile ( (section + "/" + subSection + "/aggregation/nodes_per_aggregate").data(), 1, found ); if ( found ) { list.set ( "aggregation: nodes per aggregate", AggregationNodesPerAggregate ); } Int AggregationNextLevelAggregatesPerProcess = dataFile ( (section + "/" + subSection + "/aggregation/next-level_aggregates_per_process").data(), 128, found ); if ( found ) { list.set ( "aggregation: next level aggregates per process", AggregationNextLevelAggregatesPerProcess ); } bool AggregationUseTentativeRestriction = dataFile ( (section + "/" + subSection + "/aggregation/tentative_restriction").data(), false, found ); if ( found ) { list.set ( "aggregation: use tentative restriction", AggregationUseTentativeRestriction ); } bool AggregationSymmetrize = dataFile ( (section + "/" + subSection + "/aggregation/symmetrize").data(), false, found ); if ( found ) { list.set ( "aggregation: symmetrize", AggregationSymmetrize ); } Int AggregationNumLevelTypes = dataFile ( (section + "/" + subSection + "/aggregation/level_type").data(), 0, found ); if ( found ) { for (Int i (0); i < AggregationNumLevelTypes; ++i) { std::string levelIndex = dataFile ( (section + "/" + subSection + "/aggregation/level_type").data(), "0", 2 * i + 1 ); std::string levelParamValue = dataFile ( (section + "/" + subSection + "/aggregation/level_type").data(), "METIS", 2 * i + 2 ); list.set ( ("aggregation: type (level " + levelIndex + ")").data(), levelParamValue ); } } bool EnergyMinimizationEnable = dataFile ( (section + "/" + subSection + "/energy_minimization/enable").data(), false, found ); if ( found ) { list.set ( "energy minimization: enable", EnergyMinimizationEnable ); } Int EnergyMinimizationType = dataFile ( (section + "/" + subSection + "/energy_minimization/type").data(), 2, found ); if ( found ) { list.set ( "energy minimization: type", EnergyMinimizationType ); } Real EnergyMinimizationDropTol = dataFile ( (section + "/" + subSection + "/energy_minimization/droptol").data(), 0., found ); if ( found ) { list.set ( "energy minimization: droptol", EnergyMinimizationDropTol ); } bool EnergyMinimizationCheap = dataFile ( (section + "/" + subSection + "/energy_minimization/cheap").data(), false, found ); if ( found ) { list.set ( "energy minimization: cheap", EnergyMinimizationCheap ); } // Smoothing parameters std::string SmootherType = dataFile ( (section + "/" + subSection + "/smoother/type").data(), "IFPACK", found ); if ( found ) { list.set ( "smoother: type", SmootherType ); } Int SmootherSweeps = dataFile ( (section + "/" + subSection + "/smoother/sweeps").data(), 2, found ); if ( found ) { list.set ( "smoother: sweeps", SmootherSweeps ); } Real SmootherDampingFactor = dataFile ( (section + "/" + subSection + "/smoother/damping_factor").data(), 1.0, found ); if ( found ) { list.set ( "smoother: damping factor", SmootherDampingFactor ); } std::string SmootherPreOrPost = dataFile ( (section + "/" + subSection + "/smoother/pre_or_post").data(), "both", found ); if ( found ) { list.set ( "smoother: pre or post", SmootherPreOrPost ); } Real SmootherChebyshevAlpha = dataFile ( (section + "/" + subSection + "/smoother/Chebyshev_alpha").data(), 20., found ); if ( found ) { list.set ( "smoother: Chebyshev alpha", SmootherChebyshevAlpha ); } bool SmootherHiptmairEfficientSymmetric = dataFile ( (section + "/" + subSection + "/smoother/Hiptmair_efficient_symmetric").data(), true, found ); if ( found ) { list.set ( "smoother: Hiptmair efficient symmetric", SmootherHiptmairEfficientSymmetric ); } std::string SmootherIfpackType = dataFile ( (section + "/" + subSection + "/smoother/ifpack_type").data(), "ILU", found ); if ( found ) { list.set ( "smoother: ifpack type", SmootherIfpackType ); } Int SmootherIfpackOverlap = dataFile ( (section + "/" + subSection + "/smoother/ifpack_overlap").data(), 1, found ); if ( found ) { list.set ( "smoother: ifpack overlap", SmootherIfpackOverlap ); } Int SmootherNumLevelTypes = dataFile ( (section + "/" + subSection + "/smoother/level_type").data(), 0, found ); if ( found ) { for (Int i (0); i < SmootherNumLevelTypes; ++i) { std::string levelIndex = dataFile ( (section + "/" + subSection + "/smoother/level_type").data(), "0", 2 * i + 1 ); std::string levelParamValue = dataFile ( (section + "/" + subSection + "/smoother/level_type").data(), "IFPACK", 2 * i + 2 ); list.set ( ("smoother: type (level " + levelIndex + ")").data(), levelParamValue ); } } Int SmootherNumLevelSweeps = dataFile ( (section + "/" + subSection + "/smoother/level_sweeps").data(), 0, found ); if ( found ) { for (Int i (0); i < SmootherNumLevelSweeps; ++i) { std::string levelIndex = dataFile ( (section + "/" + subSection + "/smoother/level_sweeps").data(), "0", 2 * i + 1 ); Int levelParamValue = dataFile ( (section + "/" + subSection + "/smoother/level_sweeps").data(), 1, 2 * i + 2 ); list.set ( ("smoother: sweeps (level " + levelIndex + ")").data(), levelParamValue ); } } // subsmoother parameter std::string SubSmootherType = dataFile ( (section + "/" + subSection + "/subsmoother/type").data(), "Chebyshev", found ); if ( found ) { list.set ( "subsmoother: type", SubSmootherType ); } Real SubSmootherChebyshevAlpha = dataFile ( (section + "/" + subSection + "/subsmoother/Chebyshev_alpha").data(), 20., found ); if ( found ) { list.set ( "subsmoother: Chebyshev alpha", SubSmootherChebyshevAlpha ); } // Real SubSmootherSGSDampingFactor = dataFile((section + "/" + subSection + "/subsmoothers/SGS_damping_factor").data(), 1., found ); Int SubSmootherEdgeSweeps = dataFile ( (section + "/" + subSection + "/subsmoother/edge_sweeps").data(), 2, found ); if ( found ) { list.set ( "subsmoother: edge sweeps", SubSmootherEdgeSweeps ); } Int SubSmootherNodeSweeps = dataFile ( (section + "/" + subSection + "/subsmoother/node_sweeps").data(), 2, found ); if ( found ) { list.set ( "subsmoother: node sweeps", SubSmootherNodeSweeps ); } // Coarsest Grid Parameters Int CoarseMaxSize = dataFile ( (section + "/" + subSection + "/coarse/max_size").data(), 128, found ); if ( found ) { list.set ( "coarse: max size", CoarseMaxSize ); } std::string CoarseType = dataFile ( (section + "/" + subSection + "/coarse/type").data(), "Chebyshev", found ); if ( found ) { list.set ( "coarse: type", CoarseType ); } std::string CoarsePreOrPost = dataFile ( (section + "/" + subSection + "/coarse/pre_or_post").data(), "post", found ); if ( found ) { list.set ( "coarse: pre or post", CoarsePreOrPost ); } Int CoarseSweeps = dataFile ( (section + "/" + subSection + "/coarse/sweeps").data(), 2, found ); if ( found ) { list.set ( "coarse: sweeps", CoarseSweeps ); } Real CoarseDampingFactor = dataFile ( (section + "/" + subSection + "/coarse/damping_factor").data(), 1.0, found ); if ( found ) { list.set ( "coarse: damping factor", CoarseDampingFactor ); } std::string CoarseSubsmootherType = dataFile ( (section + "/" + subSection + "/coarse/subsmoother_type").data(), "Chebyshev", found ); if ( found ) { list.set ( "coarse: subsmoother type", CoarseSubsmootherType ); } Int CoarseNodeSweeps = dataFile ( (section + "/" + subSection + "/coarse/node_sweeps").data(), 2, found ); if ( found ) { list.set ( "coarse: node sweeps", CoarseNodeSweeps ); } Int CoarseEdgeSweeps = dataFile ( (section + "/" + subSection + "/coarse/edge_sweeps").data(), 2, found ); if ( found ) { list.set ( "coarse: edge sweeps", CoarseEdgeSweeps ); } Real CoarseChebyshevAlpha = dataFile ( (section + "/" + subSection + "/coarse/Chebyshev_alpha").data(), 30., found ); if ( found ) { list.set ( "coarse: Chebyshev alpha", CoarseChebyshevAlpha ); } Int CoarseMaxProcesses = dataFile ( (section + "/" + subSection + "/coarse/max_processes").data(), -1, found ); if ( found ) { list.set ( "coarse: max processes", CoarseMaxProcesses ); } // Load-balancing Options Int RepartitionEnable = dataFile ( (section + "/" + subSection + "/repartition/enable").data(), 0, found ); if ( found ) { list.set ( "repartition: enable", RepartitionEnable ); } std::string RepartitionPartitioner = dataFile ( (section + "/" + subSection + "/repartition/partitioner").data(), "ParMETIS", found ); if ( found ) { list.set ( "repartition: partitioner", RepartitionPartitioner ); } Real RepartitionMaxMinRatio = dataFile ( (section + "/" + subSection + "/repartition/max_min_ratio").data(), 1.3, found ); if ( found ) { list.set ( "repartition: max min ratio", RepartitionMaxMinRatio ); } Int RepartitionMinPerProc = dataFile ( (section + "/" + subSection + "/repartition/min_per_proc").data(), 512, found ); if ( found ) { list.set ( "repartition: min per proc", RepartitionMinPerProc ); } Real RepartitionNodeMaxMinRatio = dataFile ( (section + "/" + subSection + "/repartition/node_max_min_ratio").data(), 1.3, found ); if ( found ) { list.set ( "repartition: node max min ratio", RepartitionNodeMaxMinRatio ); } Int RepartitionNodeMinPerProc = dataFile ( (section + "/" + subSection + "/repartition/node_min_per_proc").data(), 170, found ); if ( found ) { list.set ( "repartition: node min per proc", RepartitionNodeMinPerProc ); } Int RepartitionZoltanDimensions = dataFile ( (section + "/" + subSection + "/repartition/Zoltan_dimensions").data(), 2, found ); if ( found ) { list.set ( "repartition: Zoltan dimensions", RepartitionZoltanDimensions ); } if ( MLPrintParameterList && verbose ) { std::cout << "ML parameters list:" << std::endl; std::cout << "-----------------------------" << std::endl; list.print ( std::cout ); std::cout << "-----------------------------" << std::endl; } }
void setParameters (list_Type& list) { M_startingTimeStimulus = list.get ("starting_time_stimulus", 0.0); M_tShortS1S1 = list.get ("tShortS1S1", 0.001); M_stimulusInterval = list.get ("stimulus_interval", 0.0 ); this->setStIntMin ( list.get ("stIntMin", 0.001) ); this->setStIntS1S2 ( list.get ("stIntS1S2", 0.0) ); this->setStIntS1S2Min ( list.get ("stIntS1S2Min", 10.0) ); this->setStIntS2S3 ( list.get ("stIntS2S3", 0.01) ); this->setStIntS3S4 ( list.get ("stIntS3S4", 0.01) ); M_nbStimMax = list.get ("nbStimMax", 1); this->setRepeatSt ( list.get ("repeatSt", 1) ); this->setTimeStep ( list.get ("dt", 0.01) ); this->setPacingProtocol ( list.get ("pacPro", "FCL-ExtraSt") ); this->setPacingProtocolType ( list.get ("pacProType", "S1-S2") ); M_stimulusDuration = list.get ("duration_stimulus", 1.0 ); M_pacingSite_X = list.get ( "pacing_site_X", 1.0 ); M_pacingSite_Y = list.get ( "pacing_site_Y", 1.0 ); M_pacingSite_Z = list.get ( "pacing_site_Z", 1.0 ); M_radius = list.get ( "applied_current_radius", 0.2 ); M_stimulusAmplitude = list.get ( "stimulus_amplitude", 1.0 ); }
void PreconditionerIfpack::createIfpackList( list_Type& list, const GetPot& dataFile, const std::string& section, const std::string& subSection, const bool& verbose ) { // See http://trilinos.sandia.gov/packages/docs/r9.0/packages/ifpack/doc/html/index.html // for more informations on the parameters Int overlapLevel = dataFile( (section + "/" + subSection + "/overlap").data(), 0 ); std::string precType = dataFile( (section + "/" + subSection + "/prectype").data(), "Amesos" ); list.set( "prectype", precType ); list.set( "overlap level", overlapLevel ); bool displayList = dataFile( (section + "/displayList").data(), false ); std::string relaxationType = dataFile( (section + "/" + subSection + "/relaxation/type").data(), "Jacobi" ); Int relaxationSweeps = dataFile( (section + "/" + subSection + "/relaxation/sweeps").data(), 1 ); Real relaxationDampingFactor = dataFile( (section + "/" + subSection + "/relaxation/damping_factor").data(), 1.0 ); Real relaxationMinDiagValue = dataFile( (section + "/" + subSection + "/relaxation/min_diagonal_value").data(), 0.0 ); bool relaxationZeroStartSolution = dataFile( (section + "/" + subSection + "/relaxation/zero_starting_solution").data(), true ); list.set( "relaxation: type", relaxationType ); list.set( "relaxation: sweeps", relaxationSweeps ); list.set( "relaxation: damping factor", relaxationDampingFactor ); list.set( "relaxation: min diagonal value", relaxationMinDiagValue ); list.set( "relaxation: zero starting solution", relaxationZeroStartSolution ); std::string partitionerType = dataFile( (section + "/" + subSection + "/partitioner/type").data(), "metis" ); Int partitionerOverlap = dataFile( (section + "/" + subSection + "/partitioner/overlap").data(), 0 ); Int partitionerLocalParts = dataFile( (section + "/" + subSection + "/partitioner/local_parts").data(), 1 ); Int partitionerRootNode = dataFile( (section + "/" + subSection + "/partitioner/root_node").data(), 0 ); bool partitionerUseSymmGraph = dataFile( (section + "/" + subSection + "/partitioner/use_symmetric_graph").data(), true ); list.set( "partitioner: type", partitionerType ); list.set( "partitioner: overlap", partitionerOverlap ); list.set( "partitioner: local parts", partitionerLocalParts ); list.set( "partitioner: root node", partitionerRootNode ); list.set( "partitioner: use symmetric graph", partitionerUseSymmGraph ); std::string amesosSolverType = dataFile( (section + "/" + subSection + "/amesos/solvertype").data(), "Amesos_KLU" ); list.set( "amesos: solver type", amesosSolverType ); Int levelOfFill = dataFile( (section + "/" + subSection + "/fact/level-of-fill").data(), 4 ); Real ILUTlevelOfFill = dataFile( (section + "/" + subSection + "/fact/ilut_level-of-fill").data(), 4. ); Real athr = dataFile( (section + "/" + subSection + "/fact/absolute_threshold").data(), 0. ); Real rthr = dataFile( (section + "/" + subSection + "/fact/relative_threshold").data(), 1. ); Real relaxValue = dataFile( (section + "/" + subSection + "/fact/relax_value").data(), 0. ); Real dropTolerance = dataFile( (section + "/" + subSection + "/fact/drop_tolerance").data(), 1e-5 ); list.set( "fact: drop tolerance", dropTolerance ); list.set( "fact: level-of-fill", levelOfFill ); list.set( "fact: ilut level-of-fill", ILUTlevelOfFill ); list.set( "fact: absolute threshold", athr ); list.set( "fact: relative threshold", rthr ); list.set( "fact: relax value", relaxValue ); Int combineMode = dataFile( (section + "/" + subSection + "/schwarz/combine_mode").data(), 0 ); Epetra_CombineMode schwarzCombineMode; switch (combineMode) { case 0 : schwarzCombineMode = Add; break; case 1 : schwarzCombineMode = Zero; break; case 2 : schwarzCombineMode = Insert; break; case 3 : schwarzCombineMode = Average; break; case 4 : schwarzCombineMode = AbsMax; break; default: schwarzCombineMode = Zero; } bool schwarzComputeCondest = dataFile( (section + "/" + subSection + "/schwarz/compute_condest").data(), true ); std::string schwarzReorderingType = dataFile( (section + "/" + subSection + "/schwarz/reordering_type").data(), "none" ); bool schwarzFilterSingletons = dataFile( (section + "/" + subSection + "/schwarz/filter_singletons").data(), true ); list.set( "schwarz: combine mode", schwarzCombineMode); list.set( "schwarz: compute condest", schwarzComputeCondest); list.set( "schwarz: reordering type", schwarzReorderingType); list.set( "schwarz: filter singletons", schwarzFilterSingletons); if ( displayList && verbose ) { std::cout << "Ifpack parameters list:" << std::endl; std::cout << "-----------------------------" << std::endl; list.print( std::cout ); std::cout << "-----------------------------" << std::endl; } }