def __init__(self, **keywordArgs):
#TODO - think of a better way to do data dumps and output
self.isDataDumped = keywordArgs.get('isDataDumped', False)
self.outputFolderPath = keywordArgs.get('outputFolderPath', None)
# Attributes
self.monteCarloSampler = keywordArgs.get('monteCarloSampler')
self.hierarchyOptimiser = keywordArgs.get('hierarchyOptimiser')
self.stoppingCriterion = keywordArgs.get('stoppingCriterion')
self.errorsForStoppingCriterion = keywordArgs.get(
'errorForStoppingCriterion', None)
self.predictorsForHierarchy = keywordArgs.get('predictorsForHierarchy',
None)
self.estimatorsForHierarchy = keywordArgs.get('estimatorsForHierarchy',
None)
self.tolerancesForHierarchy = keywordArgs.get('tolerancesForHierarchy',
None)
self.errorParametersForHierarchy = keywordArgs.get(
'errorParametersForHierarchy', None)
self.costPredictorForHierarchy = keywordArgs.get(
'costPredictorForHierarchy', None)
self.costEstimatorForHierarchy = keywordArgs.get(
'costEstimatorForHierarchy', None)
self.positionMaxNumberIterationsCriterion = keywordArgs.get(
'positionMaxNumberIterationsCriterion', None)
self.iterationCounter = 0
# Methods
self.checkInitialisation = dynamicImport(
keywordArgs.get('checkInitialisation', 'xmc.tools.doNothing'))
def __init__(self, **keywordArgs):
super().__init__(**keywordArgs)
self.analysis = dynamicImport(
keywordArgs.get(
"analysisStage",
("xmc.classDefs_solverWrapper.methodDefs_KratosSolverWrapper"
".simulation_definition.SimulationScenario")))
self.adaptive_refinement_jump_to_finest_level = keywordArgs.get(
"adaptiveRefinementJumpToFinestLevel", False)
self.asynchronous = keywordArgs.get("asynchronous", False)
self.different_tasks = not keywordArgs.get("taskAllAtOnce", True)
self.fake_sample_to_serialize = keywordArgs.get("fakeRandomVariable")
self.mapping_output_quantities = keywordArgs.get(
"mappingOutputQuantities", False)
self.is_mpi = keywordArgs.get("isMpi", False)
self.number_contributions_per_instance = keywordArgs.get(
"numberContributionsPerInstance", 1)
self.outputBatchSize = keywordArgs.get("outputBatchSize", 1)
self.print_to_file = keywordArgs.get("printToFile", False)
self.project_parameters_path = keywordArgs.get("projectParametersPath")
self.qoi_estimator = keywordArgs.get("qoiEstimator")
self.refinement_parameters_path = keywordArgs.get(
"refinementParametersPath")
self.refinement_strategy = keywordArgs.get("refinementStrategy")
self.size_multi_x_moment_estimator = keywordArgs.get(
"sizeMultiXMomentEstimator",
-1) # remove after returnZeroQoiAndTime_Task is removed
# Set outputDimension
self.outputDimension = keywordArgs.get("outputDimension", None)
# If not given, compute from self.outputBatchSize for backward compatibility
if self.outputDimension is None:
outputNb = self._numberOfOutputs()
# Total number of output splits, including (possibly) a last one of smaller size
batchNb = int(math.ceil(outputNb / self.outputBatchSize))
# Assemble the list of sizes of each split
# They are all equal to outputBatchSize, except perhaps the last one
# E.g. outputBatchSize=2 and outputNb=5 gives [2,2,1]
self.outputDimension = [
min(self.outputBatchSize, outputNb - i * self.outputBatchSize)
for i in range(batchNb)
]
# workaround for Monte Carlo
if (self.solverWrapperIndex == []):
if self.refinement_strategy is not "reading_from_file":
msg = self.__class__.__name__
msg += ": Running a single-level Monte Carlo algorithm. "
msg += "Default \"refinementStrategy\" is \"reading_from_file\". "
msg += "Running with {} instead. ".format(
self.refinement_strategy)
msg += "This implies that \"refinementParametersPath\" is required for running, and it will not be used."
warnings.warn(msg, RuntimeWarning)
self.solverWrapperIndex.append(0)
if (self.solverWrapperIndex[0] >= 0): # for index < 0 not needed
if (self.asynchronous is not True): # synchronous framework
self.serialize()
else: # asynchronous framework
pass
def __init__(self, **keywordArgs):
# Attributes
self.indices = keywordArgs.get("indices", [])
self.assemblers = keywordArgs.get("assemblers")
self.estimatorsForAssembler = keywordArgs.get("estimatorsForAssembler")
self.indexConstructor = dynamicImport(
keywordArgs.get("indexConstructor", None))
self.indexConstructorDictionary = keywordArgs.get(
"indexConstructorDictionary", None)
self.qoiPredictor = keywordArgs.get(
"qoiPredictor", None
) # predictor used to extrapolate the current levelwise estimates to new levels where we don't have data yet (because we have no samples yet). If number of levels is constant, it is not required.
self.costPredictor = keywordArgs.get(
"costPredictor", None
) # predictor used to extrapolate the current levelwise estimates to new levels where we don't have data yet (because we have no samples yet). If number of levels is constant, it is not required.
self.estimatorsForPredictor = keywordArgs.get("estimatorsForPredictor",
None)
# TODO Why do we need costEstimatorsForPredictor?
self.costEstimatorForPredictor = keywordArgs.get(
"costEstimatorsForPredictor", None)
self.isCostUpdated = keywordArgs.get(
"isCostUpdated", False) # false if not using predictors
self.errorEstimators = keywordArgs.get("errorEstimators", None)
self.assemblersForError = keywordArgs.get("assemblersForError", None)
# asynchronous framework settings
self.numberBatches = keywordArgs.get("initialNumberBatches", None)
self.batchIndices = None
# Method Objects
# TODO Define these below
self.indexSet = None
self.samples = None
self.samplesCounter = 0 # this attribute is required only by the joint use of EventDatabase class and asynchronous algorithm
def __init__(self, **keywordArgs):
# Parent constructor
super().__init__(**keywordArgs)
# Attributes
# maximum order to which the moments are computed
self.order = keywordArgs.get("order")
# TODO indexSetDimension is only used to initialise self.powerSums
# and define the default value of self._updatedPowerSums.
# Should it be a required input argument?
indexSetDimension = keywordArgs.get("indexSetDimension")
self.indexSetDimension = indexSetDimension
# list of power sums required to compute the moments
# TODO - This is a temporary fix until when sample_moments.py is interfaced
if indexSetDimension == 0:
self.powerSums = [[None] for _ in range(self.powerSumsOrder())]
elif indexSetDimension == 1:
self.powerSums = [[None for _ in range(i + 2)]
for i in range(self.powerSumsOrder())]
else:
self.powerSums = None
# Methods
basePath = "xmc.methodDefs_momentEstimator."
self._centralMomentComputer = dynamicImport(
keywordArgs.get(
"centralMomentComputer",
basePath + "computeCentralMoments.centralMomentWrapper",
))
self._centralMomentErrorComputer = dynamicImport(
keywordArgs.get(
"centralMomentErrorComputer",
basePath + "computeErrorEstimation.centralMomentErrorWrapper",
))
self._rawMomentComputer = dynamicImport(
keywordArgs.get("rawMomentComputer", None))
self._rawMomentErrorComputer = dynamicImport(
keywordArgs.get("rawMomentErrorComputer", None))
# updatedPowerSums method (conditional default value)
defaultUpdater = (basePath + "updatePowerSums.updatePowerSums"
"Order{o}Dimension{d}").format(
o=self.powerSumsOrder(),
d=self.indexSetDimension)
self._updatedPowerSums = dynamicImport(
keywordArgs.get("updatedPowerSums", defaultUpdater))
def __init__(self, **keywordArgs):
# Parent constructor
super().__init__(**keywordArgs)
# Attributes
# maximum order to which the moments are computed
self.order = keywordArgs.get('order')
# TODO indexSetDimension is only used to initialise self.powerSums
# and define the default value of self._updatedPowerSums.
# Should it be a required input argument?
indexSetDimension = keywordArgs.get('indexSetDimension')
self.indexSetDimension = indexSetDimension
# list of power sums required to compute the moments
# TODO - This is a temporary fix until when sample_moments.py is interfaced
if indexSetDimension == 0:
self.powerSums = [[None] for _ in range(self.powerSumsOrder())]
elif indexSetDimension == 1:
self.powerSums = [[None for _ in range(i + 2)]
for i in range(self.powerSumsOrder())]
else:
self.powerSums = None
# Methods
self._centralMomentComputer = dynamicImport(
keywordArgs.get(
'centralMomentComputer',
'xmc.methodDefs_momentEstimator.computeCentralMoments.centralMomentTaskWrapper'
))
self._centralMomentErrorComputer = dynamicImport(
keywordArgs.get(
'centralMomentErrorComputer',
'xmc.methodDefs_momentEstimator.computeErrorEstimation.centralMomentErrorTaskWrapper'
))
self._rawMomentComputer = dynamicImport(
keywordArgs.get('rawMomentComputer', None))
self._rawMomentErrorComputer = dynamicImport(
keywordArgs.get('rawMomentErrorComputer', None))
# updatedPowerSums method (conditional default value)
default_power_sums_update='xmc.methodDefs_momentEstimator.updatePowerSums.updatePowerSumsOrder'\
+str(self.powerSumsOrder())+'Dimension'+str(indexSetDimension)+'_Task'
self._updatedPowerSums = dynamicImport(
keywordArgs.get('updatedPowerSums', default_power_sums_update))
def __init__(self, **keywordArgs):
# Attributes
self.indexSpace = keywordArgs.get("indexSpace", None)
self.toleranceSplittingBounds = keywordArgs.get(
"toleranceSplittingBounds", None)
self.defaultHierarchy = keywordArgs.get("defaultHierarchy", None)
# Methods
self.optimalIndexSet = dynamicImport(
keywordArgs.get("optimalIndexSet"))
self.optimalSampleNumbers = dynamicImport(
keywordArgs.get("optimalSampleNumbers"))
self.updateHierarchySpace = dynamicImport(
keywordArgs.get("updateHierarchySpace", "xmc.tools.doNothing"))
self.toleranceSplittingMethod = dynamicImport(
keywordArgs.get("toleranceSplittingMethod", "xmc.tools.doNothing"))
# TODO - Think of a better way to do this, improve naming
self.varianceBlender = keywordArgs.get("varianceBlender", None)
self.isVarianceBlended = keywordArgs.get("isVarianceBlended", False)
def __init__(self, **keywordArgs):
# Parent constructor
super().__init__(**keywordArgs)
# Attributes
self.parameters = keywordArgs.get("parameters", None)
# Methods
self._blendFunction = dynamicImport(
keywordArgs.get("blendFunction",
"xmc.bayesianEstimator.blend.noBlending"))
def __init__(self, **keywordArgs):
# Parent constructor
super().__init__(**keywordArgs)
# Attributes
self.parameters = keywordArgs.get('parameters', None)
# Methods
self._blendFunction = dynamicImport(
keywordArgs.get(
'blendFunction',
'xmc.methodDefs_bayesianEstimator.blend.noBlending'))
def __init__(self, **keywordArgs):
# Parent constructor
super(CombinedMomentEstimator, self).__init__(**keywordArgs)
if self.indexSetDimension == 0:
self.powerSums = [[None] for _ in range(self.powerSumsOrder())]
elif self.indexSetDimension == 1:
self.powerSums = [
[None for _ in range(0, 2)] for _ in range(self.powerSumsOrder())
]
else:
self.powerSums = None
# Methods
basePath = "xmc.methodDefs_momentEstimator."
self._centralMomentComputer = dynamicImport(
keywordArgs.get(
"centralMomentComputer",
basePath + "computeCentralMoments.centralCombinedMomentWrapper",
)
)
self._centralMomentErrorComputer = dynamicImport(
keywordArgs.get(
"centralMomentErrorComputer",
basePath + "computeErrorEstimation.centralCombinedMomentErrorWrapper",
)
)
self._rawMomentComputer = dynamicImport(keywordArgs.get("rawMomentComputer", None))
self._rawMomentErrorComputer = dynamicImport(
keywordArgs.get("rawMomentErrorComputer", None)
)
# updatedPowerSums method (conditional default value)
defaultUpdater = (
basePath + "updateCombinedPowerSums.updatePowerSums" "Order{o}Dimension{d}"
).format(o=self.powerSumsOrder(), d=self.indexSetDimension)
self._updatedPowerSums = dynamicImport(
keywordArgs.get("updatedPowerSums", defaultUpdater)
)
def __init__(self, **keywordArgs):
# Parent constructor
super().__init__(**keywordArgs)
#
# Methods
powerSumsUpdaterName = keywordArgs.get(
"powerSumsUpdater",
"xmc.methodDefs_momentEstimator.powerSums.addPowerSumsAndCounter",
)
# Modules for methods to compute moments
estimationName = keywordArgs.get(
"estimationFunction",
"xmc.methodDefs_momentEstimator.hStatistics.hStatisticsMonoPowerSums",
)
#
# Non-empty initialisation
# Enforce parallelisation
if self._isUpdateParallel and powerSumsUpdaterName[-6:-1] != "_Task":
powerSumsUpdaterName += "_Task"
if self._isEstimationParallel and estimationName[-6:-1] != "_Task":
estimationName += "_Task"
self._powerSumsUpdater = dynamicImport(powerSumsUpdaterName)
self._estimation = dynamicImport(estimationName)
def __init__(self, criterion_function, tolerance_values=None):
"""
- criterion_function is a necessary input argument. It is a string of the full name of the criterion function, e.g. xmc.methodDefs_monoCriterion.criterionFunctions.isLowerThanOrEqualTo.
- tolerance_value is not always necessary; it depends on the chosen criterion_function.
"""
self._criterion = dynamicImport(criterion_function)
if len(tolerance_values) == 0:
self.tolerance = tolerance_values
elif len(tolerance_values) == 1:
self.tolerance = tolerance_values[0]
else:
self.tolerance = tolerance_values.pop(0)
self.tolerances = tolerance_values
def __init__(self, **keywordArgs):
# Attributes
self.randomGenerator = instantiateObject(
keywordArgs.get('randomGenerator'),
**keywordArgs.get('randomGeneratorInputDict'))
self.qoiProcessor = dynamicImport(
keywordArgs.get('qoiProcessor', 'xmc.tools.returnInput'))
solver_wrapper_indices = keywordArgs.get('solverWrapperIndices')
self.solvers = []
for sw_index in solver_wrapper_indices:
keywordArgs['solverWrapperInputDict']['index'] = sw_index
self.solvers.append(
instantiateObject(keywordArgs.get('solverWrapper'),
**keywordArgs.get('solverWrapperInputDict')))
def __init__(self, **keywordArgs):
# Parent constructor
super(CombinedMomentEstimator, self).__init__(**keywordArgs)
# list of power sums to combined compute moments
# for these power sums we store upper and lower level
# for example, for index = 1 and order = 1, we will have S10, S01, S20, S02
if (self.indexSetDimension == 0):
self.powerSums = [[None] for _ in range(self.powerSumsOrder())]
elif (self.indexSetDimension == 1):
self.powerSums = [[None for _ in range(0, 2)]
for _ in range(self.powerSumsOrder())]
else:
self.powerSums = None
# Methods
self._centralMomentComputer = dynamicImport(
keywordArgs.get(
'centralMomentComputer',
'xmc.methodDefs_momentEstimator.computeCentralMoments.centralCombinedMomentTaskWrapper'
))
self._centralMomentErrorComputer = dynamicImport(
keywordArgs.get(
'centralMomentErrorComputer',
'xmc.methodDefs_momentEstimator.computeErrorEstimation.centralCombinedMomentErrorTaskWrapper'
))
self._rawMomentComputer = dynamicImport(
keywordArgs.get('rawMomentComputer', None))
self._rawMomentErrorComputer = dynamicImport(
keywordArgs.get('rawMomentErrorComputer', None))
# updatedPowerSums method (conditional default value)
default_power_sums_update = 'xmc.methodDefs_momentEstimator.updateCombinedPowerSums.updatePowerSumsOrder2Dimension' + str(
self.indexSetDimension) + '_Task'
self._updatedPowerSums = dynamicImport(
keywordArgs.get('updatedTimePowerSums', default_power_sums_update))
def __init__(self, **keywordArgs):
# Attributes
self.randomGenerator = instantiateObject(
keywordArgs.get("randomGenerator"),
**keywordArgs.get("randomGeneratorInputDictionary"),
)
self.qoiProcessor = dynamicImport(
keywordArgs.get("qoiProcessor", "xmc.tools.returnInput"))
solver_wrapper_indices = keywordArgs.get("solverWrapperIndices")
self.solvers = []
for sw_index in solver_wrapper_indices:
keywordArgs["solverWrapperInputDictionary"]["index"] = sw_index
self.solvers.append(
instantiateObject(
keywordArgs.get("solverWrapper"),
**keywordArgs.get("solverWrapperInputDictionary"),
))
def __init__(self, **keywordArgs):
# Attributes
self.indices = keywordArgs.get("indices", [])
self.assemblers = keywordArgs.get("assemblers")
self.estimatorsForAssembler = keywordArgs.get("estimatorsForAssembler")
self.indexConstructor = dynamicImport(keywordArgs.get("indexConstructor", None))
self.indexConstructorDictionary = keywordArgs.get("indexConstructorDictionary", None)
self.qoiPredictor = keywordArgs.get("qoiPredictor", None)
self.costPredictor = keywordArgs.get("costPredictor", None)
self.estimatorsForPredictor = keywordArgs.get("estimatorsForPredictor", None)
# TODO Why do we need costEstimatorsForPredictor?
self.costEstimatorForPredictor = keywordArgs.get("costEstimatorsForPredictor", None)
self.isCostUpdated = keywordArgs.get("isCostUpdated", False)
self.errorEstimators = keywordArgs.get("errorEstimators", None)
self.assemblersForError = keywordArgs.get("assemblersForError", None)
# asynchronous framework settings
self.numberBatches = keywordArgs.get("initialNumberBatches", None)
self.batchIndices = None
# Method Objects
# TODO Define these below
self.indexSet = None
self.samples = None
def __init__(self, **keywordArgs):
# TODO - think of a better way to do data dumps and output
self.isDataDumped = keywordArgs.get("isDataDumped", False)
self.outputFolderPath = keywordArgs.get("outputFolderPath", None)
# Attributes
self.monteCarloSampler = keywordArgs.get("monteCarloSampler")
self.hierarchyOptimiser = keywordArgs.get("hierarchyOptimiser")
self.stoppingCriterion = keywordArgs.get("stoppingCriterion")
self.errorsForStoppingCriterion = keywordArgs.get("errorForStoppingCriterion", None)
self.predictorsForHierarchy = keywordArgs.get("predictorsForHierarchy", None)
self.estimatorsForHierarchy = keywordArgs.get("estimatorsForHierarchy", None)
self.errorParametersForHierarchy = keywordArgs.get("errorParametersForHierarchy", None)
self.costPredictorForHierarchy = keywordArgs.get("costPredictorForHierarchy", None)
self.costEstimatorForHierarchy = keywordArgs.get("costEstimatorForHierarchy", None)
self.positionMaxNumberIterationsCriterion = keywordArgs.get(
"positionMaxNumberIterationsCriterion", None
)
self.iterationCounter = 0
# Methods
self.checkInitialisation = dynamicImport(
keywordArgs.get("checkInitialisation", "xmc.tools.doNothing")
)
def __init__(self, **keywordArgs):
# Attributes
self.parameters = keywordArgs.get("parameters", None)
# Methods
self._errorMethod = dynamicImport(keywordArgs.get("error"))
def __init__(self, **keywordArgs):
self.parameters = keywordArgs.get("parameters")
self._generator = dynamicImport(keywordArgs.get("generator"))
def __init__(self, **keywordArgs):
self.parameters = keywordArgs["parameters"]
self._generator = dynamicImport(keywordArgs["generator"])
def __init__(self, **keywordArgs):
"""
Keyword arguments required:
- order
Keyword arguments required for parallel update:
- variableDimension
Optional keyword arguments:
- referenceComponent
- isUpdateParallel
- isEstimationParallel
- isParallel
- estimationFunction
- powerSumsUpdater
- powerSums
Notes:
- isParallel: value is assigned to both self._isUpdateParallel and self._isEstimationParallel. If the keyword arguments isUpdateParallel or isEstimationParallel are given, they take priority.
"""
# Parent constructor
super().__init__(**keywordArgs)
#
# Attributes
# maximum order to which the moments are computed
self.order = keywordArgs.get("order")
# Index of reference component for the algorithm: error estimation and so on
self._referenceComponent = keywordArgs.get("referenceComponent", 0)
# Whether to run computations in parallel
isParallel = keywordArgs.get("isParallel", True)
self._isUpdateParallel = keywordArgs.get("isUpdateParallel",
isParallel)
self._isEstimationParallel = keywordArgs.get("isEstimationParallel",
isParallel)
# The following two attributes will be initialised upon first update,
# but if the samples are Future objects, the variable dimension must be given
self._variableDimension = keywordArgs.get("variableDimension", None)
self._indexSetDimension = None
#
# Methods
powerSumsUpdaterName = keywordArgs.get(
"powerSumsUpdater",
"xmc.methodDefs_momentEstimator.powerSums.updatedPowerSums")
# Modules for methods to compute moments
estimationName = keywordArgs.get(
"estimationFunction",
"xmc.methodDefs_momentEstimator.hStatistics.hStatistics")
#
# Non-empty initialisation
# Enforce parallelisation
if self._isUpdateParallel and powerSumsUpdaterName[-6:-1] != "_Task":
powerSumsUpdaterName += "_Task"
if self._isEstimationParallel and estimationName[-6:-1] != "_Task":
estimationName += "_Task"
self._powerSumsUpdater = dynamicImport(powerSumsUpdaterName)
self._estimation = dynamicImport(estimationName)
# list of power sums used to compute the moments
self._powerSums = keywordArgs.get("powerSums", None)
# in case power sums are input
if self._powerSums is not None:
self._indexSetDimension = self._guessIndexSetDimension()
self._variableDimension = self._guessVariableDimension()
def __init__(self, **keywordArgs):
self.parameters = keywordArgs.get('parameters')
self._generator = dynamicImport(keywordArgs.get('generator'))
