Python Catalogue.make_from_dict方法代码示例

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
    def setUp(self):
        """
        """
        # Read initial dataset
        filename = os.path.join(self.BASE_DATA_PATH,
                                'completeness_test_cat.csv')
        test_data = np.genfromtxt(filename, delimiter=',', skip_header=1)
        # Create the catalogue A
        self.catalogueA = Catalogue.make_from_dict(
            {'year': test_data[:,3], 'magnitude': test_data[:,17]})

        # Read initial dataset
        filename = os.path.join(self.BASE_DATA_PATH,
                                'recurrence_test_cat_B.csv')
        test_data = np.genfromtxt(filename, delimiter=',', skip_header=1)
        # Create the catalogue A
        self.catalogueB = Catalogue.make_from_dict(
            {'year': test_data[:,3], 'magnitude': test_data[:,17]})

        # Read the verification table A
        filename = os.path.join(self.BASE_DATA_PATH,
                                'recurrence_table_test_A.csv')
        self.true_tableA = np.genfromtxt(filename, delimiter = ',')

        # Read the verification table A
        filename = os.path.join(self.BASE_DATA_PATH,
                                'recurrence_table_test_B.csv')
        self.true_tableB = np.genfromtxt(filename, delimiter = ',')

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def test_input_checks_sets_magnitude_interval(self):
     fake_completeness_table = 0.0
     catalogue = Catalogue.make_from_dict({'year': [1900]})
     config = {'magnitude_interval' : 0.1}
     cmag, ctime, ref_mag, dmag, _ = rec_utils.input_checks(catalogue,
             config, fake_completeness_table)
     self.assertEqual(0.1, dmag)

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def test_kijko_smit_set_reference_magnitude(self):
     completeness_table = np.array([[1900, 1.0]])
     catalogue = Catalogue.make_from_dict(
         {'magnitude': np.array([5.0, 6.0]),
          'year': np.array([2000, 2000])})
     config = {'reference_magnitude': 0.0}
     self.ks_ml.calculate(catalogue, config, completeness_table)

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def test_input_checks_use_reference_magnitude(self):
     fake_completeness_table = 0.0
     catalogue = Catalogue.make_from_dict({'year': [1900]})
     config = {'reference_magnitude' : 3.0}
     cmag, ctime, ref_mag, dmag, _ = rec_utils.input_checks(catalogue,
             config, fake_completeness_table)
     self.assertEqual(3.0, ref_mag)

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def setUp(self):
     """
     This generates a minimum data-set to be used for the regression.
     """
     # Test A: Generates a data set assuming b=1 and N(m=4.0)=10.0 events
     self.dmag = 0.1
     mext = np.arange(4.0, 7.01, 0.1)
     self.mval = mext[0:-1] + self.dmag / 2.0
     self.bval = 1.0
     self.numobs = np.flipud(
         np.diff(np.flipud(10.0 ** (-self.bval * mext + 8.0))))
     # Test B: Generate a completely artificial catalogue using the
     # Gutenberg-Richter distribution defined above
     numobs = np.around(self.numobs)
     size = int(np.sum(self.numobs))
     magnitude = np.zeros(size)
     lidx = 0
     for mag, nobs in zip(self.mval, numobs):
         uidx = int(lidx+nobs)
         magnitude[lidx:uidx] = mag + 0.01
         lidx = uidx
     year = np.ones(size) * 1999
     self.catalogue = Catalogue.make_from_dict(
         {'magnitude': magnitude, 'year': year})
     # Create the seismicity occurrence calculator
     self.aki_ml = AkiMaxLikelihood()

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
def build_catalogue_from_file(filename):
    """
    Creates a "minimal" catalogue from a raw csv file
    """
    raw_data = np.genfromtxt(filename, delimiter=",")
    neq = raw_data.shape[0]
    return Catalogue.make_from_dict({"eventID": raw_data[:, 0].astype(int),
                                     "year": raw_data[:, 1].astype(int),
                                     "dtime": raw_data[:, 2],
                                     "longitude": raw_data[:, 3],
                                     "latitude": raw_data[:, 4],
                                     "magnitude": raw_data[:, 5],
                                     "depth": raw_data[:, 6]})

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def test_generate_synthetic_catalogues(self):
     '''
     Tests the hmtk.seismicity.occurence.utils function
     generate_synthetic_magnitudes
     '''
     bvals = []
     # Generate set of synthetic catalogues
     for i in range(0, 100):
         cat1 = rec_utils.generate_synthetic_magnitudes(4.5, 1.0, 4.0, 8.0,
                                                        1000)
         bvals.append(self.occur.calculate(
             Catalogue.make_from_dict(cat1))[0])
     bvals = np.array(bvals)
     self.assertAlmostEqual(np.mean(bvals), 1.0, 1)

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def test_generate_magnitudes(self):
     '''
     Tests the hmtk.seismicity.occurence.utils function
     generate_trunc_gr_magnitudes
     '''
     bvals = []
     # Generate set of synthetic catalogues
     for _ in range(0, 100):
         mags = rec_utils.generate_trunc_gr_magnitudes(1.0, 4.0, 8.0, 1000)
         cat = Catalogue.make_from_dict(
             {'magnitude': mags,
              'year': np.zeros(len(mags), dtype=int)})
         bvals.append(self.occur.calculate(cat)[0])
     bvals = np.array(bvals)
     self.assertAlmostEqual(np.mean(bvals), 1.0, 1)

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
    def setUp(self):
        """
        This generates a catalogue to be used for the regression.
        """
        # Generates a data set assuming b=1
        self.dmag = 0.1
        mext = np.arange(4.0,7.01,0.1)
        self.mval = mext[0:-1] + self.dmag / 2.0
        self.bval = 1.0
        numobs = np.flipud(np.diff(np.flipud(10.0**(-self.bval*mext+7.0))))

        # Define completeness window
        numobs[0:6] *= 10
        numobs[6:13] *= 20
        numobs[13:22] *= 50
        numobs[22:] *= 100

        compl = np.array([[1900, 1950, 1980, 1990], [6.34, 5.44, 4.74, 3.0]])
        print compl
        self.compl = compl.transpose()
        print 'completeness'
        print self.compl
        print self.compl.shape

        numobs = np.around(numobs)
        print numobs

        magnitude = np.zeros((np.sum(numobs)))
        year = np.zeros((np.sum(numobs))) * 1999

        lidx = 0
        for mag, nobs in zip(self.mval, numobs):
            uidx = int(lidx+nobs)
            magnitude[lidx:uidx] = mag + 0.01
            year_low = compl[0,np.min(np.nonzero(compl[1,:] < mag)[0])]
            year[lidx:uidx] = (year_low + np.random.rand(uidx-lidx) *
                    (2000-year_low))
            print '%.2f %.0f %.0f' % (mag,np.min(year[lidx:uidx]),
                                      np.max(year[lidx:uidx]))
            lidx = uidx

        self.catalogue = Catalogue.make_from_dict(
            {'magnitude': magnitude, 'year': year})
        self.b_ml = BMaxLikelihood()
        self.config = {'Average Type' : 'Weighted'}

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def setUp(self):
     """
     This generates a catalogue to be used for the regression.
     """
     # Generates a data set assuming b=1
     self.dmag = 0.1
     mext = np.arange(4.0,7.01,0.1)
     self.mval = mext[0:-1] + self.dmag / 2.0
     self.bval = 1.0
     numobs = np.flipud(np.diff(np.flipud(10.0**(-self.bval*mext+7.0))))
     # Compute the number of observations in the different magnitude
     # intervals (according to completeness) 
     numobs[0:6] *= 10
     numobs[6:13] *= 20
     numobs[13:22] *= 50
     numobs[22:] *= 100
     # Define completeness window
     compl = np.array([[1900, 1950, 1980, 1990], [6.34, 5.44, 4.74, 3.0]])
     self.compl = np.flipud(compl.transpose())
     # Compute the number of observations (i.e. earthquakes) in each
     # magnitude bin
     numobs = np.around(numobs)
     magnitude = np.zeros( (np.sum(numobs)) )
     year = np.zeros( (np.sum(numobs)) ) * 1999
     # Generate the catalogue
     lidx = 0
     for mag, nobs in zip(self.mval, numobs):
         uidx = int(lidx+nobs)
         magnitude[lidx:uidx] = mag + 0.01
         year_low = compl[0,np.min(np.nonzero(compl[1,:] < mag)[0])]
         year[lidx:uidx] = (year_low + np.random.rand(uidx-lidx) *
                 (2000-year_low))
         lidx = uidx
     # Fix the parameters that later will be used for the testing
     self.catalogue = Catalogue.make_from_dict(
         {'magnitude' : magnitude, 'year' : year})
     self.wei = Weichert()
     self.config = {'Average Type' : 'Weighted'}

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
    def update_selection(self):
        """
        :returns: a catalogue holding the selection
        """
        initial = catalogue = self.catalogue_model.catalogue

        if not self.selection_editor.selectorList.count():
            self.catalogue_map.select([])
        else:
            for i in range(self.selection_editor.selectorList.count()):
                selector = self.selection_editor.selectorList.item(i)
                if (not self.intersect_with_selection and not
                    isinstance(selector, Invert)):
                    union_data = selector.apply(initial, initial).data
                    if initial != catalogue:
                        union_data['eventID'] = numpy.append(
                            union_data['eventID'], catalogue.data['eventID'])
                        union_data['year'] = numpy.append(
                            union_data['year'], catalogue.data['year'])
                    catalogue = Catalogue.make_from_dict(union_data)
                else:
                    catalogue = selector.apply(catalogue, initial)
            self.catalogue_map.select(catalogue.data['eventID'])

        features_num = len(
            self.catalogue_map.catalogue_layer.selectedFeatures())
        if not features_num:
            self.selection_editor.selectorSummaryLabel.setText(
                "No event selected")
        elif features_num == initial.get_number_events():
            self.selection_editor.selectorSummaryLabel.setText(
                "All events selected")
        else:
            self.selection_editor.selectorSummaryLabel.setText(
                "%d events selected" % features_num)

        return catalogue

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def test_input_checks_use_a_float_for_completeness(self):
     fake_completeness_table = 0.0
     catalogue = Catalogue.make_from_dict({'year': [1900]})
     config = {}
     rec_utils.input_checks(catalogue, config, fake_completeness_table)

# 需要导入模块: from hmtk.seismicity.catalogue import Catalogue [as 别名]
# 或者: from hmtk.seismicity.catalogue.Catalogue import make_from_dict [as 别名]
 def test_input_checks_simple_input(self):
     completeness_table = [[1900, 2.0]]
     catalogue = Catalogue.make_from_dict(
         {'magnitude': [5.0, 6.0], 'year': [2000, 2000]})
     config = {}
     rec_utils.input_checks(catalogue, config, completeness_table)