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