[0, [1, True, True], multiplyByScalar_Task]], 'costEstimatorsForPredictor': [1, True, False], 'costPredictor': costPredictor, 'errorEstimators': [MSEErrorEstimator], 'assemblersForError': [[1, 2]], 'isCostUpdated': True } mcSampler = xmc.monteCarloSampler.MonteCarloSampler(**inputDict) # XMCAlgorithm inputDict = { 'monteCarloSampler': mcSampler, 'hierarchyOptimiser': hierarchyCostOptimiser, 'stoppingCriterion': criterion, 'errorsForStoppingCriterion': [0], 'predictorsForHierarchy': [0, 1], 'costPredictorForHierarchy': [1, True, False], 'estimatorsForHierarchy': [[0, [1, True, False]], [0, [1, True, True]]], 'costEstimatorForHierarchy': [1, True, False], 'tolerancesForHierarchy': [0], 'errorParametersForHierarchy': [0], } algo = xmc.XMCAlgorithm(**inputDict) algo.runXMC()
monteCarloSamplerInputDictionary[ "indexConstructorDictionary"] = monteCarloIndexInputDictionary monteCarloSamplerInputDictionary["assemblers"] = [ expectationAssembler, varianceAssembler ] monteCarloSamplerInputDictionary["errorEstimators"] = [statErrorEstimator] mcSampler = xmc.monteCarloSampler.MonteCarloSampler( **monteCarloSamplerInputDictionary) # XMCAlgorithm XMCAlgorithmInputDictionary = parameters["XMCAlgorithmInputDictionary"] XMCAlgorithmInputDictionary["monteCarloSampler"] = mcSampler XMCAlgorithmInputDictionary["hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDictionary["stoppingCriterion"] = criterion algo = xmc.XMCAlgorithm(**XMCAlgorithmInputDictionary) if (parameters["solverWrapperInputDictionary"]["asynchronous"] is True): algo.runAsynchronousXMC() else: algo.runXMC() ######################################################################################################################################################################################################## ######################################################################################################################################################################################################## ######################################################################################################################################################################################################## # from exaqute.ExaquteTaskPyCOMPSs import * # to execute with runcompss # import xmc.methodDefs_momentEstimator.computeCentralMoments as mdccm # # writing to file a dictionary # qoi_dict = {}
def test_mc_asynchronous_Kratos(self): # read parameters parametersList = ["parameters/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d.json", \ "parameters/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d_with_combined_power_sums.json", \ "parameters/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d_with_10_combined_power_sums.json", \ "parameters/parameters_xmc_test_mc_Kratos_poisson_2d.json", \ "parameters/parameters_xmc_test_mc_Kratos_poisson_2d_with_combined_power_sums.json"] for parametersPath in parametersList: with open(parametersPath, 'r') as parameter_file: parameters = json.load(parameter_file) # add path of the problem folder to python path problem_id = parameters["solverWrapperInputDictionary"][ "problemId"] sys.path.append(os.path.join("poisson_square_2d_xmc")) # SampleGenerator samplerInputDictionary = parameters["samplerInputDictionary"] samplerInputDictionary[ 'randomGeneratorInputDictionary'] = parameters[ "randomGeneratorInputDictionary"] samplerInputDictionary[ 'solverWrapperInputDictionary'] = parameters[ "solverWrapperInputDictionary"] # MonteCarloIndex monteCarloIndexInputDictionary = parameters[ "monteCarloIndexInputDictionary"] monteCarloIndexInputDictionary[ "samplerInputDictionary"] = samplerInputDictionary # Moment Estimators qoiEstimatorInputDictionary = parameters[ "qoiEstimatorInputDictionary"] combinedEstimatorInputDictionary = parameters[ "combinedEstimatorInputDictionary"] costEstimatorInputDictionary = parameters[ "costEstimatorInputDictionary"] # qoi estimators monteCarloIndexInputDictionary["qoiEstimator"] = [ monteCarloIndexInputDictionary["qoiEstimator"][0] for _ in range( 0, parameters["solverWrapperInputDictionary"]["numberQoI"]) ] monteCarloIndexInputDictionary["qoiEstimatorInputDictionary"] = [ qoiEstimatorInputDictionary ] * parameters["solverWrapperInputDictionary"]["numberQoI"] # combined estimators monteCarloIndexInputDictionary["combinedEstimator"] = [ monteCarloIndexInputDictionary["combinedEstimator"][0] for _ in range( 0, parameters["solverWrapperInputDictionary"] ["numberCombinedQoi"]) ] monteCarloIndexInputDictionary[ "combinedEstimatorInputDictionary"] = [ combinedEstimatorInputDictionary ] * parameters["solverWrapperInputDictionary"][ "numberCombinedQoi"] # cost estimator monteCarloIndexInputDictionary[ "costEstimatorInputDictionary"] = costEstimatorInputDictionary # MonoCriterion criteriaArray = [] criteriaInputs = [] for monoCriterion in (parameters["monoCriteriaInpuctDict"]): criteriaArray.append(xmc.monoCriterion.MonoCriterion(\ parameters["monoCriteriaInpuctDict"][monoCriterion]["criteria"],\ parameters["monoCriteriaInpuctDict"][monoCriterion]["tolerance"])) criteriaInputs.append([ parameters["monoCriteriaInpuctDict"][monoCriterion] ["input"] ]) # MultiCriterion multiCriterionInputDictionary = parameters[ "multiCriterionInputDictionary"] multiCriterionInputDictionary["criteria"] = criteriaArray multiCriterionInputDictionary[ "inputsForCriterion"] = criteriaInputs criterion = xmc.multiCriterion.MultiCriterion( **multiCriterionInputDictionary) # ErrorEstimator statErrorEstimator = xmc.errorEstimator.ErrorEstimator( **parameters["errorEstimatorInputDictionary"]) # HierarchyOptimiser hierarchyCostOptimiser = xmc.hierarchyOptimiser.HierarchyOptimiser( **parameters["hierarchyOptimiserInputDictionary"]) # EstimationAssembler if "expectationAssembler" in parameters[ "estimationAssemblerInputDictionary"].keys(): expectationAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"] ["expectationAssembler"]) if "varianceAssembler" in parameters[ "estimationAssemblerInputDictionary"].keys(): varianceAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"] ["varianceAssembler"]) # MonteCarloSampler monteCarloSamplerInputDictionary = parameters[ "monteCarloSamplerInputDictionary"] monteCarloSamplerInputDictionary[ "indexConstructorDictionary"] = monteCarloIndexInputDictionary monteCarloSamplerInputDictionary["assemblers"] = [ expectationAssembler, varianceAssembler ] monteCarloSamplerInputDictionary["errorEstimators"] = [ statErrorEstimator ] mcSampler = xmc.monteCarloSampler.MonteCarloSampler( **monteCarloSamplerInputDictionary) # XMCAlgorithm XMCAlgorithmInputDictionary = parameters[ "XMCAlgorithmInputDictionary"] XMCAlgorithmInputDictionary["monteCarloSampler"] = mcSampler XMCAlgorithmInputDictionary[ "hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDictionary["stoppingCriterion"] = criterion algo = xmc.XMCAlgorithm(**XMCAlgorithmInputDictionary) if (parameters["solverWrapperInputDictionary"]["asynchronous"] is True): algo.runAsynchronousXMC() else: algo.runXMC() # test estimations = get_value_from_remote(algo.estimation()) estimated_mean = 1.5 self.assertAlmostEqual(estimations[0], estimated_mean, delta=0.1) self.assertEqual( algo.monteCarloSampler.indices[0].costEstimator._sampleCounter, 15)
def test_mc_Kratos(self): if not kratosFound(): self.skipTest("Missing dependency: KratosMultiphysics") # read parameters parametersList = [ "parameters/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d.json", "parameters/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d_with_combined_power_sums.json", "parameters/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d_with_10_combined_power_sums.json", "parameters/parameters_xmc_test_mc_Kratos_poisson_2d.json", "parameters/parameters_xmc_test_mc_Kratos_poisson_2d_with_combined_power_sums.json", "parameters/poisson_multi-moment_mc.json", ] for parametersPath in parametersList: with open(parametersPath, "r") as parameter_file: parameters = json.load(parameter_file) # add path of the problem folder to python path problem_id = parameters["solverWrapperInputDictionary"]["problemId"] sys.path.append(os.path.join("poisson_square_2d")) # SampleGenerator samplerInputDictionary = parameters["samplerInputDictionary"] samplerInputDictionary["randomGeneratorInputDictionary"] = parameters[ "randomGeneratorInputDictionary" ] samplerInputDictionary["solverWrapperInputDictionary"] = parameters[ "solverWrapperInputDictionary" ] # MonteCarloIndex monteCarloIndexInputDictionary = parameters["monteCarloIndexInputDictionary"] monteCarloIndexInputDictionary["samplerInputDictionary"] = samplerInputDictionary # Moment Estimators if "qoiEstimatorInputDictionary" not in monteCarloIndexInputDictionary.keys(): numberMomentEstimator = parameters["solverWrapperInputDictionary"]["numberMomentEstimator"] monteCarloIndexInputDictionary["qoiEstimator"] = [ monteCarloIndexInputDictionary["qoiEstimator"][0] for _ in range(numberMomentEstimator) ] monteCarloIndexInputDictionary["qoiEstimatorInputDictionary"] = [ parameters["qoiEstimatorInputDictionary"] ] * numberMomentEstimator # combined estimators if "combinedEstimator" in monteCarloIndexInputDictionary.keys(): numberCombinedQoI = parameters["solverWrapperInputDictionary"][ "numberCombinedMomentEstimator" ] monteCarloIndexInputDictionary["combinedEstimator"] = [ monteCarloIndexInputDictionary["combinedEstimator"][0] for _ in range(numberCombinedQoI) ] monteCarloIndexInputDictionary["combinedEstimatorInputDictionary"] = [ parameters["combinedEstimatorInputDictionary"] ] * numberCombinedQoI # cost estimator monteCarloIndexInputDictionary["costEstimatorInputDictionary"] = parameters[ "costEstimatorInputDictionary" ] # MonoCriterion criteriaArray = [] criteriaInputs = [] for monoCriterion in parameters["monoCriteriaInpuctDictionary"]: criteriaArray.append( xmc.monoCriterion.MonoCriterion( parameters["monoCriteriaInpuctDictionary"][monoCriterion]["criteria"], parameters["monoCriteriaInpuctDictionary"][monoCriterion]["tolerance"], ) ) criteriaInputs.append( [parameters["monoCriteriaInpuctDictionary"][monoCriterion]["input"]] ) # MultiCriterion multiCriterionInputDictionary = parameters["multiCriterionInputDictionary"] multiCriterionInputDictionary["criteria"] = criteriaArray multiCriterionInputDictionary["inputsForCriterion"] = criteriaInputs criterion = xmc.multiCriterion.MultiCriterion(**multiCriterionInputDictionary) # ErrorEstimator statErrorEstimator = xmc.errorEstimator.ErrorEstimator( **parameters["errorEstimatorInputDictionary"] ) # HierarchyOptimiser hierarchyCostOptimiser = xmc.hierarchyOptimiser.HierarchyOptimiser( **parameters["hierarchyOptimiserInputDictionary"] ) # EstimationAssembler if ( "expectationAssembler" in parameters["estimationAssemblerInputDictionary"].keys() ): expectationAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"]["expectationAssembler"] ) if "varianceAssembler" in parameters["estimationAssemblerInputDictionary"].keys(): varianceAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"]["varianceAssembler"] ) # MonteCarloSampler monteCarloSamplerInputDictionary = parameters["monteCarloSamplerInputDictionary"] monteCarloSamplerInputDictionary[ "indexConstructorDictionary" ] = monteCarloIndexInputDictionary monteCarloSamplerInputDictionary["assemblers"] = [ expectationAssembler, varianceAssembler, ] monteCarloSamplerInputDictionary["errorEstimators"] = [statErrorEstimator] mcSampler = xmc.monteCarloSampler.MonteCarloSampler( **monteCarloSamplerInputDictionary ) # XMCAlgorithm XMCAlgorithmInputDictionary = parameters["XMCAlgorithmInputDictionary"] XMCAlgorithmInputDictionary["monteCarloSampler"] = mcSampler XMCAlgorithmInputDictionary["hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDictionary["stoppingCriterion"] = criterion algo = xmc.XMCAlgorithm(**XMCAlgorithmInputDictionary) if parameters["solverWrapperInputDictionary"]["asynchronous"] is True: algo.runAsynchronousXMC() else: algo.runXMC() # test estimations = get_value_from_remote(algo.estimation()) estimated_mean = 1.5 self.assertAlmostEqual(estimations[0], estimated_mean, delta=0.1) self.assertEqual(algo.hierarchy()[0][1], 15)
def test_mc_Kratos(self): if not isKratosFound(): self.skipTest( "Missing dependency: KratosMultiphysics or one of required applications. Check the test docstrings for details." ) # read parameters parametersList = [ "poisson_square_2d/problem_settings/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d_RFF.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d_with_combined_power_sums.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mc_Kratos_asynchronous_poisson_2d_with_10_combined_power_sums.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mc_Kratos_poisson_2d.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mc_Kratos_poisson_2d_with_combined_power_sums.json", "poisson_square_2d/problem_settings/poisson_multi-moment_mc.json", ] for parametersPath in parametersList: with open(parametersPath, "r") as parameter_file: parameters = json.load(parameter_file) # SolverWrapper parameters["solverWrapperInputDictionary"][ "qoiEstimator"] = parameters["monteCarloIndexInputDictionary"][ "qoiEstimator"] # SampleGenerator samplerInputDictionary = parameters["samplerInputDictionary"] samplerInputDictionary[ "randomGeneratorInputDictionary"] = parameters[ "randomGeneratorInputDictionary"] samplerInputDictionary[ "solverWrapperInputDictionary"] = parameters[ "solverWrapperInputDictionary"] # MonteCarloIndex monteCarloIndexInputDictionary = parameters[ "monteCarloIndexInputDictionary"] monteCarloIndexInputDictionary[ "samplerInputDictionary"] = samplerInputDictionary # MonoCriterion criteriaArray = [] criteriaInputs = [] for monoCriterion in parameters["monoCriteriaInputDictionary"]: criteriaArray.append( xmc.monoCriterion.MonoCriterion( parameters["monoCriteriaInputDictionary"] [monoCriterion]["criteria"], parameters["monoCriteriaInputDictionary"] [monoCriterion]["tolerance"], )) criteriaInputs.append([ parameters["monoCriteriaInputDictionary"][monoCriterion] ["input"] ]) # MultiCriterion multiCriterionInputDictionary = parameters[ "multiCriterionInputDictionary"] multiCriterionInputDictionary["criteria"] = criteriaArray multiCriterionInputDictionary[ "inputsForCriterion"] = criteriaInputs criterion = xmc.multiCriterion.MultiCriterion( **multiCriterionInputDictionary) # ErrorEstimator statErrorEstimator = xmc.errorEstimator.ErrorEstimator( **parameters["errorEstimatorInputDictionary"]) # HierarchyOptimiser hierarchyCostOptimiser = xmc.hierarchyOptimiser.HierarchyOptimiser( **parameters["hierarchyOptimiserInputDictionary"]) # EstimationAssembler if ("expectationAssembler" in parameters["estimationAssemblerInputDictionary"].keys()): expectationAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"] ["expectationAssembler"]) if "varianceAssembler" in parameters[ "estimationAssemblerInputDictionary"].keys(): varianceAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"] ["varianceAssembler"]) # MonteCarloSampler monteCarloSamplerInputDictionary = parameters[ "monteCarloSamplerInputDictionary"] monteCarloSamplerInputDictionary[ "indexConstructorDictionary"] = monteCarloIndexInputDictionary monteCarloSamplerInputDictionary["assemblers"] = [ expectationAssembler, varianceAssembler, ] monteCarloSamplerInputDictionary["errorEstimators"] = [ statErrorEstimator ] mcSampler = xmc.monteCarloSampler.MonteCarloSampler( **monteCarloSamplerInputDictionary) # XMCAlgorithm XMCAlgorithmInputDictionary = parameters[ "XMCAlgorithmInputDictionary"] XMCAlgorithmInputDictionary["monteCarloSampler"] = mcSampler XMCAlgorithmInputDictionary[ "hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDictionary["stoppingCriterion"] = criterion algo = xmc.XMCAlgorithm(**XMCAlgorithmInputDictionary) if parameters["solverWrapperInputDictionary"][ "asynchronous"] is True: algo.runAsynchronousXMC() else: algo.runXMC() # test estimations = get_value_from_remote(algo.estimation()) estimated_mean = 1.5 self.assertAlmostEqual(estimations[0], estimated_mean, delta=0.1) self.assertEqual(algo.hierarchy()[0][1], 15)
def mpi_test_mlmc_Kratos_ParMmg(self): # read parameters parametersList = [ "problem_settings/parameters_xmc_asynchronous_mlmc_SAR.json", "problem_settings/parameters_xmc_asynchronous_mlmc_DAR.json", ] with WorkFolderScope("caarc_wind_mpi/", __file__, add_to_path=True): for parametersPath in parametersList: with open(parametersPath, "r") as parameter_file: parameters = json.load(parameter_file) # SolverWrapper parameters["solverWrapperInputDictionary"][ "qoiEstimator"] = parameters[ "monteCarloIndexInputDictionary"]["qoiEstimator"] # SampleGenerator samplerInputDictionary = parameters["samplerInputDictionary"] samplerInputDictionary[ "randomGeneratorInputDictionary"] = parameters[ "randomGeneratorInputDictionary"] samplerInputDictionary[ "solverWrapperInputDictionary"] = parameters[ "solverWrapperInputDictionary"] # MonteCarloIndex Constructor monteCarloIndexInputDictionary = parameters[ "monteCarloIndexInputDictionary"] monteCarloIndexInputDictionary[ "samplerInputDictionary"] = samplerInputDictionary # MonoCriterion criteriaArray = [] criteriaInputs = [] for monoCriterion in parameters["monoCriteriaInputDictionary"]: criteriaArray.append( xmc.monoCriterion.MonoCriterion( parameters["monoCriteriaInputDictionary"] [monoCriterion]["criteria"], parameters["monoCriteriaInputDictionary"] [monoCriterion]["tolerance"], )) criteriaInputs.append([ parameters["monoCriteriaInputDictionary"] [monoCriterion]["input"] ]) # MultiCriterion multiCriterionInputDictionary = parameters[ "multiCriterionInputDictionary"] multiCriterionInputDictionary["criteria"] = criteriaArray multiCriterionInputDictionary[ "inputsForCriterion"] = criteriaInputs criterion = xmc.multiCriterion.MultiCriterion( **multiCriterionInputDictionary) # ErrorEstimator MSEErrorEstimator = xmc.errorEstimator.ErrorEstimator( **parameters["errorEstimatorInputDictionary"]) # HierarchyOptimiser hierarchyCostOptimiser = xmc.hierarchyOptimiser.HierarchyOptimiser( **parameters["hierarchyOptimiserInputDictionary"]) # MonteCarloSampler monteCarloSamplerInputDictionary = parameters[ "monteCarloSamplerInputDictionary"] monteCarloSamplerInputDictionary[ "indexConstructorDictionary"] = monteCarloIndexInputDictionary monteCarloSamplerInputDictionary["errorEstimators"] = [ MSEErrorEstimator ] # EstimationAssembler monteCarloSamplerInputDictionary["assemblers"] = [] for key, dicArgs in parameters[ "estimationAssemblerInputDictionary"].items(): monteCarloSamplerInputDictionary["assemblers"].append( xmc.estimationAssembler.EstimationAssembler(**dicArgs)) mcSampler = xmc.monteCarloSampler.MonteCarloSampler( **monteCarloSamplerInputDictionary) # XMCAlgorithm XMCAlgorithmInputDictionary = parameters[ "XMCAlgorithmInputDictionary"] XMCAlgorithmInputDictionary["monteCarloSampler"] = mcSampler XMCAlgorithmInputDictionary[ "hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDictionary["stoppingCriterion"] = criterion algo = xmc.XMCAlgorithm(**XMCAlgorithmInputDictionary) if parameters["solverWrapperInputDictionary"][ "asynchronous"] is True: algo.runAsynchronousXMC() else: algo.runXMC() # test # such results are not accurate, since we run the problem for few decimals # and coarse meshes instead of hundreds of seconds and finer meshes estimations = get_value_from_remote(algo.estimation()) self.assertGreater(sum(estimations), 0) for level in algo.hierarchy(): self.assertEqual(level[1], 5) # check moment estimator - level 0 sample_counter = (algo.monteCarloSampler.indices[0]. qoiEstimator[0]._sampleCounter) S1 = get_value_from_remote(algo.monteCarloSampler.indices[0]. qoiEstimator[0].powerSums[0][0]) h1 = get_value_from_remote( ccm.computeCentralMomentsOrderOneDimensionZero( S1, sample_counter)) self.assertGreater(-h1, 0) self.assertEqual(sample_counter, 5) # check multi moment estimator - level 1 sample_counter = (algo.monteCarloSampler.indices[1]. qoiEstimator[1]._sampleCounter) self.assertEqual(sample_counter, 5) # check combined moment estimator - level 2 sample_counter = (algo.monteCarloSampler.indices[2]. qoiEstimator[2]._sampleCounter) S1 = get_value_from_remote(algo.monteCarloSampler.indices[2]. qoiEstimator[2].powerSums[0][0]) h1 = get_value_from_remote( ccm.computeCentralMomentsOrderOneDimensionZero( S1, sample_counter)) self.assertEqual(sample_counter, 5) # check multi combined moment estimator - level 2 sample_counter = (algo.monteCarloSampler.indices[2]. qoiEstimator[3]._sampleCounter) self.assertEqual(sample_counter, 5)
def test_mlmc_asynchronous_Kratos(self): # read parameters parametersList = ["parameters/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d.json", \ "parameters/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d_with_combined_power_sums.json", \ "parameters/parameters_xmc_test_mlmc_Kratos_poisson_2d.json", \ "parameters/parameters_xmc_test_mlmc_Kratos_poisson_2d_with_combined_power_sums.json"] for parametersPath in parametersList: with open(parametersPath, 'r') as parameter_file: parameters = json.load(parameter_file) # add path of the problem folder to python path problem_id = parameters["solverWrapperInputDict"]["problemId"] sys.path.append(os.path.join("poisson_square_2d_xmc")) # RandomGeneratorWrapper randomGeneratorInputDict = parameters["randomGeneratorInputDict"] # SolverWrapper solverWrapperInputDict = parameters["solverWrapperInputDict"] # SampleGenerator samplerInputDict = parameters["samplerInputDict"] samplerInputDict[ 'randomGeneratorInputDict'] = randomGeneratorInputDict samplerInputDict['solverWrapperInputDict'] = solverWrapperInputDict # Moment Estimators qoiEstimatorInputDict = parameters["qoiEstimatorInputDict"] combinedEstimatorInputDict = parameters[ "combinedEstimatorInputDict"] costEstimatorInputDict = parameters["costEstimatorInputDict"] # MonteCarloIndex Constructor monteCarloIndexInputDict = parameters["monteCarloIndexInputDict"] monteCarloIndexInputDict["samplerInputDict"] = samplerInputDict # qoi estimators monteCarloIndexInputDict["qoiEstimator"] = [ monteCarloIndexInputDict["qoiEstimator"][0] for _ in range( 0, parameters["solverWrapperInputDict"]["numberQoI"]) ] monteCarloIndexInputDict["qoiEstimatorInputDict"] = [ qoiEstimatorInputDict ] * parameters["solverWrapperInputDict"]["numberQoI"] # combined estimators monteCarloIndexInputDict["combinedEstimator"] = [ monteCarloIndexInputDict["combinedEstimator"][0] for _ in range( 0, parameters["solverWrapperInputDict"] ["numberCombinedQoi"]) ] monteCarloIndexInputDict["combinedEstimatorInputDict"] = [ combinedEstimatorInputDict ] * parameters["solverWrapperInputDict"]["numberCombinedQoi"] # cost estimator monteCarloIndexInputDict[ "costEstimatorInputDict"] = costEstimatorInputDict ################################# RUN TIME GENERATED ENTITIES END HERE ####################### # MonoCriterion criteriaArray = [] criteriaInputs = [] for monoCriterion in (parameters["monoCriteriaInpuctDict"]): criteriaArray.append(xmc.monoCriterion.MonoCriterion(\ parameters["monoCriteriaInpuctDict"][monoCriterion]["criteria"],\ parameters["monoCriteriaInpuctDict"][monoCriterion]["tolerance"])) criteriaInputs.append([ parameters["monoCriteriaInpuctDict"][monoCriterion] ["input"] ]) # MultiCriterion criterion = xmc.multiCriterion.MultiCriterion( criteria=criteriaArray, inputsForCriterion=criteriaInputs, interpreter= 'xmc.methodDefs_multiCriterion.interpreter.interpretAsConvergenceAndIterationBounds', flag='xmc.methodDefs_multiCriterion.flag.plainFlag') # ErrorEstimator MSEErrorEstimator = xmc.errorEstimator.ErrorEstimator( error= 'xmc.methodDefs_errorEstimator.errorEstimation.errorEstimationMSE_Task', parameters=[0.95]) # HierarchyOptimiser hierarchyOptimiserInputDict = parameters[ "hierarchyOptimiserInputDict"] hierarchyCostOptimiser = xmc.hierarchyOptimiser.HierarchyOptimiser( **hierarchyOptimiserInputDict) # EstimationAssembler expectationAssembler = xmc.estimationAssembler.EstimationAssembler( assembleEstimation= 'xmc.methodDefs_estimationAssembler.assembleEstimation.assembleValue_Task' ) biasAssembler = xmc.estimationAssembler.EstimationAssembler( assembleEstimation= 'xmc.methodDefs_estimationAssembler.assembleEstimation.assembleBias_Task' ) varianceAssembler = xmc.estimationAssembler.EstimationAssembler( assembleEstimation= 'xmc.methodDefs_estimationAssembler.assembleEstimation.assembleStatisticalError_Task' ) # MonteCarloSampler monteCarloSamplerInputDict = parameters[ "monteCarloSamplerInputDict"] monteCarloSamplerInputDict[ "indexConstructorDictionary"] = monteCarloIndexInputDict monteCarloSamplerInputDict["assemblers"] = [ expectationAssembler, biasAssembler, varianceAssembler ] monteCarloSamplerInputDict["errorEstimators"] = [MSEErrorEstimator] mcSampler = xmc.monteCarloSampler.MonteCarloSampler( **monteCarloSamplerInputDict) # XMCAlgorithm XMCAlgorithmInputDict = parameters["XMCAlgorithmInputDict"] XMCAlgorithmInputDict["monteCarloSampler"] = mcSampler XMCAlgorithmInputDict[ "hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDict["stoppingCriterion"] = criterion algo = xmc.XMCAlgorithm(**XMCAlgorithmInputDict) # run if (parameters["solverWrapperInputDict"]["asynchronous"] is True): algo.runAsynchronousXMC() else: algo.runXMC() # test estimations = algo.estimation() estimated_mean = 1.47 self.assertAlmostEqual(estimations[0], estimated_mean, delta=1.0) self.assertEqual( algo.monteCarloSampler.indices[0].costEstimator._sampleCounter, 15) # level 0 self.assertEqual( algo.monteCarloSampler.indices[1].costEstimator._sampleCounter, 15) # level 1 self.assertEqual( algo.monteCarloSampler.indices[2].costEstimator._sampleCounter, 15) # level 2
def _RunXMC(self): # read parameters with open(self.xmc_settings_path,'r') as parameter_file: parameters = json.load(parameter_file) # SolverWrapper parameters["solverWrapperInputDictionary"]["qoiEstimator"] = parameters["monteCarloIndexInputDictionary"]["qoiEstimator"] # SampleGenerator samplerInputDictionary = parameters["samplerInputDictionary"] samplerInputDictionary['randomGeneratorInputDictionary'] = parameters["randomGeneratorInputDictionary"] samplerInputDictionary['solverWrapperInputDictionary'] = parameters["solverWrapperInputDictionary"] # MonteCarloIndex monteCarloIndexInputDictionary = parameters["monteCarloIndexInputDictionary"] monteCarloIndexInputDictionary["samplerInputDictionary"] = samplerInputDictionary # MonoCriterion criteriaArray = [] criteriaInputs = [] for monoCriterion in (parameters["monoCriteriaInpuctDictionary"]): criteriaArray.append(xmc.monoCriterion.MonoCriterion(\ parameters["monoCriteriaInpuctDictionary"][monoCriterion]["criteria"],\ parameters["monoCriteriaInpuctDictionary"][monoCriterion]["tolerance"])) criteriaInputs.append([parameters["monoCriteriaInpuctDictionary"][monoCriterion]["input"]]) # MultiCriterion multiCriterionInputDictionary=parameters["multiCriterionInputDictionary"] multiCriterionInputDictionary["criteria"] = criteriaArray multiCriterionInputDictionary["inputsForCriterion"] = criteriaInputs criterion = xmc.multiCriterion.MultiCriterion(**multiCriterionInputDictionary) # ErrorEstimator errorEstimator = xmc.errorEstimator.ErrorEstimator(**parameters["errorEstimatorInputDictionary"]) # HierarchyOptimiser hierarchyCostOptimiser = xmc.hierarchyOptimiser.HierarchyOptimiser(**parameters["hierarchyOptimiserInputDictionary"]) # EstimationAssembler assemblers = [] if "expectationAssembler" in parameters["estimationAssemblerInputDictionary"].keys(): expectationAssembler = xmc.estimationAssembler.EstimationAssembler(**parameters["estimationAssemblerInputDictionary"]["expectationAssembler"]) assemblers.append(expectationAssembler) if "discretizationErrorAssembler" in parameters["estimationAssemblerInputDictionary"].keys(): discretizationErrorAssembler = xmc.estimationAssembler.EstimationAssembler(**parameters["estimationAssemblerInputDictionary"]["discretizationErrorAssembler"]) assemblers.append(discretizationErrorAssembler) if "varianceAssembler" in parameters["estimationAssemblerInputDictionary"].keys(): varianceAssembler = xmc.estimationAssembler.EstimationAssembler(**parameters["estimationAssemblerInputDictionary"]["varianceAssembler"]) assemblers.append(varianceAssembler) # MonteCarloSampler monteCarloSamplerInputDictionary = parameters["monteCarloSamplerInputDictionary"] monteCarloSamplerInputDictionary["indexConstructorDictionary"] = monteCarloIndexInputDictionary monteCarloSamplerInputDictionary["assemblers"] = assemblers monteCarloSamplerInputDictionary["errorEstimators"] = [errorEstimator] mcSampler = xmc.monteCarloSampler.MonteCarloSampler(**monteCarloSamplerInputDictionary) # XMCAlgorithm XMCAlgorithmInputDictionary = parameters["XMCAlgorithmInputDictionary"] XMCAlgorithmInputDictionary["monteCarloSampler"] = mcSampler XMCAlgorithmInputDictionary["hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDictionary["stoppingCriterion"] = criterion self.xmc_analysis = xmc.XMCAlgorithm(**XMCAlgorithmInputDictionary) if (parameters["solverWrapperInputDictionary"]["asynchronous"] is True): self.xmc_analysis.runAsynchronousXMC() else: self.xmc_analysis.runXMC()
def test_mlmc_Kratos(self): if not isKratosFound(): self.skipTest("Missing dependency: KratosMultiphysics or one of its applications") if not isMmgFound(): self.skipTest( "Missing dependency: KratosMultiphysics.MeshingApplication with MMG support" ) # read parameters parametersList = [ "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d_with_combined_power_sums.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_poisson_2d.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_poisson_2d_with_combined_power_sums.json", "poisson_square_2d/problem_settings/poisson_multi-moment_mlmc.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d_with_combined_power_sums_multi.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d_with_combined_power_sums_multi_ensemble.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d_DAR.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_asynchronous_poisson_2d_fixedsamples.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_asynchronous_adaptivefixednumberlevels_poisson_2d.json", "poisson_square_2d/problem_settings/parameters_xmc_test_mlmc_Kratos_adaptivefixednumberlevels_poisson_2d.json" ] for parametersPath in parametersList: # read parameters with open(parametersPath, "r") as parameter_file: parameters = json.load(parameter_file) # SolverWrapper parameters["solverWrapperInputDictionary"]["qoiEstimator"] = parameters[ "monteCarloIndexInputDictionary" ]["qoiEstimator"] # SampleGenerator samplerInputDictionary = parameters["samplerInputDictionary"] samplerInputDictionary["randomGeneratorInputDictionary"] = parameters[ "randomGeneratorInputDictionary" ] samplerInputDictionary["solverWrapperInputDictionary"] = parameters[ "solverWrapperInputDictionary" ] # MonteCarloIndex Constructor monteCarloIndexInputDictionary = parameters["monteCarloIndexInputDictionary"] monteCarloIndexInputDictionary["samplerInputDictionary"] = samplerInputDictionary # MonoCriterion criteriaArray = [] criteriaInputs = [] for monoCriterion in parameters["monoCriteriaInputDictionary"]: criteriaArray.append( xmc.monoCriterion.MonoCriterion( parameters["monoCriteriaInputDictionary"][monoCriterion]["criteria"], parameters["monoCriteriaInputDictionary"][monoCriterion]["tolerance"], ) ) criteriaInputs.append( [parameters["monoCriteriaInputDictionary"][monoCriterion]["input"]] ) # MultiCriterion multiCriterionInputDictionary = parameters["multiCriterionInputDictionary"] multiCriterionInputDictionary["criteria"] = criteriaArray multiCriterionInputDictionary["inputsForCriterion"] = criteriaInputs criterion = xmc.multiCriterion.MultiCriterion(**multiCriterionInputDictionary) # ErrorEstimator MSEErrorEstimator = xmc.errorEstimator.ErrorEstimator( **parameters["errorEstimatorInputDictionary"] ) # HierarchyOptimiser # Set tolerance from stopping criterion parameters["hierarchyOptimiserInputDictionary"]["tolerance"] = parameters["monoCriteriaInputDictionary"]["statisticalError"]["tolerance"] hierarchyCostOptimiser = xmc.hierarchyOptimiser.HierarchyOptimiser( **parameters["hierarchyOptimiserInputDictionary"] ) # EstimationAssembler if ( "expectationAssembler" in parameters["estimationAssemblerInputDictionary"].keys() ): expectationAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"]["expectationAssembler"] ) if ( "discretizationErrorAssembler" in parameters["estimationAssemblerInputDictionary"].keys() ): discretizationErrorAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"][ "discretizationErrorAssembler" ] ) if "varianceAssembler" in parameters["estimationAssemblerInputDictionary"].keys(): varianceAssembler = xmc.estimationAssembler.EstimationAssembler( **parameters["estimationAssemblerInputDictionary"]["varianceAssembler"] ) # MonteCarloSampler monteCarloSamplerInputDictionary = parameters["monteCarloSamplerInputDictionary"] monteCarloSamplerInputDictionary[ "indexConstructorDictionary" ] = monteCarloIndexInputDictionary monteCarloSamplerInputDictionary["assemblers"] = [ expectationAssembler, discretizationErrorAssembler, varianceAssembler, ] monteCarloSamplerInputDictionary["errorEstimators"] = [MSEErrorEstimator] # build Monte Carlo sampler object mcSampler = xmc.monteCarloSampler.MonteCarloSampler( **monteCarloSamplerInputDictionary ) # XMCAlgorithm XMCAlgorithmInputDictionary = parameters["XMCAlgorithmInputDictionary"] XMCAlgorithmInputDictionary["monteCarloSampler"] = mcSampler XMCAlgorithmInputDictionary["hierarchyOptimiser"] = hierarchyCostOptimiser XMCAlgorithmInputDictionary["stoppingCriterion"] = criterion algo = xmc.XMCAlgorithm(**XMCAlgorithmInputDictionary) if parameters["solverWrapperInputDictionary"]["asynchronous"] is True: algo.runAsynchronousXMC() else: algo.runXMC() # test estimations = get_value_from_remote(algo.estimation()) estimated_mean = 1.47 self.assertAlmostEqual(estimations[0], estimated_mean, delta=1.0) if "asynchronous_adaptivefixednumberlevels" in parametersPath: self.assertAlmostEqual(sum(estimations), 1.5285582403120515, delta=parameters["monoCriteriaInputDictionary"]["statisticalError"]["tolerance"][0]) # self.assertEqual(sum(algo.hierarchy()[i][-1] for i in range (0,len(algo.hierarchy()))), 194) # uncomment once issue #62 is solved elif "adaptivefixednumberlevels" in parametersPath: self.assertAlmostEqual(sum(estimations), 1.528129424481246, delta=parameters["monoCriteriaInputDictionary"]["statisticalError"]["tolerance"][0]) # self.assertEqual(sum(algo.hierarchy()[i][-1] for i in range (0,len(algo.hierarchy()))), 122) # uncomment once issue #62 is solved else: for level in algo.hierarchy(): self.assertEqual(level[1], 15)