def get_cov(cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): """ Construct coverage """ pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # 0d spatial topology (station/trajectory) if brick_size is not None: bricking_scheme = {'brick_size':brick_size, 'chunk_size':True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, 'TestOneParamCovInt' else: # Add data for the parameter scov.set_parameter_values(make_parameter_data_dict({'time': np.arange(nt)})) if in_memory and save_coverage: SimplexCoverage.pickle_save(scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestOneParamCovInt'
def get_cov(cls, only_time=False, param_filter=None, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): # Instantiate a ParameterDictionary pname_filter = ['time', 'lat', 'lon', 'temp', 'conductivity'] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # 0d spatial topology (station/trajectory) if brick_size is not None: bricking_scheme = {'brick_size':brick_size, 'chunk_size':True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) if in_memory and save_coverage: SimplexCoverage.pickle_save(scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestEmptySampleCovInt'
def get_cov(cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): # Instantiate a ParameterDictionary pname_filter = ['time', 'lat', 'lon', 'temp', 'conductivity'] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # 0d spatial topology (station/trajectory) if brick_size is not None: bricking_scheme = {'brick_size':brick_size, 'chunk_size':True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, 'TestSampleCovInt' else: params = {} params['time'] = np.arange(nt) if not only_time: params['lat'] = np.empty(nt) params['lat'].fill(45) params['lon'] = np.empty(nt) params['lon'].fill(-71) params['temp'] = utils.get_random_sample(nt, 23, 26) params['conductivity'] = utils.get_random_sample(nt, 90, 110) scov.set_parameter_values(params) # Add data for each parameter # scov.set_parameter_values({'time': np.arange(nt)}) # if not only_time: # scov.set_parameter_values('lat', value=45) # scov.set_parameter_values('lon', value=-71) # # make a random sample of 10 values between 23 and 26 # # Ref: http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.random_sample.html#numpy.random.random_sample # # --> To sample multiply the output of random_sample by (b-a) and add a # tvals = utils.get_random_sample(nt, 23, 26) # scov.set_parameter_values('temp', value=tvals) # scov.set_parameter_values('conductivity', value=utils.get_random_sample(nt, 90, 110)) if in_memory and save_coverage: SimplexCoverage.pickle_save(scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestSampleCovInt'
def get_cov(cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): """ Construct coverage """ pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE ) # 0d spatial topology (station/trajectory) if brick_size is not None: bricking_scheme = {'brick_size': brick_size, 'chunk_size': True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, 'TestOneParamCovInt' else: scov.insert_timesteps(nt) # Add data for the parameter scov.set_parameter_values('time', value=np.arange(nt)) if in_memory and save_coverage: SimplexCoverage.pickle_save( scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestOneParamCovInt'
def get_cov(cls, only_time=False, param_filter=None, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): # Instantiate a ParameterDictionary pname_filter = ['time', 'lat', 'lon', 'temp', 'conductivity'] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE ) # 0d spatial topology (station/trajectory) if brick_size is not None: bricking_scheme = {'brick_size': brick_size, 'chunk_size': True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) if in_memory and save_coverage: SimplexCoverage.pickle_save( scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestEmptySampleCovInt'
def create_cov(cls, only_time=False, in_memory=False, inline_data_writes=True, brick_size=None, auto_flush_values=True): # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # 0d spatial topology (station/trajectory) pname_filter = ['time', 'boolean', 'const_int', 'const_rng_flt', 'const_rng_int', 'numexpr_func', 'category', 'record', 'sparse', 'lat', 'lon', 'depth', 'salinity'] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) if brick_size is not None: bricking_scheme = {'brick_size':brick_size, 'chunk_size':True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain cov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) cls.coverages.add(cov.persistence_guid) return cov
def construct_cov( cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True, ): """ Construct coverage """ # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape("temporal", [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain( GridShape("spatial", [0]), scrs, MutabilityEnum.IMMUTABLE ) # 0d spatial topology (station/trajectory) pname_filter = [ "time", "boolean", "const_float", "const_int", "const_str", "const_rng_flt", "const_rng_int", "numexpr_func", "category", "quantity", "array", "record", "fixed_str", "sparse", "lat", "lon", "depth", ] if only_time: pname_filter = ["time"] pdict = get_parameter_dict(parameter_list=pname_filter) if brick_size is not None: bricking_scheme = {"brick_size": brick_size, "chunk_size": True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage( cls.working_dir, create_guid(), "sample coverage_model", parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values, ) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, "TestTestSpanUnit" else: # Add data for each parameter if only_time: scov.set_parameter_values( make_parameter_data_dict({scov.temporal_parameter_name: np.arange(1000, 10000, nt + 1)}) ) else: parameter_values = {} # scov.set_parameter_values('sparse', [[[2, 4, 6], [8, 10, 12]]]) # scov.insert_timesteps(nt/2) # # scov.set_parameter_values('sparse', [[[4, 8], [16, 20]]]) # scov.insert_timesteps(nt/2) scov.append_parameter(ParameterContext("m_lon")) scov.append_parameter(ParameterContext("m_lat")) scov.append_parameter(ParameterContext("depth")) parameter_values["time"] = np.arange(1000, 1000 + nt) parameter_values["depth"] = 1000 * np.random.random_sample(nt) parameter_values["m_lon"] = 160 * np.random.random_sample(nt) parameter_values["m_lat"] = 70 * np.random.random_sample(nt) scov.set_parameter_values(make_parameter_data_dict(parameter_values)) cls.coverages.add(scov.persistence_guid) return scov, "TestSpanInt"
def get_cov(cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): """ Construct coverage """ # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # 0d spatial topology (station/trajectory) pname_filter = ['time', 'boolean', 'const_float', 'const_int', 'const_str', 'const_rng_flt', 'const_rng_int', 'numexpr_func', 'category', 'quantity', 'array', 'record', 'fixed_str', 'sparse'] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) if brick_size is not None: bricking_scheme = {'brick_size':brick_size, 'chunk_size':True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, 'TestPtypesCovInt' else: # Add data for each parameter print nt if only_time: scov.insert_timesteps(nt) scov.set_parameter_values('time', value=np.arange(nt)) else: scov.set_parameter_values('sparse', [[[2, 4, 6], [8, 10, 12]]]) scov.insert_timesteps(nt/2) scov.set_parameter_values('sparse', [[[4, 8], [16, 20]]]) scov.insert_timesteps(nt/2) scov.set_parameter_values('time', value=np.arange(nt)) scov.set_parameter_values('boolean', value=[True, True, True], tdoa=[[2,4,14]]) scov.set_parameter_values('const_float', value=-71.11) # Set a constant with correct data type scov.set_parameter_values('const_int', value=45.32) # Set a constant with incorrect data type (fixed under the hood) scov.set_parameter_values('const_str', value='constant string value') # Set with a string scov.set_parameter_values('const_rng_flt', value=(12.8, 55.2)) # Set with a tuple scov.set_parameter_values('const_rng_int', value=[-10, 10]) # Set with a list scov.set_parameter_values('quantity', value=np.random.random_sample(nt)*(26-23)+23) arrval = [] recval = [] catval = [] fstrval = [] catkeys = EXEMPLAR_CATEGORIES.keys() letts='abcdefghijklmnopqrstuvwxyz' while len(letts) < nt: letts += 'abcdefghijklmnopqrstuvwxyz' for x in xrange(nt): arrval.append(np.random.bytes(np.random.randint(1,20))) # One value (which is a byte string) for each member of the domain d = {letts[x]: letts[x:]} recval.append(d) # One value (which is a dict) for each member of the domain catval.append(random.choice(catkeys)) fstrval.append(''.join([random.choice(letts) for x in xrange(8)])) # A random string of length 8 scov.set_parameter_values('array', value=arrval) scov.set_parameter_values('record', value=recval) scov.set_parameter_values('category', value=catval) scov.set_parameter_values('fixed_str', value=fstrval) if in_memory and save_coverage: SimplexCoverage.pickle_save(scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestPtypesCovInt'
def construct_cov(cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): """ Construct coverage """ # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE) # 0d spatial topology (station/trajectory) pname_filter = ['time', 'boolean', 'const_float', 'const_int', # 'const_str', 'const_rng_flt', 'const_rng_int', 'numexpr_func', 'category', 'quantity', 'array', 'record', 'fixed_str', 'sparse', 'lat', 'lon', 'depth'] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) if brick_size is not None: bricking_scheme = {'brick_size':brick_size, 'chunk_size':True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, 'TestSpanValidationUnit' else: np_dict = {} # Add data for each parameter time_array = np.arange(10000, 10000+nt) np_dict[scov.temporal_parameter_name] = NumpyParameterData(scov.temporal_parameter_name, time_array, time_array) if not only_time: scov.append_parameter(ParameterContext('depth', fill_value=9999.0)) # scov.append_parameter(ParameterContext('lon')) # scov.append_parameter(ParameterContext('lat')) scov.append_parameter(ParameterContext('const_str', fill_value='Nope')) np_dict['depth'] = NumpyParameterData('depth', np.random.uniform(0,200,[nt]), time_array) np_dict['lon'] = NumpyParameterData('lon', np.random.uniform(-180,180,[nt]), time_array) np_dict['lat'] = NumpyParameterData('lat', np.random.uniform(-90,90,[nt]), time_array) np_dict['const_float'] = ConstantOverTime('const_float', 88.8, time_start=10000, time_end=10000+nt) np_dict['const_str'] = ConstantOverTime('const_str', 'Jello', time_start=10000, time_end=10000+nt) scov.set_parameter_values(np_dict) cls.coverages.add(scov.persistence_guid) return scov, 'TestSpanValidationInt'
def get_cov(cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): """ Construct coverage """ # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE ) # 0d spatial topology (station/trajectory) pname_filter = [ 'time', 'boolean', 'const_float', 'const_int', 'const_str', 'const_rng_flt', 'const_rng_int', 'numexpr_func', 'category', 'quantity', 'array', 'record', 'fixed_str', 'sparse' ] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) if brick_size is not None: bricking_scheme = {'brick_size': brick_size, 'chunk_size': True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, 'TestPtypesCovInt' else: # Add data for each parameter print nt if only_time: scov.insert_timesteps(nt) scov.set_parameter_values('time', value=np.arange(nt)) else: scov.set_parameter_values('sparse', [[[2, 4, 6], [8, 10, 12]]]) scov.insert_timesteps(nt / 2) scov.set_parameter_values('sparse', [[[4, 8], [16, 20]]]) scov.insert_timesteps(nt / 2) scov.set_parameter_values('time', value=np.arange(nt)) scov.set_parameter_values('boolean', value=[True, True, True], tdoa=[[2, 4, 14]]) scov.set_parameter_values( 'const_float', value=-71.11) # Set a constant with correct data type scov.set_parameter_values( 'const_int', value=45.32 ) # Set a constant with incorrect data type (fixed under the hood) scov.set_parameter_values( 'const_str', value='constant string value') # Set with a string scov.set_parameter_values('const_rng_flt', value=(12.8, 55.2)) # Set with a tuple scov.set_parameter_values('const_rng_int', value=[-10, 10]) # Set with a list scov.set_parameter_values('quantity', value=np.random.random_sample(nt) * (26 - 23) + 23) arrval = [] recval = [] catval = [] fstrval = [] catkeys = EXEMPLAR_CATEGORIES.keys() letts = 'abcdefghijklmnopqrstuvwxyz' while len(letts) < nt: letts += 'abcdefghijklmnopqrstuvwxyz' for x in xrange(nt): arrval.append( np.random.bytes(np.random.randint(1, 20)) ) # One value (which is a byte string) for each member of the domain d = {letts[x]: letts[x:]} recval.append( d ) # One value (which is a dict) for each member of the domain catval.append(random.choice(catkeys)) fstrval.append(''.join([ random.choice(letts) for x in xrange(8) ])) # A random string of length 8 scov.set_parameter_values('array', value=arrval) scov.set_parameter_values('record', value=recval) scov.set_parameter_values('category', value=catval) scov.set_parameter_values('fixed_str', value=fstrval) if in_memory and save_coverage: SimplexCoverage.pickle_save( scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestPtypesCovInt'
def get_cov(cls, only_time=False, save_coverage=False, in_memory=False, inline_data_writes=True, brick_size=None, make_empty=False, nt=None, auto_flush_values=True): # Instantiate a ParameterDictionary pname_filter = ['time', 'lat', 'lon', 'temp', 'conductivity'] if only_time: pname_filter = ['time'] pdict = get_parameter_dict(parameter_list=pname_filter) # Construct temporal and spatial Coordinate Reference System objects tcrs = CRS([AxisTypeEnum.TIME]) scrs = CRS([AxisTypeEnum.LON, AxisTypeEnum.LAT]) # Construct temporal and spatial Domain objects tdom = GridDomain(GridShape('temporal', [0]), tcrs, MutabilityEnum.EXTENSIBLE) # 1d (timeline) sdom = GridDomain(GridShape('spatial', [0]), scrs, MutabilityEnum.IMMUTABLE ) # 0d spatial topology (station/trajectory) if brick_size is not None: bricking_scheme = {'brick_size': brick_size, 'chunk_size': True} else: bricking_scheme = None # Instantiate the SimplexCoverage providing the ParameterDictionary, spatial Domain and temporal Domain scov = SimplexCoverage(cls.working_dir, create_guid(), 'sample coverage_model', parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=inline_data_writes, in_memory_storage=in_memory, bricking_scheme=bricking_scheme, auto_flush_values=auto_flush_values) # Insert some timesteps (automatically expands other arrays) if (nt is None) or (nt == 0) or (make_empty is True): return scov, 'TestSampleCovInt' else: scov.insert_timesteps(nt) # Add data for each parameter scov.set_parameter_values('time', value=np.arange(nt)) if not only_time: scov.set_parameter_values('lat', value=45) scov.set_parameter_values('lon', value=-71) # make a random sample of 10 values between 23 and 26 # Ref: http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.random_sample.html#numpy.random.random_sample # --> To sample multiply the output of random_sample by (b-a) and add a tvals = utils.get_random_sample(nt, 23, 26) scov.set_parameter_values('temp', value=tvals) scov.set_parameter_values('conductivity', value=utils.get_random_sample( nt, 90, 110)) if in_memory and save_coverage: SimplexCoverage.pickle_save( scov, os.path.join(cls.working_dir, 'sample.cov')) return scov, 'TestSampleCovInt'