def scenario_julia_call(scenario_info, start_index, end_index): """ Starts a Julia engine, runs the add_path file to load Julia code. Then, loads the data path and runs the scenario. :param dict scenario_info: scenario information. :param int start_index: start index. :param int end_index: end index. """ from julia.api import Julia jl = Julia(compiled_modules=False) from julia import Main from julia import REISE interval = int(scenario_info['interval'].split('H', 1)[0]) n_interval = int((end_index - start_index + 1) / interval) input_dir = os.path.join(const.EXECUTE_DIR, 'scenario_%s' % scenario_info['id']) output_dir = os.path.join(const.EXECUTE_DIR, 'scenario_%s/output/' % scenario_info['id']) REISE.run_scenario(interval=interval, n_interval=n_interval, start_index=start_index, inputfolder=input_dir, outputfolder=output_dir) Main.eval('exit()')
def run_julia(self): print("Loading Julia....") I = np.genfromtxt(self.us_exchanges_filename, delimiter=" ") age_fracs_with_name = np.genfromtxt(self.age_fracs_filename, delimiter=",") age_fracs = np.delete(age_fracs_with_name, 0, 1) employed = pd.read_csv(self.employment_filename, dtype={ "Sector": str, "Feb": np.int64 }) j.eval("using DataFrames") julia_formatted_employed = j.DataFrame(employed.to_dict(orient='list')) print("Starting Julia run...") j.include("CASES.jl") returned_result = j.main(I, age_fracs, julia_formatted_employed) print("Julia run complete.") cases_2 = returned_result[1] pickle.dump(cases_2, open(self.employment_filename + "_cases_2.bin", "wb")) cases_1 = returned_result[0] pickle.dump(cases_1, open(self.employment_filename + "_cases_1.bin", "wb")) self.results.append(cases_1) self.results.append(cases_2)
def __init__(self, metric_str): self.metric_str = metric_str # check name and args name_args = metric_str.split("@metric")[1].strip().split( "\n")[0].split() self.name = name_args[0] self.args = name_args[1:] # run on julia Main.eval(metric_str)
def import_diffeqpy(self): """Import diffeqpy using lazy loading and creates an attribute so that loading happens only if required and loads in parallel. """ try: if self.der_solver_type == "diffeqpy": DERModelType = OpenDSSData.config['myconfig']['DERModelType'] if six.PY3: tic = time.perf_counter() elif six.PY2: tic = time.clock() from diffeqpy import ode from julia import Sundials self.de = ode self.sundials = Sundials #from diffeqpy import de from julia import Main from julia import LinearAlgebra LinearAlgebra.BLAS.set_num_threads(18) #Set number of threads to be used by DiffEqPy if required OpenDSSData.log(level=20,msg="BLAS threads:{}".format(Main.eval("ccall((:openblas_get_num_threads64_, Base.libblas_name), Cint, ())"))) #Show number of threads being used by DiffEqPy if six.PY3: toc = time.perf_counter() elif six.PY2: toc = time.clock() OpenDSSData.log(level=10,msg="Time taken to import 'diffeqpy':{:.3f}".format(toc - tic)) except: OpenDSSData.log()
def inject_square_current(self, current): #, section = None, debug=False): """Inputs: current : a dictionary with exactly three items, whose keys are: 'amplitude', 'delay', 'duration' Example: current = {'amplitude':float*pq.pA, 'delay':float*pq.ms, 'duration':float*pq.ms}} where \'pq\' is a physical unit representation, implemented by casting float values to the quanitities \'type\'. Description: A parameterized means of applying current injection into defined Currently only single section neuronal models are supported, the neurite section is understood to be simply the soma. """ import numpy as np if 'injected_square_current' in current.keys(): c = current['injected_square_current'] else: c = current duration = float(c['duration']) #.rescale('ms')) delay = float(c['delay']) #.rescale('ms')) amp = float(c['amplitude']) #.rescale('uA') tmax = 1.3 #00 tmin = 0.0 DT = 0.025 T = np.linspace(tmin, tmax, int(tmax / DT)) Iext_ = [] for t in T: Iext_.append(Id(t, delay, duration, tmax, amp)) self.attrs['N'] = len(Iext_) self.set_attrs(self.attrs) Main.eval('pA = 0.001nA') Main.eval("SNN.monitor(E2, [:v])") Main.dur = current["duration"] Main.current = current Main.delay = float(current["delay"]) Main.temp_current = float(amp) Main.eval("E2.I = [deepcopy(temp_current)*pA]") #Main.eval("@show(E2.I)") Main.eval( 'SNN.sim!([E2], []; dt =' + str(DT) + '*ms, delay=delay,stimulus_duration=1000,simulation_duration = 1300)' ) #Main.eval('SNN.sim!([E2], []; dt = 0.015*ms, delay=current["delay"]*ms,stimulus_duration=1000*ms,simulation_duration = 1300*ms)') Main.eval("v = SNN.getrecord(E2, :v)") v = Main.v #Main.eval('SNN.vecplot(E2, :v) |> display') self.vM = AnalogSignal(v, units=pq.mV, sampling_period=DT * pq.ms) return self.vM
def _call_pandamodels(buffer_file, julia_file, dev_mode): # pragma: no cover try: import julia from julia import Main from julia import Pkg from julia import Base except ImportError: raise ImportError( "Please install pyjulia properly to run pandapower with PandaModels.jl." ) try: julia.Julia() except: raise UserWarning( "Could not connect to julia, please check that Julia is installed and pyjulia is correctly configured" ) if not Base.find_package("PandaModels"): logger.info( "PandaModels.jl is not installed in julia. It is added now!") Pkg.Registry.update() Pkg.add("PandaModels") if dev_mode: logger.info("installing dev mode is a slow process!") Pkg.resolve() Pkg.develop("PandaModels") # add pandamodels dependencies: slow process Pkg.instantiate() Pkg.build() Pkg.resolve() logger.info("Successfully added PandaModels") if dev_mode: Pkg.develop("PandaModels") Pkg.build() Pkg.resolve() Pkg.activate("PandaModels") try: Main.using("PandaModels") except ImportError: raise ImportError("cannot use PandaModels") Main.buffer_file = buffer_file result_pm = Main.eval(julia_file + "(buffer_file)") # if dev_mode: # Pkg.activate() # Pkg.free("PandaModels") # Pkg.resolve() return result_pm
def set_attrs(self, attrs): JUIZI = { 'a': 0.02, 'b': 0.2, 'c': -65, 'd': 8, } if not len(attrs): attrs = JUIZI Main.attrs = attrs Main.eval('param = SNN.IZParameter(;a = attrs["a"], b = attrs["b"], c = attrs["c"], d = attrs["d"])') self.attrs.update(attrs) #Main.N_ = attrs["N"] Main.eval('E2 = SNN.IZ(;N = 1, param = param)') Main.eval("N = Int32(1)")
def jl(src, locals=None, globals=None): """ Execute some Julia code and return the answer. The Julia code is executed in the top-level of Julia's Main module. You can interpolate Python values into the Julia expression in the same way as with `%julia` magic for IPython, and scoping behaves the same way as well. See: https://pyjulia.readthedocs.io/en/latest/usage.html#ipython-magic """ if locals is None: locals = get_caller_locals() if globals is None: globals = get_caller_globals() src = unicode(src) return_value = "nothing" if src.strip().endswith(";") else "" return Main.eval(""" _PyJuliaHelper.@prepare_for_pyjulia_call begin begin %s end %s end """ % (src, return_value))(globals, locals)