from SupervisedLearning.SciKitLearn import SciKitLearn
from SupervisedLearning.SyntheticHistory import SyntheticHistory
from SupervisedLearning.pickledROM import pickledROM
from SupervisedLearning.PolyExponential import PolyExponential
from SupervisedLearning.DynamicModeDecomposition import DynamicModeDecomposition
from SupervisedLearning.ROMCollection import Collection, Segments, Clusters, Interpolated
from .KerasClassifier import KerasClassifier
from SupervisedLearning.KerasMLPClassifier import KerasMLPClassifier
from SupervisedLearning.KerasConvNetClassifier import KerasConvNetClassifier
from SupervisedLearning.KerasLSTMClassifier import KerasLSTMClassifier
from SupervisedLearning.ROMCollection import Collection, Segments, Clusters
################################################################################
factory = EntityFactory('supervisedLearning')
factory.registerType('NDspline' , NDsplineRom)
factory.registerType('NDinvDistWeight' , NDinvDistWeight)
factory.registerType('NDsplineRom' , NDsplineRom)
factory.registerType('SciKitLearn' , SciKitLearn)
factory.registerType('GaussPolynomialRom' , GaussPolynomialRom)
factory.registerType('HDMRRom' , HDMRRom)
factory.registerType('MSR' , MSR)
factory.registerType('ARMA' , ARMA)
factory.registerType('SyntheticHistory' , SyntheticHistory)
factory.registerType('pickledROM' , pickledROM)
factory.registerType('PolyExponential' , PolyExponential)
factory.registerType('DMD' , DynamicModeDecomposition)
factory.registerType('Segments' , Segments)
factory.registerType('Clusters' , Clusters)
factory.registerType('Interpolated' , Interpolated)
factory.registerType('KerasMLPClassifier' , KerasMLPClassifier)
__moduleInterfaceList = []
startDir = os.path.join(os.path.dirname(__file__), 'PostProcessorFunctions')
for dirr, _, _ in os.walk(startDir):
__moduleInterfaceList.extend(glob(os.path.join(dirr, "*.py")))
utils.add_path(dirr)
__moduleImportedList = []
factory = EntityFactory('InterfacedPostProcessor')
for moduleIndex in range(len(__moduleInterfaceList)):
if 'class' in open(__moduleInterfaceList[moduleIndex]).read():
__moduleImportedList.append(
utils.importFromPath(__moduleInterfaceList[moduleIndex], False))
for key, modClass in inspect.getmembers(__moduleImportedList[-1],
inspect.isclass):
# in this way we can get all the class methods
classMethods = [
method for method in dir(modClass)
if callable(getattr(modClass, method))
]
if 'run' in classMethods:
factory.registerType(key, modClass)
def interfaceClasses():
"""
This returns the classes available
@ In, None
@ Out, interfaceClasses, list of classes available
"""
return list(factory._registeredTypes.values())
from glob import glob
import inspect
#External Modules End--------------------------------------------------------------------------------
#Internal Modules------------------------------------------------------------------------------------
from EntityFactoryBase import EntityFactory
from utils import utils
#Internal Modules End--------------------------------------------------------------------------------
__moduleInterfaceList = []
startDir = os.path.join(os.path.dirname(__file__), 'CodeInterfaces')
for dirr, _, _ in os.walk(startDir):
__moduleInterfaceList.extend(glob(os.path.join(dirr, "*.py")))
utils.add_path(dirr)
__moduleImportedList = []
factory = EntityFactory('Code')
for moduleIndex in range(len(__moduleInterfaceList)):
if 'class' in open(__moduleInterfaceList[moduleIndex]).read():
__moduleImportedList.append(
utils.importFromPath(__moduleInterfaceList[moduleIndex], False))
for key, modClass in inspect.getmembers(__moduleImportedList[-1],
inspect.isclass):
# in this way we can get all the class methods
classMethods = [
method for method in dir(modClass)
if callable(getattr(modClass, method))
]
if 'createNewInput' in classMethods:
factory.registerType(key.replace("Interface", ""), modClass)
from Samplers.AdaptiveSampler import AdaptiveSampler
from Samplers.LimitSurfaceSearch import LimitSurfaceSearch
from Samplers.AdaptiveSobol import AdaptiveSobol
from Samplers.AdaptiveSparseGrid import AdaptiveSparseGrid
from Samplers.AdaptiveMonteCarlo import AdaptiveMonteCarlo
# Dynamic Event Tree-based Samplers
from Samplers.DynamicEventTree import DynamicEventTree
from Samplers.AdaptiveDynamicEventTree import AdaptiveDynamicEventTree
# MCMC Samplers
from .MCMC import Metropolis
from .MCMC import AdaptiveMetropolis
factory = EntityFactory('Sampler')
factory.registerType('MonteCarlo', MonteCarlo)
factory.registerType('Grid', Grid)
factory.registerType('Stratified', Stratified)
factory.registerType('FactorialDesign', FactorialDesign)
factory.registerType('ResponseSurfaceDesign', ResponseSurfaceDesign)
factory.registerType('Sobol', Sobol)
factory.registerType('SparseGridCollocation', SparseGridCollocation)
factory.registerType('CustomSampler', CustomSampler)
factory.registerType('EnsembleForward', EnsembleForward)
factory.registerType('LimitSurfaceSearch', LimitSurfaceSearch)
factory.registerType('AdaptiveSobol', AdaptiveSobol)
factory.registerType('AdaptiveSparseGrid', AdaptiveSparseGrid)
factory.registerType('DynamicEventTree', DynamicEventTree)
factory.registerType('AdaptiveDynamicEventTree', AdaptiveDynamicEventTree)
factory.registerType('AdaptiveMonteCarlo', AdaptiveMonteCarlo)
factory.registerType('Metropolis', Metropolis)
@ In, None
@ Out, keys, list, list of available methods in this Function module (imported module)
"""
return self.__actionDictionary.keys()
def parameterNames(self):
"""
Get a list of the variables this function needs
@ In, None
@ Out, __inputVariables, list, the parameter names
"""
return self.__inputVariables[:]
factory = EntityFactory('function',
needsRunInfo=True,
returnInputParameter=True)
factory.registerType('External', External)
# add input specifications in FunctionCollection
FunctionCollection.addSub(External.getInputSpecification())
def returnInputParameter():
"""
Function returns the InputParameterClass that can be used to parse the
whole collection.
@ Out, returnInputParameter, FunctionCollection, class for parsing.
"""
return FunctionCollection()
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Created on May 21, 2016
@author: chenj
"""
from EntityFactoryBase import EntityFactory
################################################################################
from .Optimizer import Optimizer
from .RavenSampled import RavenSampled
from .GradientDescent import GradientDescent
from .SimulatedAnnealing import SimulatedAnnealing
from .GeneticAlgorithm import GeneticAlgorithm
factory = EntityFactory('Optimizer')
factory.registerType('GradientDescent', GradientDescent)
factory.registerType('SimulatedAnnealing', SimulatedAnnealing)
factory.registerType('GeneticAlgorithm', GeneticAlgorithm)
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Created on April 5, 2016
@author: maljdp
extracted from alfoa (11/14/2013) OutStreamManager.py
"""
from EntityFactoryBase import EntityFactory
from utils import utils
from .OutStreamBase import OutStreamBase
from .FilePrint import FilePrint
from .GeneralPlot import GeneralPlot
# from .DataMining import DataMining
# from .VDCComparison import VDCComparison
factory = EntityFactory('OutStreamBase')
factory.registerType('Print', FilePrint)
factory.registerType('Plot', GeneralPlot)
Pickle dump method hook.
@ In, None
@ Out, stateDict, dict, dict of objets needed to restore instance
"""
stateDict = File.__getstate__(self)
stateDict['perturbed'] = self.perturbed
stateDict['subDirectory'] = self.subDirectory
stateDict['alias'] = self.alias
return stateDict
def __setstate__(self, stateDict):
"""
Pickle load method hook.
@ In, stateDict, dict, of objets needed to restore instance
@ Out, None
"""
File.__setstate__(self, stateDict)
self.perturbed = stateDict['perturbed']
self.subDirectory = stateDict['subDirectory']
self.alias = stateDict['alias']
#
#
#
#
factory = EntityFactory('Files')
factory.registerType('RAVEN', RAVENGenerated)
factory.registerType('CSV', CSV)
factory.registerType('Input', UserGenerated)
'QTopologicalDecomposition': 'TopologicalDecomposition',
'QDataMining': 'DataMining'
}
except ImportError:
renaming = {}
factory = EntityFactory('Model', needsRunInfo=True)
factory.registerAllSubtypes(Model, alias=renaming)
# #here the class methods are called to fill the information about the usage of the classes
for className in factory.knownTypes():
classType = factory.returnClass(className, None)
classType.generateValidateDict()
classType.specializeValidateDict()
factory.registerType('External', ExternalPostProcessor)
def validate(className, role, what, caller):
"""
This is the general interface for the validation of a model usage
@ In, className, string, the name of the class
@ In, role, string, the role assumed in the Step
@ In, what, string, type of object
@ In, caller, instance, the instance of the caller
@ Out, None
"""
if className in factory.knownTypes():
return factory.returnClass(className,
caller).localValidateMethod(role, what)
else:
# Copyright 2017 Battelle Energy Alliance, LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Created on September 16, 2015
@author: maljdp
extracted from alfoa (2/16/2013) DataObjects.py
"""
from EntityFactoryBase import EntityFactory
from DataObjects.DataObject import DataObject
from DataObjects.DataSet import DataSet
from DataObjects.PointSet import PointSet
from DataObjects.HistorySet import HistorySet
factory = EntityFactory('DataObject')
factory.registerType('DataSet', DataSet)
factory.registerType('HistorySet', HistorySet)
factory.registerType('PointSet', PointSet)