class ErtServer(object): DATE_FORMAT = '%Y-%m-%d %H:%M:%S' site_config = None def __init__(self , config_file , logger): installAbortSignals() self.queue_lock = threading.Lock() self.ert_handle = None self.logger = logger if os.path.exists(config_file): self.open( config_file ) else: raise IOError("The config file:%s does not exist" % config_file) self.initCmdTable() self.run_context = None self.init_fs = None self.run_fs = None self.run_count = 0 def SUCCESS(self , res): self.logger.debug("Success: returning: %s" , res) return SUCCESS(res) def ERROR(self , res): self.logger.debug("ERROR: returning: %s" , res) return ERROR(res) def initCmdTable(self): self.cmd_table = {"STATUS" : self.handleSTATUS , "INIT_SIMULATIONS" : self.handleINIT_SIMULATIONS , "ADD_SIMULATION" : self.handleADD_SIMULATION , "GET_RESULT" : self.handleGET_RESULT , "TIME_STEP": self.handleTIMESTEP } def open(self , config_file): self.config_file = config_file self.ert_handle = EnKFMain( config_file ) self.logger.info("Have connect ert handle to:%s" , config_file) def close(self): # More cleanup first ... self.logger.info("Shutting down ert handle") self.ert_handle = None def isConnected(self): if self.ert_handle: return True else: return False def __del__(self): if self.isConnected(): self.close() def evalCmd(self , cmd_expr): cmd = cmd_expr[0] func = self.cmd_table.get(cmd) self.logger.info("Received command: %s" % cmd) if func: return func(cmd_expr[1:]) else: raise KeyError("The command:%s was not recognized" % cmd) # The STATUS action can either report results for the complete # simulation set, or it can report the status of one particular # realisation. If the function is called with zero arguments it # will return the global status, if called with one argument it # will return the status for that realisation. def handleSTATUS(self , args): if self.isConnected(): if self.run_context is None: return self.SUCCESS(["READY"]) else: if len(args) == 0: if self.run_context.isRunning(): return self.SUCCESS(["RUNNING" , self.run_context.getNumRunning() , self.run_context.getNumSuccess() , self.run_context.getNumFailed()]) else: return self.SUCCESS(["COMPLETE" , self.run_context.getNumRunning() , self.run_context.getNumSuccess() , self.run_context.getNumFailed()]) else: iens = args[0] if self.run_context.realisationRunning(iens): return self.SUCCESS(["RUNNING"]) elif self.run_context.realisationFailed(iens): return self.SUCCESS(["FAILED"]) elif self.run_context.realisationSuccess(iens): return self.SUCCESS(["SUCCESS"]) else: return self.SUCCESS(["CLOSED"]) def initSimulations(self , args): run_size = args[0] init_case = str(args[1]) run_case = str(args[2]) fs_manager = self.ert_handle.getEnkfFsManager() self.run_fs = fs_manager.getFileSystem( run_case ) self.init_fs = fs_manager.getFileSystem( init_case ) fs_manager.switchFileSystem( self.run_fs ) self.run_context = RunContext(self.ert_handle , run_size , self.run_fs , self.run_count) self.run_count += 1 return self.handleSTATUS([]) def restartSimulations(self , args): return self.initSimulations(args) def handleINIT_SIMULATIONS(self , args): if len(args) == 3: result = [] with self.queue_lock: if self.run_context is None: self.initSimulations( args ) else: if not self.run_context.isRunning(): self.restartSimulations( args ) result = ["OK"] return self.SUCCESS(result) else: raise IndexError("The INIT_SIMULATIONS command expects three arguments: [ensemble_size , init_case, run_case]") def handleGET_RESULT(self , args): iens = args[0] kw = str(args[2]) try: year,month,day = args[1] time_map = self.run_fs.getTimeMap( ) report_step = time_map.lookupTime( datetime.date( year , month , day) , tolerance_seconds_before = 24*3600 , tolerance_seconds_after = 24*3600) except TypeError: report_step = args[1] ensembleConfig = self.ert_handle.ensembleConfig() if kw in ensembleConfig: state = self.ert_handle.getRealisation( iens ) node = state[kw] gen_data = node.asGenData() fs = self.ert_handle.getEnkfFsManager().getCurrentFileSystem() node_id = NodeId(report_step , iens , EnkfStateType.FORECAST ) if node.tryLoad( fs , node_id ): data = gen_data.getData() return self.SUCCESS( ["OK"] + data.asList() ) else: raise Exception("Loading iens:%d report:%d kw:%s failed" % (iens , report_step , kw)) else: raise KeyError("The keyword:%s is not recognized" % kw) # ["ADD_SIMULATION" , 0 , 1 , 1 [ ["KW1" , ...] , ["KW2" , ....]]] def handleADD_SIMULATION(self , args): geo_id = args[0] pert_id = args[1] iens = args[2] self.logger.debug("ADD_SIMULATION geo_id:%d pert_id:%d iens:%d" % (geo_id , pert_id , iens)) kw_list = args[3] state = self.ert_handle.getRealisation( iens ) state.addSubstKeyword( "GEO_ID" , "%d" % geo_id ) elco_kw = [ l[0] for l in kw_list ] ens_config = self.ert_handle.ensembleConfig() for kw in ens_config.getKeylistFromVarType( EnkfVarType.PARAMETER ): if not kw in elco_kw: node = state[kw] init_id = NodeId(0 , geo_id , EnkfStateType.ANALYZED ) run_id = NodeId(0 , iens , EnkfStateType.ANALYZED ) node.load( self.init_fs , init_id ) node.save( self.run_fs , run_id ) for kw_arg in kw_list: kw = str(kw_arg[0]) data = kw_arg[1:] self.logger.debug("ADD_SIMULATION %s : %s" % (kw , data)) node = state[kw] gen_kw = node.asGenKw() gen_kw.setValues(data) run_id = NodeId(0 , iens , EnkfStateType.ANALYZED ) node.save( self.run_fs , run_id ) self.run_fs.fsync() state_map = self.run_fs.getStateMap() state_map[iens] = RealizationStateEnum.STATE_INITIALIZED self.run_context.startSimulation( iens ) return self.handleSTATUS([]) def handleTIMESTEP(self, args): enkf_fs_manager = self.ert_handle.getEnkfFsManager() enkf_fs = enkf_fs_manager.getCurrentFileSystem() time_map = enkf_fs.getTimeMap() time_steps = [ ts.datetime().strftime(ErtServer.DATE_FORMAT) for ts in time_map ] return self.SUCCESS(time_steps)
class ErtServer(object): DATE_FORMAT = '%Y-%m-%d %H:%M:%S' site_config = None def __init__(self, config_file, logger): installAbortSignals() self.queue_lock = threading.Lock() self.ert_handle = None self.logger = logger if os.path.exists(config_file): self.open(config_file) else: raise IOError("The config file:%s does not exist" % config_file) self.initCmdTable() self.run_context = None self.init_fs = None self.run_fs = None self.run_count = 0 def SUCCESS(self, res): self.logger.debug("Success: returning: %s", res) return SUCCESS(res) def ERROR(self, res): self.logger.debug("ERROR: returning: %s", res) return ERROR(res) def initCmdTable(self): self.cmd_table = { "STATUS": self.handleSTATUS, "INIT_SIMULATIONS": self.handleINIT_SIMULATIONS, "ADD_SIMULATION": self.handleADD_SIMULATION, "GET_RESULT": self.handleGET_RESULT, "TIME_STEP": self.handleTIMESTEP } def open(self, config_file): self.config_file = config_file self.ert_handle = EnKFMain(config_file) self.logger.info("Have connect ert handle to:%s", config_file) def close(self): # More cleanup first ... self.logger.info("Shutting down ert handle") self.ert_handle = None def isConnected(self): if self.ert_handle: return True else: return False def __del__(self): if self.isConnected(): self.close() def evalCmd(self, cmd_expr): cmd = cmd_expr[0] func = self.cmd_table.get(cmd) self.logger.info("Received command: %s" % cmd) if func: return func(cmd_expr[1:]) else: raise KeyError("The command:%s was not recognized" % cmd) def handleSTATUS(self, args): if self.isConnected(): if self.run_context is None: return self.SUCCESS(["READY"]) else: if self.run_context.isRunning(): if len(args) == 0: return self.SUCCESS([ "RUNNING", self.run_context.getNumRunning(), self.run_context.getNumComplete() ]) else: iens = args[0] if self.run_context.realisationComplete(iens): return self.SUCCESS(["COMPLETE"]) else: return self.SUCCESS(["RUNNING"]) else: return self.SUCCESS(["COMPLETE"]) else: return self.SUCCESS(["CLOSED"]) def initSimulations(self, args): run_size = args[0] init_case = str(args[1]) run_case = str(args[2]) fs_manager = self.ert_handle.getEnkfFsManager() self.run_fs = fs_manager.getFileSystem(run_case) self.init_fs = fs_manager.getFileSystem(init_case) fs_manager.switchFileSystem(self.run_fs) self.run_context = RunContext(self.ert_handle, run_size, self.run_fs, self.run_count) self.run_count += 1 return self.handleSTATUS([]) def restartSimulations(self, args): return self.initSimulations(args) def handleINIT_SIMULATIONS(self, args): if len(args) == 3: result = [] with self.queue_lock: if self.run_context is None: self.initSimulations(args) else: if not self.run_context.isRunning(): self.restartSimulations(args) result = ["OK"] return self.SUCCESS(result) else: raise IndexError( "The INIT_SIMULATIONS command expects three arguments: [ensemble_size , init_case, run_case]" ) def handleGET_RESULT(self, args): iens = args[0] kw = str(args[2]) try: year, month, day = args[1] time_map = self.run_fs.getTimeMap() report_step = time_map.lookupTime( datetime.date(year, month, day), tolerance_seconds_before=24 * 3600, tolerance_seconds_after=24 * 3600) except TypeError: report_step = args[1] ensembleConfig = self.ert_handle.ensembleConfig() if kw in ensembleConfig: state = self.ert_handle.getRealisation(iens) node = state[kw] gen_data = node.asGenData() fs = self.ert_handle.getEnkfFsManager().getCurrentFileSystem() node_id = NodeId(report_step, iens, EnkfStateType.FORECAST) if node.tryLoad(fs, node_id): data = gen_data.getData() return self.SUCCESS(["OK"] + data.asList()) else: raise Exception("Loading iens:%d report:%d kw:%s failed" % (iens, report_step, kw)) else: raise KeyError("The keyword:%s is not recognized" % kw) # ["ADD_SIMULATION" , 0 , 1 , 1 [ ["KW1" , ...] , ["KW2" , ....]]] def handleADD_SIMULATION(self, args): geo_id = args[0] pert_id = args[1] iens = args[2] self.logger.debug("ADD_SIMULATION geo_id:%d pert_id:%d iens:%d" % (geo_id, pert_id, iens)) kw_list = args[3] state = self.ert_handle.getRealisation(iens) state.addSubstKeyword("GEO_ID", "%d" % geo_id) elco_kw = [l[0] for l in kw_list] ens_config = self.ert_handle.ensembleConfig() for kw in ens_config.getKeylistFromVarType(EnkfVarType.PARAMETER): if not kw in elco_kw: node = state[kw] init_id = NodeId(0, geo_id, EnkfStateType.ANALYZED) run_id = NodeId(0, iens, EnkfStateType.ANALYZED) node.load(self.init_fs, init_id) node.save(self.run_fs, run_id) for kw_arg in kw_list: kw = str(kw_arg[0]) data = kw_arg[1:] self.logger.debug("ADD_SIMULATION %s : %s" % (kw, data)) node = state[kw] gen_kw = node.asGenKw() gen_kw.setValues(data) run_id = NodeId(0, iens, EnkfStateType.ANALYZED) node.save(self.run_fs, run_id) self.run_fs.fsync() state_map = self.run_fs.getStateMap() state_map[iens] = RealizationStateEnum.STATE_INITIALIZED self.run_context.startSimulation(iens) return self.handleSTATUS([]) def handleTIMESTEP(self, args): enkf_fs_manager = self.ert_handle.getEnkfFsManager() enkf_fs = enkf_fs_manager.getCurrentFileSystem() time_map = enkf_fs.getTimeMap() time_steps = [ ts.datetime().strftime(ErtServer.DATE_FORMAT) for ts in time_map ] return self.SUCCESS(time_steps)
# and submit the simulation. path_fmt = "/tmp/run%d" arg_list = [ RunArg.createEnsembleExperimentRunArg(fs, iens, path_fmt % iens) for iens in range(ert.getEnsembleSize()) ] for arg in arg_list: ert.createRunPath( arg ) ert.submitSimulation( arg ) while True: print("Waiting:%d Running:%d Complete:%d/%d" % (queue_manager.getNumWaiting( ), queue_manager.getNumRunning( ) , queue_manager.getNumSuccess() , queue_manager.getNumFailed( ))) if not queue_manager.isRunning( ): break time.sleep( 5 ) ens_config = ert.ensembleConfig( ) data_config = ens_config["SNAKE_OIL_OPR_DIFF"] param_config = ens_config["SNAKE_OIL_PARAM"] for iens in range(ert.getEnsembleSize( )): data_id = NodeId( realization_number = iens, report_step = 199 ) enkf_node1 = EnkfNode( data_config ) enkf_node1.load( fs , data_id ) gen_data = enkf_node1.asGenData( ) data = gen_data.getData( ) param_id = NodeId( realization_number = iens, report_step = 0 ) enkf_node2 = EnkfNode( param_config )
#!/usr/bin/env python import sys import time from ert.enkf import EnKFMain from ert.enkf.enums import ErtImplType # This will instantiate the EnkFMain object and create a handle to # "everything" ert related for this instance. ert = EnKFMain( sys.argv[1] ) # Ask the EnKFMain instance how many realisations it has. Observe that # the answer to this question is just the value of the # NUM_REALISATIONS setting in the configuration file. print("This instance has %d realisations" % ert.getEnsembleSize()) # Get the ensemble configuration object, and ask for all GEN_KW keys: ens_config = ert.ensembleConfig( ) for key in ens_config.getKeylistFromImplType(ErtImplType.GEN_KW): config_node = ens_config[key] # "Downcast" to GEN_KW configuration. gen_kw_config = config_node.getModelConfig( ) print("%s : %s" % (key , gen_kw_config.getKeyWords( )))
class ErtServer(object): site_config = None def __init__(self, config_file, logger): installAbortSignals() self.queue_lock = threading.Lock() self.ert_handle = None self.logger = logger if os.path.exists(config_file): self.open(config_file) else: raise IOError("The config file:%s does not exist" % config_file) self.initCmdTable() self.run_context = None self.init_fs = None self.run_fs = None self.run_count = 0 def SUCCESS(self, res): self.logger.debug("Success: returning: %s", res) return SUCCESS(res) def ERROR(self, res): self.logger.debug("ERROR: returning: %s", res) return ERROR(res) def initCmdTable(self): self.cmd_table = { "STATUS": self.handleSTATUS, "INIT_SIMULATIONS": self.handleINIT_SIMULATIONS, "ADD_SIMULATION": self.handleADD_SIMULATION, "GET_RESULT": self.handleGET_RESULT, } def open(self, config_file): self.config_file = config_file self.ert_handle = EnKFMain(config_file, ErtServer.site_config) self.logger.info("Have connect ert handle to:%s", config_file) def close(self): # More cleanup first ... self.logger.info("Shutting down ert handle") self.ert_handle = None def isConnected(self): if self.ert_handle: return True else: return False def __del__(self): if self.isConnected(): self.close() def evalCmd(self, cmd_expr): cmd = cmd_expr[0] func = self.cmd_table.get(cmd) self.logger.info("Received command: %s" % cmd) if func: return func(cmd_expr[1:]) else: raise KeyError("The command:%s was not recognized" % cmd) def handleSTATUS(self, args): if self.isConnected(): if self.run_context is None: return self.SUCCESS(["READY"]) else: if self.run_context.isRunning(): if len(args) == 0: return self.SUCCESS( ["RUNNING", self.run_context.getNumRunning(), self.run_context.getNumComplete()] ) else: iens = args[0] if self.run_context.realisationComplete(iens): return self.SUCCESS(["COMPLETE"]) else: return self.SUCCESS(["RUNNING"]) else: return self.SUCCESS(["COMPLETE"]) else: return self.SUCCESS(["CLOSED"]) def initSimulations(self, args): run_size = args[0] init_case = str(args[1]) run_case = str(args[2]) fs_manager = self.ert_handle.getEnkfFsManager() self.run_fs = fs_manager.getFileSystem(run_case) self.init_fs = fs_manager.getFileSystem(init_case) fs_manager.switchFileSystem(self.run_fs) self.run_context = RunContext(self.ert_handle, run_size, self.run_fs, self.run_count) self.run_count += 1 return self.handleSTATUS([]) def restartSimulations(self, args): return self.initSimulations(args) def handleINIT_SIMULATIONS(self, args): if len(args) == 3: result = [] with self.queue_lock: if self.run_context is None: self.initSimulations(args) else: if not self.run_context.isRunning(): self.restartSimulations(args) result = ["OK"] return self.SUCCESS(result) else: raise IndexError( "The INIT_SIMULATIONS command expects three arguments: [ensemble_size , init_case, run_case]" ) def handleGET_RESULT(self, args): iens = args[0] report_step = args[1] kw = str(args[2]) ensembleConfig = self.ert_handle.ensembleConfig() if ensembleConfig.hasKey(kw): state = self.ert_handle.getRealisation(iens) node = state[kw] gen_data = node.asGenData() fs = self.ert_handle.getEnkfFsManager().getCurrentFileSystem() node_id = NodeId(report_step, iens, EnkfStateType.FORECAST) if node.tryLoad(fs, node_id): data = gen_data.getData() return self.SUCCESS(["OK"] + data.asList()) else: raise Exception("Loading iens:%d report:%d kw:%s failed" % (iens, report_step, kw)) else: raise KeyError("The keyword:%s is not recognized" % kw) # ["ADD_SIMULATION" , 0 , 1 , 1 [ ["KW1" , ...] , ["KW2" , ....]]] def handleADD_SIMULATION(self, args): geo_id = args[0] pert_id = args[1] iens = args[2] kw_list = args[3] state = self.ert_handle.getRealisation(iens) state.addSubstKeyword("GEO_ID", "%s" % geo_id) elco_kw = [l[0] for l in kw_list] ens_config = self.ert_handle.ensembleConfig() for kw in ens_config.getKeylistFromVarType(EnkfVarType.PARAMETER): if not kw in elco_kw: node = state[kw] init_id = NodeId(0, geo_id, EnkfStateType.ANALYZED) run_id = NodeId(0, iens, EnkfStateType.ANALYZED) node.load(self.init_fs, init_id) node.save(self.run_fs, run_id) for kw_arg in kw_list: kw = str(kw_arg[0]) data = kw_arg[1:] node = state[kw] gen_kw = node.asGenKw() gen_kw.setValues(data) run_id = NodeId(0, iens, EnkfStateType.ANALYZED) node.save(self.run_fs, run_id) state_map = self.run_fs.getStateMap() state_map[iens] = RealizationStateEnum.STATE_INITIALIZED self.run_context.startSimulation(iens) return self.handleSTATUS([])
class ErtServer(object): site_config = None def __init__(self , config_file = None): self.ert_handle = None if config_file: if os.path.exists(config_file): self.open( config_file ) else: raise IOError("The config file:%s does not exist" % config_file) self.initCmdTable() self.run_context = None def initCmdTable(self): self.cmd_table = {"STATUS" : self.handleSTATUS , "INIT_SIMULATIONS" : self.handleINIT_SIMULATIONS , "ADD_SIMULATION" : self.handleADD_SIMULATION , "SET_VARIABLE" : self.handleSET_VARIABLE , "GET_RESULT" : self.handleGET_RESULT } def open(self , config_file): self.config_file = config_file self.ert_handle = EnKFMain( config_file , ErtServer.site_config ) def close(self): # More cleanup first ... self.ert_handle = None def isConnected(self): if self.ert_handle: return True else: return False def __del__(self): if self.isConnected(): self.close() def evalCmd(self , cmd_expr): cmd = cmd_expr[0] func = self.cmd_table.get(cmd) if func: return func(cmd_expr[1:]) else: raise ErtCmdError("The command:%s was not recognized" % cmd) def handleSTATUS(self , args): if self.isConnected(): if self.run_context is None: return ["READY"] else: return ["RUNNING" , self.run_context.getNumRunning() , self.run_context.getNumComplete()] else: return ["CLOSED"] def handleINIT_SIMULATIONS(self , args): if len(args) == 2: if self.run_context is None: run_size = args[0] init_case = args[1] self.run_context = RunContext(self.ert_handle , run_size , init_case) return self.handleSTATUS([]) else: raise ErtCmdError("The ert server has already started simulations") else: raise ErtCmdError("The INIT_SIMULATIONS command expects two arguments: [ensemble_size , init_case]") def handleGET_RESULT(self , args): iens = args[0] report_step = args[1] kw = str(args[2]) ensembleConfig = self.ert_handle.ensembleConfig() if ensembleConfig.hasKey( kw ): state = self.ert_handle[iens] node = state[kw] gen_data = node.asGenData() fs = self.ert_handle.getEnkfFsManager().getCurrentFileSystem() node_id = NodeId(report_step , iens , EnkfStateType.FORECAST ) if node.tryLoad( fs , node_id ): data = gen_data.getData() return json.dumps( ["OK"] + data.asList() ) else: raise ErtCmdError("Loading iens:%d report:%d kw:%s failed" % (iens , report_step , kw)) else: raise ErtCmdError("The keyword:%s is not recognized" % kw) def handleSET_VARIABLE(self , args): geo_id = args[0] pert_id = args[1] iens = args[2] kw = str(args[3]) ensembleConfig = self.ert_handle.ensembleConfig() if ensembleConfig.hasKey(kw): state = self.ert_handle[iens] node = state[kw] gen_kw = node.asGenKw() gen_kw.setValues(args[4:]) fs = self.ert_handle.getEnkfFsManager().getCurrentFileSystem() node_id = NodeId(0 , iens , EnkfStateType.ANALYZED ) node.save( fs , node_id ) else: raise ErtCmdError("The keyword:%s is not recognized" % kw) def handleADD_SIMULATION(self , args): iens = args[0] self.run_context.startSimulation( iens )