def __init__(self, name, vars={}, models={}, default_models={}, regions={}, direc_out='', nc_dir_struc=False, verbose=True): self.verbose = verbose if self.verbose: print ("Initializing Project instance: %s (%s)" % (name, time.ctime())) self.name = name self.direc_out = direc_out self.nc_dir_struc = nc_dir_struc if models: self.models = dict_name_keys(models) else: self.models = {} if default_models == 'all': self.default_models = self.models elif default_models: self.default_models = dict_name_keys(default_models) else: self.default_models = {} if regions: self.regions = dict_name_keys(regions) else: self.regions = {} for obj_dict in (self.models, self.regions): for obj in obj_dict.values(): setattr(obj, 'proj', self) db_models = [m.db_entry for m in models] # Add row to database. session = create_session() self.db_entry, isin = get_or_create(session, dbProj, defaults=None, name=self.name, direc_out=self.direc_out) if not self.db_entry.models: self.db_entry.models = db_models session.commit() session.close()
def __init__(self, calc_interface): self.__dict__ = vars(calc_interface) self._print_verbose('Initializing Calc instance:', self.__str__()) #[mod.set_grid_data() for mod in self.model] if isinstance(calc_interface.ens_mem, int): self.data_in_direc = self.data_in_direc[calc_interface.ens_mem] self.dt_set = False self.dir_scratch = self._dir_scratch() self.dir_archive = self._dir_archive() self.file_name = {d: self._file_name(d) for d in self.dtype_out_time} self.path_scratch = {d: self._path_scratch(d) for d in self.dtype_out_time} self.path_archive = self._path_archive() self.data_out = {} # Add rows to database. session = create_session() rn = self.run[0].get_db_entry(session) vr, isin = get_or_create(session, dbVar, defaults=None, name=self.name) for d in self.dtype_out_time: clc, isin = get_or_create(session, dbCalc, defaults=None, name=self.name, filepath=self.path_scratch[d], var=vr, run=rn, intvl_in=self.intvl_in, intvl_out=self.intvl_out, dtype_out_time=d, start_date=self.start_date, end_date=self.end_date, pressure_type=str(self.level)) session.commit() session.close()
def __init__(self, name='', description='', proj=False, grid_file_paths=(), data_in_direc=False, data_in_dir_struc=False, data_in_dur=False, data_in_start_date=False, data_in_end_date=False, default_date_range=False, runs={}, default_runs={}, load_grid_data=False, repo_version=False): self.name = name self.description = description self.proj = proj self.grid_file_paths = grid_file_paths self.repo_version = repo_version self.data_in_direc = data_in_direc self.data_in_dir_struc = data_in_dir_struc self.data_in_dur = data_in_dur self.data_in_start_date = data_in_start_date self.data_in_end_date = data_in_end_date self.default_date_range = default_date_range self.runs = dict_name_keys(runs) [setattr(run, 'parent', self) for run in self.runs.values()] if default_runs: self.default_runs = dict_name_keys(default_runs) else: self.default_runs = {} self.grid_data_is_set = False # Add row to database. session = create_session() self.db_entry, isin = get_or_create(session, dbModel, defaults=None, name=self.name) if not self.db_entry.runs: self.db_entry.runs = [r.db_entry for r in runs] session.commit() session.close()
def __init__(self, proj=None, model=None, run=None, ens_mem=None, var=None, date_range=None, region=None, intvl_in=None, intvl_out=None, dtype_in_time=None, dtype_in_vert=None, dtype_out_time=None, dtype_out_vert=None, level=None, chunk_len=False, verbose=True): """Create the CalcInterface object with the given parameters.""" if run not in model.runs.values(): raise AttributeError("Model '{}' has no run '{}'. Calc object " "will not be generated.".format(model, run)) # 2015-10-13 S. Hill: This tuple-izing is for support of calculations # where variables come from different runs. However, this is a very # fragile way of implementing that functionality. Eventually it will # be replaced with something better. proj = tuple([proj]) model = tuple([model]) if not isinstance(run, (list, tuple)): run = tuple([run]) # Make tuples the same length. if len(proj) == 1 and (len(model) > 1 or len(run) > 1): proj = tuple(list(proj)*len(run)) if len(model) == 1 and len(run) > 1: model = tuple(list(model)*len(run)) self.proj = proj self.model = model self.run = run self._set_data_in_attrs() self.proj_str = '_'.join(set([p.name for p in self.proj])) self.model_str = '_'.join(set([m.name for m in self.model])) run_names = [r.name for r in self.run] self.run_str = '_'.join(set(run_names)) self.run_str_full = '_'.join(run_names) self.var = var self.name = self.var.name self.domain = self.var.domain self.def_time = self.var.def_time self.def_vert = self.var.def_vert self.verbose = verbose try: self.function = self.var.func except AttributeError: self.function = lambda x: x if getattr(self.var, 'variables', False): self.variables = self.var.variables else: self.variables = (self.var,) self.ens_mem = ens_mem self.level = level self.intvl_in = intvl_in self.intvl_out = intvl_out self.dtype_in_time = dtype_in_time self.dtype_in_vert = dtype_in_vert self.ps = ps if isinstance(dtype_out_time, (list, tuple)): self.dtype_out_time = tuple(dtype_out_time) else: self.dtype_out_time = tuple([dtype_out_time]) self.dtype_out_vert = dtype_out_vert self.region = region self.months = TimeManager.month_indices(intvl_out) self.start_date = TimeManager.str_to_datetime(date_range[0]) self.end_date = TimeManager.str_to_datetime(date_range[-1]) tm = TimeManager(self.start_date, self.end_date, intvl_out) self.date_range = tm.create_time_array() self.start_date_xray = tm.apply_year_offset(self.start_date) self.end_date_xray = tm.apply_year_offset(self.end_date) # Add row to database. session = create_session() db_entry_var, isin = get_or_create(session, dbVar, defaults=None, name=self.name) session.commit() session.close()