[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)
