def sample_source_model_logictree(self, random_seed, mfd_bin_width): """ Perform a Monte-Carlo sampling of source model logic tree. :param random_seed: An integer random seed value to initialize random generator before doing random sampling. :param mfd_bin_width: Float, the width of sources' MFD histograms bins. :return: String, json-serialized source model sample. For serialization the java class ``org.gem.JsonSerializer`` is used. """ rnd = random.Random(random_seed) sm_reader = jvm().JClass('org.gem.engine.hazard.' 'parsers.SourceModelReader') branch = self.source_model_lt.root_branchset.sample(rnd) sources = sm_reader(branch.value, float(mfd_bin_width)).read() while True: branchset = branch.child_branchset if branchset is None: break branch = branchset.sample(rnd) for source in sources: branchset.apply_uncertainty(branch.value, source) serializer = jvm().JClass('org.gem.JsonSerializer') return serializer.getJsonSourceList(sources)
def __init__(self, src_model_path, mfd_bin_width=DEFAULT_MFD_BIN_WIDTH, owner_id=1, input_id=None): """ :param src_model_path: path to a source model file :type src_model_path: str :param mfd_bin_width: Magnitude Frequency Distribution bin width :type mfd_bin_width: float :param owner_id: ID of an admin.organization entity in the database. By default, the default 'GEM Foundation' group will be used. Note(LB): This is kind of ugly and needs to be revisited later. :param int input_id: The database key of the uploaded input file from which this source was extracted. Please note that the `input_id` will only be supplied when uploading source model files via the GUI. """ self.src_model_path = src_model_path self.mfd_bin_width = mfd_bin_width self.owner_id = owner_id self.input_id = input_id # Java SourceModelReader object java.jvm().java.lang.System.setProperty( "openquake.nrml.schema", xml.nrml_schema_file()) self.src_reader = java.jclass('SourceModelReader')( self.src_model_path, self.mfd_bin_width)
def preloader(self, *args, **kwargs): """Validate job""" self.cache = java.jclass("KVS")( settings.KVS_HOST, settings.KVS_PORT) self.calc = java.jclass("LogicTreeProcessor")( self.cache, self.key) java.jvm().java.lang.System.setProperty("openquake.nrml.schema", xml.nrml_schema_file()) return fn(self, *args, **kwargs)
def preloader(self, *args, **kwargs): """Validate job""" self.cache = java.jclass("KVS")( config.get("kvs", "host"), int(config.get("kvs", "port"))) self.calc = java.jclass("LogicTreeProcessor")( self.cache, self.key) java.jvm().java.lang.System.setProperty("openquake.nrml.schema", xml.nrml_schema_file()) return fn(self, *args, **kwargs)
def test_jvm_memmax_setting_is_not_passed(self): """Do not pass -Xmx to the jvm.""" with helpers.patch("jpype.startJVM") as startjvm_mock: with helpers.patch("jpype.isJVMStarted") as isjvmstarted_mock: # Make sure that startJVM() gets called. isjvmstarted_mock.side_effect = lambda: False with helpers.patch("openquake.java.init_logs"): java.jvm() args, _ = startjvm_mock.call_args self.assertFalse(filter(lambda a: a.startswith("-Xmx"), args))
def setUpClass(cls): # This is safe to call even if the jvm was already running from a # previous test. # Even better would be to start with a fresh jvm but this is currently # not possible (see # http://jpype.sourceforge.net/doc/user-guide/userguide.html#limitation # ) java.jvm() # save the java stdout and stderr that will be trashed during this test cls.old_java_out = jpype.java.lang.System.out cls.old_java_err = jpype.java.lang.System.err
def __init__(self, *args, **kwargs): """ One-time setup stuff for this entire test case class. """ super(NrmlModelLoaderTestCase, self).__init__(*args, **kwargs) self.src_reader = java.jclass('SourceModelReader')( TEST_SRC_FILE, db_loader.SourceModelLoader.DEFAULT_MFD_BIN_WIDTH) java.jvm().java.lang.System.setProperty("openquake.nrml.schema", xml.nrml_schema_file()) self.sources = self.src_reader.read() self.simple, self.complex, self.area, self.point = self.sources
def test_jvm_memmax_setting_is_enforced(self): """The `-Xmx` property is passed to the JVM.""" with helpers.patch("jpype.startJVM") as startjvm_mock: with helpers.patch("jpype.isJVMStarted") as isjvmstarted_mock: # Make sure that startJVM() gets called. def side_effect(): isjvmstarted_mock.side_effect = lambda: True return False isjvmstarted_mock.side_effect = side_effect java.jvm() args, _ = startjvm_mock.call_args self.assertTrue( filter(lambda a: a.startswith("-Xmx"), args))
def _is_complexfault(cls, source): """ Return ``True`` if ``source`` is opensha source of complex fault type. """ classname = 'org.opensha.sha.earthquake.rupForecastImpl.' \ 'GEM1.SourceData.GEMSubductionFaultSourceData' return isinstance(source, jvm().JClass(classname))
def to_java(self): """Converts to a Java Site object""" jpype = java.jvm() loc_class = jpype.JClass("org.opensha.commons.geo.Location") site_class = jpype.JClass("org.opensha.commons.data.Site") # TODO(JMC): Support named sites? return site_class(loc_class(self.latitude, self.longitude))
def _is_gr_mfd(cls, mfd): """ Return ``True`` if ``mfd`` is opensha GR MFD object (and in particular not evenly discretized function). """ classname = 'org.opensha.sha.magdist.GutenbergRichterMagFreqDist' return isinstance(mfd, jvm().JClass(classname))
def _is_area(cls, source): """ Return ``True`` if ``source`` is opensha source of area type. """ classname = 'org.opensha.sha.earthquake.rupForecastImpl.' \ 'GEM1.SourceData.GEMAreaSourceData' return isinstance(source, jvm().JClass(classname))
def parameterize_sites(self, site_list): """Convert python Sites to Java Sites, and add default parameters.""" # TODO(JMC): There's Java code for this already, sets each site to have # the same default parameters jpype = java.jvm() jsite_list = java.jclass("ArrayList")() for x in site_list: site = x.to_java() vs30 = java.jclass("DoubleParameter")(jpype.JString("Vs30")) vs30.setValue(float(self.calc_proxy.params["REFERENCE_VS30_VALUE"])) depth25 = java.jclass("DoubleParameter")("Depth 2.5 km/sec") depth25.setValue(float(self.calc_proxy.params["REFERENCE_DEPTH_TO_2PT5KM_PER_SEC_PARAM"])) sadigh = java.jclass("StringParameter")("Sadigh Site Type") sadigh.setValue(self.calc_proxy.params["SADIGH_SITE_TYPE"]) depth1km = java.jclass("DoubleParameter")(jpype.JString("Depth 1.0 km/sec")) depth1km.setValue(float(self.calc_proxy.params["DEPTHTO1PT0KMPERSEC"])) vs30_type = java.jclass("StringParameter")("Vs30 Type") # Enum values must be capitalized in the Java domain! vs30_type.setValue(self.calc_proxy.params["VS30_TYPE"].capitalize()) site.addParameter(vs30) site.addParameter(depth25) site.addParameter(sadigh) site.addParameter(depth1km) site.addParameter(vs30_type) jsite_list.add(site) return jsite_list
def test_write_uhs_spectrum_data(self): # Test `write_uhs_spectrum_data`. # To start with, we need to write the 'container' records for the UHS # results: write_uh_spectra(self.job_ctxt) uhs_results = [] # The results we want to write to HDF5 uhs_result = java.jvm().JClass('org.gem.calc.UHSResult') # Build up a result list that we can pass to the function under test: for poe, uhs in self.UHS_RESULTS: uhs_results.append(uhs_result(poe, list_to_jdouble_array(uhs))) realization = 0 test_site = Site(0.0, 0.0) # Call the function under test write_uhs_spectrum_data( self.job_ctxt, realization, test_site, uhs_results) uhs_data = UhSpectrumData.objects.filter( uh_spectrum__uh_spectra__output__oq_job=( self.job.id)) self.assertEqual(len(self.UHS_RESULTS), len(uhs_data)) self.assertTrue(all([x.realization == 0 for x in uhs_data])) uhs_results_dict = dict(self.UHS_RESULTS) # keyed by PoE for uhs_datum in uhs_data: self.assertTrue( numpy.allclose(uhs_results_dict[uhs_datum.uh_spectrum.poe], uhs_datum.sa_values)) self.assertEqual(test_site.point.to_wkt(), uhs_datum.location.wkt)
def _get_exception(self): jpype = java.jvm() try: jpype.java.lang.Integer('foo') except jpype.JavaException, e: return e
def _parse_file(self, path): jpype = java.jvm() ltr = jpype.JClass('org.gem.engine.LogicTreeReader')(path) try: ltr.read() except jpype.JavaException, ex: opensha.unwrap_validation_error( jpype, ex, path)
def setUp(self): self.jvm = java.jvm() self.handler = logging.handlers.BufferingHandler(capacity=float('inf')) self.python_logger = logging.getLogger('java') self.python_logger.addHandler(self.handler) self.python_logger.setLevel(logging.DEBUG) jlogger_class = self.jvm.JClass("org.apache.log4j.Logger") self.root_logger = jlogger_class.getRootLogger() self.other_logger = jlogger_class.getLogger('other_logger')
def validate_uncertainty_value(self, node, branchset, value): """ See superclass' method for description and signature specification. Checks that the value is the name of the class inside java package :attr:`GMPE_PACKAGE` which implements interface :attr:`BASE_GMPE`. """ base_gmpe = jvm().JClass(self.BASE_GMPE) try: gmpe = jvm().JClass('%s.%s' % (self.GMPE_PACKAGE, value)) except jvm().JavaException: # Class not found pass else: if issubclass(gmpe, base_gmpe): # Class exists and implements the proper interface. return value raise ValidationError(node, self.filename, self.basepath, 'gmpe %r is not available' % value)
def store_gmpe_map(self, seed): """Generates a hash of tectonic regions and GMPEs, using the logic tree specified in the job config file.""" key = kvs.generate_product_key(self.id, kvs.tokens.GMPE_TOKEN) print "GMPE map key is", key jpype = java.jvm() try: self.calc.sampleAndSaveGMPETree(self.cache, key, seed) except jpype.JException(jpype.java.lang.RuntimeException), ex: unwrap_validation_error( jpype, ex, self.params.get("GMPE_LOGIC_TREE_FILE_PATH"))
def tearDown(self): # reset Log4j config jvm = java.jvm() jvm.JClass("org.apache.log4j.BasicConfigurator").resetConfiguration() jvm.JClass("org.apache.log4j.BasicConfigurator").configure() # reset logging config cleanup_loggers() # restore process name multiprocessing.current_process().name = self.process_name
def _serialize_test_helper(self, test_file, expected_tables): engine = db_utils.get_db_session("hzrdi", "writer").connection().engine java.jvm().java.lang.System.setProperty("openquake.nrml.schema", xml.nrml_schema_file()) src_loader = db_loader.SourceModelLoader(test_file, engine) results = src_loader.serialize() # we should get a 3 item list of results self.assertEquals(3, len(results)) # We expect there to have been 3 inserts. # The results are a list of dicts with a single key. # The key is the table name (including table space); # the value is the id (as an int) of the new record. # First, check that the results includes the 3 tables we expect: result_tables = [x.keys()[0] for x in results] self.assertEqual(expected_tables, result_tables) # Everything appears to be fine, but let's query the database to make # sure the expected records are there. # At this point, we're not going to check every single value; we just # want to make sure the records made it into the database. tables = src_loader.meta.tables # list of tuples of (table name, id) table_id_pairs = [x.items()[0] for x in results] for table_name, record_id in table_id_pairs: table = tables[table_name] # run a query against the table object to get a ResultProxy result_proxy = table.select(table.c.id == record_id).execute() # there should be 1 record here self.assertEqual(1, result_proxy.rowcount) # clean up db resources src_loader.close()
def validate_uncertainty_value(self, node, branchset, value): """ See superclass' method for description and signature specification. Checks that the value is the name of the class inside java package :attr:`GMPE_PACKAGE` which implements interface :attr:`BASE_GMPE`. """ base_gmpe = jvm().JClass(self.BASE_GMPE) try: gmpe = jvm().JClass('%s.%s' % (self.GMPE_PACKAGE, value)) except jvm().JavaException: # Class not found pass else: if issubclass(gmpe, base_gmpe): # Class exists and implements the proper interface. return value raise ValidationError( node, self.filename, self.basepath, 'gmpe %r is not available' % value )
def setUp(self): # starting the jvm... print "About to start the jvm..." jpype = java.jvm() java_class = jpype.JClass("org.gem.engine.hazard.redis.Cache") print ("Not dead yet, and found the class...") self.java_client = java_class(settings.KVS_HOST, settings.KVS_PORT) self.python_client = kvs.get_client(binary=False) self.reader = reader.Reader(self.python_client) self._delete_test_file()
def setUp(self): # starting the jvm... print "About to start the jvm..." jpype = java.jvm() java_class = jpype.JClass("org.gem.engine.hazard.redis.Cache") print("Not dead yet, and found the class...") self.java_client = java_class(settings.KVS_HOST, settings.KVS_PORT) self.python_client = kvs.get_client(binary=False) self.reader = reader.Reader(self.python_client) self._delete_test_file()
def setUp(self): # starting the jvm... print "About to start the jvm..." jpype = java.jvm() java_class = jpype.JClass("org.gem.engine.hazard.redis.Cache") print "Not dead yet, and found the class..." self.java_client = java_class(config.get("kvs", "host"), int(config.get("kvs", "port"))) self.python_client = kvs.get_client() self.python_client.flushdb() self._delete_test_file()
def setUp(self): # starting the jvm... print "About to start the jvm..." jpype = java.jvm() java_class = jpype.JClass("org.gem.engine.hazard.redis.Cache") print "Not dead yet, and found the class..." self.java_client = java_class( config.get("kvs", "host"), int(config.get("kvs", "port"))) self.python_client = kvs.get_client() self.python_client.flushdb() self._delete_test_file()
def compute_ground_motion_fields(self, site_list, stochastic_set_id, seed): """Ground motion field calculation, runs on the workers.""" jpype = java.jvm() jsite_list = self.parameterize_sites(site_list) key = kvs.generate_product_key(self.id, kvs.tokens.STOCHASTIC_SET_TOKEN, stochastic_set_id) gmc = self.params['GROUND_MOTION_CORRELATION'] correlate = (gmc == "true" and True or False) java.jclass("HazardCalculator").generateAndSaveGMFs( self.cache, key, stochastic_set_id, jsite_list, self.generate_erf(), self.generate_gmpe_map(), java.jclass("Random")(seed), jpype.JBoolean(correlate))
def compute_hazard_curve(self, sites, realization): """ Compute hazard curves, write them to KVS as JSON, and return a list of the KVS keys for each curve. """ jpype = java.jvm() try: calc = java.jclass("HazardCalculator") poes_list = calc.getHazardCurvesAsJson( self.parameterize_sites(sites), self.generate_erf(), self.generate_gmpe_map(), self.get_iml_list(), float(self.params['MAXIMUM_DISTANCE'])) except jpype.JavaException, ex: unwrap_validation_error(jpype, ex)
def compute_ground_motion_fields(self, site_list, history, realization, seed): """Ground motion field calculation, runs on the workers.""" jpype = java.jvm() jsite_list = self.parameterize_sites(site_list) key = kvs.tokens.stochastic_set_key(self.job_ctxt.job_id, history, realization) correlate = self.job_ctxt['GROUND_MOTION_CORRELATION'] stochastic_set_id = "%s!%s" % (history, realization) java.jclass("HazardCalculator").generateAndSaveGMFs( self.cache, key, stochastic_set_id, jsite_list, self.generate_erf(), self.generate_gmpe_map(), java.jclass("Random")(seed), jpype.JBoolean(correlate))
def compute_ground_motion_fields(self, site_list, stochastic_set_id, seed): """Ground motion field calculation, runs on the workers.""" jpype = java.jvm() jsite_list = self.parameterize_sites(site_list) key = kvs.generate_product_key( self.id, kvs.tokens.STOCHASTIC_SET_TOKEN, stochastic_set_id) gmc = self.params['GROUND_MOTION_CORRELATION'] correlate = (gmc == "true" and True or False) java.jclass("HazardCalculator").generateAndSaveGMFs( self.cache, key, stochastic_set_id, jsite_list, self.generate_erf(), self.generate_gmpe_map(), java.jclass("Random")(seed), jpype.JBoolean(correlate))
def compute_hazard_curve(self, sites, realization): """ Compute hazard curves, write them to KVS as JSON, and return a list of the KVS keys for each curve. """ jpype = java.jvm() try: calc = java.jclass("HazardCalculator") poes_list = calc.getHazardCurvesAsJson( self.parameterize_sites(sites), self.generate_erf(), self.generate_gmpe_map(), general.get_iml_list( self.job_ctxt.imls, self.job_ctxt.params['INTENSITY_MEASURE_TYPE']), self.job_ctxt['MAXIMUM_DISTANCE']) except jpype.JavaException, ex: unwrap_validation_error(jpype, ex)
def set_gmpe_params(self, gmpe_map): """Push parameters from configuration file into the GMPE objects""" jpype = java.jvm() gmpe_lt_data = self.calc.createGmpeLogicTreeData() for tect_region in gmpe_map.keySet(): gmpe = gmpe_map.get(tect_region) gmpe_lt_data.setGmpeParams(self.params['COMPONENT'], self.params['INTENSITY_MEASURE_TYPE'], jpype.JDouble(float(self.params['PERIOD'])), jpype.JDouble(float(self.params['DAMPING'])), self.params['GMPE_TRUNCATION_TYPE'], jpype.JDouble(float(self.params['TRUNCATION_LEVEL'])), self.params['STANDARD_DEVIATION_TYPE'], jpype.JDouble(float(self.params['REFERENCE_VS30_VALUE'])), jpype.JObject(gmpe, java.jclass("AttenuationRelationship"))) gmpe_map.put(tect_region, gmpe)
def store_source_model(self, seed): """Generates an Earthquake Rupture Forecast, using the source zones and logic trees specified in the job config file. Note that this has to be done currently using the file itself, since it has nested references to other files.""" LOG.info("Storing source model from job config") key = kvs.generate_product_key(self.id, kvs.tokens.SOURCE_MODEL_TOKEN) print "source model key is", key jpype = java.jvm() try: self.calc.sampleAndSaveERFTree(self.cache, key, seed) except jpype.JException(jpype.java.lang.RuntimeException), ex: unwrap_validation_error( jpype, ex, self.params.get("SOURCE_MODEL_LOGIC_TREE_FILE_PATH"))
def setUp(self): # save and override process name self.process_name = multiprocessing.current_process().name multiprocessing.current_process().name = '->UnitTestProcess<-' # reset Log4j config jvm = java.jvm() jvm.JClass("org.apache.log4j.BasicConfigurator").resetConfiguration() # reset logging config cleanup_loggers() # setup AMQP logging logs.init_logs(log_type='amqp', level='debug') java.init_logs(log_type='amqp', level='debug') job.setup_job_logging('123')
def set_gmpe_params(gmpe_map, params): """Push parameters from the config file into the GMPE objects. :param gmpe_map: jpype instance of `HashMap<TectonicRegionType, ScalarIntensityMeasureRelationshipAPI>` :param dict params: job config params """ jpype = java.jvm() jd_float = lambda x: jpype.JDouble(float(x)) component = params.get("COMPONENT") imt = params.get("INTENSITY_MEASURE_TYPE") # PERIOD is not used in UHS calculations. period = jd_float(params.get("PERIOD")) if params.get("PERIOD") is not None else None damping = jd_float(params.get("DAMPING")) gmpe_trunc_type = params.get("GMPE_TRUNCATION_TYPE") trunc_level = jd_float(params.get("TRUNCATION_LEVEL")) stddev_type = params.get("STANDARD_DEVIATION_TYPE") j_set_gmpe_params = java.jclass("GmpeLogicTreeData").setGmpeParams for tect_region in gmpe_map.keySet(): gmpe = gmpe_map.get(tect_region) # There are two overloads for this method; one with 'period'... if period is not None: j_set_gmpe_params( component, imt, period, damping, gmpe_trunc_type, trunc_level, stddev_type, jpype.JObject(gmpe, java.jclass("AttenuationRelationship")), ) # ... and one without. else: j_set_gmpe_params( component, imt, damping, gmpe_trunc_type, trunc_level, stddev_type, jpype.JObject(gmpe, java.jclass("AttenuationRelationship")), ) gmpe_map.put(tect_region, gmpe)
def parameterize_sites(self, site_list): """Convert python Sites to Java Sites, and add default parameters.""" # TODO(JMC): There's Java code for this already, sets each site to have # the same default parameters jpype = java.jvm() jsite_list = java.jclass("ArrayList")() for x in site_list: site = x.to_java() vs30 = java.jclass("DoubleParameter")(jpype.JString("Vs30")) vs30.setValue(float(self.params['REFERENCE_VS30_VALUE'])) depth25 = java.jclass("DoubleParameter")("Depth 2.5 km/sec") depth25.setValue( float(self.params['REFERENCE_DEPTH_TO_2PT5KM_PER_SEC_PARAM'])) sadigh = java.jclass("StringParameter")("Sadigh Site Type") sadigh.setValue(self.params['SADIGH_SITE_TYPE']) site.addParameter(vs30) site.addParameter(depth25) site.addParameter(sadigh) jsite_list.add(site) return jsite_list
def set_gmpe_params(gmpe_map, params): """Push parameters from the config file into the GMPE objects. :param gmpe_map: jpype instance of `HashMap<TectonicRegionType, ScalarIntensityMeasureRelationshipAPI>` :param dict params: job config params """ jpype = java.jvm() jd_float = lambda x: jpype.JDouble(float(x)) component = params.get('COMPONENT') imt = params.get('INTENSITY_MEASURE_TYPE') # PERIOD is not used in UHS calculations. period = (jd_float(params.get('PERIOD')) if params.get('PERIOD') is not None else None) damping = jd_float(params.get('DAMPING')) gmpe_trunc_type = params.get('GMPE_TRUNCATION_TYPE') trunc_level = jd_float(params.get('TRUNCATION_LEVEL')) stddev_type = params.get('STANDARD_DEVIATION_TYPE') j_set_gmpe_params = java.jclass("GmpeLogicTreeData").setGmpeParams for tect_region in gmpe_map.keySet(): gmpe = gmpe_map.get(tect_region) # There are two overloads for this method; one with 'period'... if period is not None: j_set_gmpe_params( component, imt, period, damping, gmpe_trunc_type, trunc_level, stddev_type, jpype.JObject(gmpe, java.jclass("AttenuationRelationship"))) # ... and one without. else: j_set_gmpe_params( component, imt, damping, gmpe_trunc_type, trunc_level, stddev_type, jpype.JObject(gmpe, java.jclass("AttenuationRelationship"))) gmpe_map.put(tect_region, gmpe)
def parameterize_sites(self, site_list): """Set vs30, vs30 type, z1pt0, z2pt5, and sadigh site type parameters on all input sites, returning a jpype `ArrayList` of OpenSHA `Site` objects. For vs30, vs30 type, z1pt0, and z2pt5: These params can be defined in general for the entire calculation. Alternatively, the calculation can define a `SITE_MODEL`, which supply site-specific parameters. This method handles both cases. NOTE: If a `SITE_MODEL` is used, it needs to be properly stored first. See :function:`~openquake.calculators.hazard.general.store_site_model`. :param site_list: `list` of :class:`~openquake.shapes.Site` objects. :returns: jpype `ArrayList` of `org.opensha.commons.data.Site` objects (with the above parameters set). """ # make sure the JVM is started java.jvm() # the return value jsite_list = java.jclass("ArrayList")() job_profile = self.job_ctxt.oq_job_profile # The `sadigh site type` is the same in any case sadigh_param = java.jclass("StringParameter")("Sadigh Site Type") sadigh_param.setValue( job_params.REVERSE_ENUM_MAP[job_profile.sadigh_site_type] ) site_model = get_site_model(self.job_ctxt.oq_job.id) if site_model is not None: # set site-specific parameters: for site in site_list: jsite = site.to_java() sm_data = get_closest_site_model_data(site_model, site) set_java_site_parameters(jsite, sm_data) # The sadigh site type param is not site specific, but we need # to set it anyway. jsite.addParameter(sadigh_param) jsite_list.add(jsite) else: # use the same parameters for all sites vs30_param = java.jclass("DoubleParameter")("Vs30") vs30_param.setValue(job_profile.reference_vs30_value) vs30_type_param = java.jclass("StringParameter")("Vs30 Type") vs30_type_param.setValue(job_profile.vs30_type.capitalize()) z1pt0_param = java.jclass("DoubleParameter")("Depth 1.0 km/sec") z1pt0_param.setValue(job_profile.depth_to_1pt_0km_per_sec) z2pt5_param = java.jclass("DoubleParameter")("Depth 2.5 km/sec") z2pt5_param.setValue( job_profile.reference_depth_to_2pt5km_per_sec_param ) for site in site_list: jsite = site.to_java() jsite.addParameter(vs30_param) jsite.addParameter(vs30_type_param) jsite.addParameter(z1pt0_param) jsite.addParameter(z2pt5_param) jsite.addParameter(sadigh_param) jsite_list.add(jsite) return jsite_list
def test(): jpype = java.jvm() jpype.java.lang.Integer('foo')
def jtask_task(data): """ Takes a single argument called `data` and might raise a Java exception. """ return str(java.jvm().java.lang.Integer(data))