def UpdateData(self): self.t[self.ptr] = time.time() - self.t[0] if self.bAcquiring: data_in = ctypes.c_longdouble( ) # double-precision IEEE floating point data from ADC if self.AIOUSB.ADC_GetChannelV(-3, 0, ctypes.byref(data_in)) is 0: self.xdata[self.ptr] = float( data_in.value) * 20 # Convert 0-5V to 0-100nm else: self.xdata[self.ptr] = 0 if self.AIOUSB.ADC_GetChannelV(-3, 1, ctypes.byref(data_in)) is 0: self.ydata[self.ptr] = float(data_in.value) * 20 else: self.ydata[self.ptr] = 0 if __debug__ and not self.bAcquiring: self.xdata[self.ptr] = (math.sin(self.t[self.ptr]) + 1) * 50 self.ydata[self.ptr] = (math.cos(self.t[self.ptr]) + 1) * 50 self.xsetdata[self.ptr] = self.xset * 100 / 65535 self.ysetdata[self.ptr] = self.yset * 100 / 65535 self.zsetdata[self.ptr] = self.zset * 100 / 65535 if self.ptr > self.datawindow: self.DataPlot(self.t[self.ptr - self.datawindow:self.ptr], self.xdata[self.ptr - self.datawindow:self.ptr], self.xsetdata[self.ptr - self.datawindow:self.ptr], self.ydata[self.ptr - self.datawindow:self.ptr], self.ysetdata[self.ptr - self.datawindow:self.ptr], self.zsetdata[self.ptr - self.datawindow:self.ptr]) self.ptr = self.ptr + 1
def get_power_ref(self): """ """ power = C.c_longdouble() result = self.tcio_dll_obj.TC4GetPowerRef(C.byref(power)) if (result != DLL_SUCCESS): print("TC4GetPowerRef failed") power = None return power.value
def read_longdouble(hProcess, address): ReadBuffer = ctypes.c_longdouble() lpBuffer = ctypes.byref(ReadBuffer) nSize = ctypes.sizeof(ReadBuffer) bytesRead = ctypes.c_ulong(0) ctypes.windll.kernel32.ReadProcessMemory(hProcess, address, lpBuffer, nSize, bytesRead) return ReadBuffer.value
def post(self, request): sex = request.POST.get('sex') age = request.POST.get('age') duration = float(request.POST.get('duration')) mri = request.POST.get('mri') cortisol = request.POST.get('cortisol') plasma = request.POST.get('plasma') # context = { # 'sex' : sex, # 'age' : age, # 'duration' : duration, # 'mri': mri, # 'cortisol' : cortisol, # 'plasma' : plasma # # } cort_m2 = ctypes.c_longdouble(numpy.longdouble(cortisol)) ach_m2 = ctypes.c_longdouble(numpy.longdouble(plasma)) age_ = ctypes.c_longdouble(numpy.longdouble(age)) duration_ = ctypes.c_longdouble(numpy.longdouble(duration)) sex_ = ctypes.c_float(float(sex)) mri_ = ctypes.c_float(float(mri)) answ = libc.mainfunc(cort_m2, ach_m2, age_, duration_, sex_, mri_) #answ = libc.mainfunc(cort_m2, ach_m2, age_, duration_, sex_, mri_) #resstring = alloc_func(cort_m2, ach_m2, age_, duration_, sex_, mri_) #answ2 = ctypes.c_char_p.from_buffer(resstring) if answ == 0: text = "Remission within 3 years" percent = "93% [89%, 96%]" elif answ == 1: text = "Recurrence within 3 years" percent = "93% [89%, 96%]" cont = { 'what_to_do' : '''alert('Hello! I am an alert box!! %s '); ''', 'answer': text, 'percents': percent } #free_func = libc.mainfunc #free_func.argtypes = [ctypes.POINTER(ctypes.c_char), ] #free_func(answ) return render(request, 'mainpage.html', cont)
def parse_longdouble(value): import ctypes from ctypes import c_longdouble, pointer val = c_longdouble() val_ptr = pointer(val) try: ctypes.cdll.LoadLibrary("libc.so.6").sscanf(value, "%Le", val_ptr) except WindowsError: return float(value) return np.ctypeslib.as_array(val_ptr, (1, ))[0]
def parse_longdouble(value): import ctypes from ctypes import c_longdouble, pointer val = c_longdouble() val_ptr = pointer(val) try: ctypes.cdll.LoadLibrary("libc.so.6").sscanf(value, "%Le", val_ptr) except WindowsError: return float(value) return np.ctypeslib.as_array(val_ptr, (1,))[0]
def get_voltage_act(self): """ Parameters: [out] p_vact Actual voltage value [V] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ vact = C.c_longdouble() result = self.tcio_dll_obj.TC4GetVoltageAct(C.byref(vact)) if (result != DLL_SUCCESS): print("TC4GetVoltageAct failed") vact = None return vact.value
def get_power_act(self): """ Parameters: [out] p_pact Actual power value [kW] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ pact = C.c_longdouble() result = self.tcio_dll_obj.TC4GetPowerAct(C.byref(pact)) if (result != DLL_SUCCESS): print("TC4GetPowerAct failed") pact = None return pact.value
def get_resistance_ref(self): """ Parameters: [out] rref PhysicalResistance [mOhm] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ resistance = C.c_longdouble() result = self.tcio_dll_obj.TC4GetResistanceRef(C.byref(resistance)) if (result != DLL_SUCCESS): print("TC4GetResistanceRef failed") resistance = None return resistance.value
def get_current_act(self): """ Parameters: [out] p_iact Actual current value [A] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ iact = C.c_longdouble() result = self.tcio_dll_obj.TC4GetCurrentAct(C.byref(iact)) if (result != DLL_SUCCESS): print("TC4GetCurrentAct failed") iact = None return iact.value
def get_current_ref(self): """ Parameters: [out] iref PhysicalCurrent [A] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ current = C.c_longdouble() result = self.tcio_dll_obj.TC4GetCurrentRef(C.byref(current)) if (result != DLL_SUCCESS): print("TC4GetCurrentRef failed") current = None return current.value
def set_power_ref(self, pref): """ Parameters: [out] rref PhysicalResistance [mOhm] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ pref_double = C.c_longdouble() pref_double.value = float(pref) result = self.tcio_dll_obj.TC4GetPowerRef(C.byref(pref_double)) if (result != DLL_SUCCESS): print("TC4GetPowerRef failed") pref_double = None return pref_double.value
def get_Q4_limit_current(self): """ Get Q4 controller current limit (parameter will be negative) Parameters: [out] pCurrent PhysicalCurrent [A] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ current = C.c_longdouble() result = self.tcio_dll_obj.TC4GetQ4LimitCurrent(C.byref(current)) if (result != DLL_SUCCESS): print("DllClose failed") current = None return current
def get_Q4_limit_power(self): """ Get Q4 controller power limit (parameter will be negative) Parameters: [out] pPower PhysicalPower [kW] Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ power = C.c_longdouble() result = self.tcio_dll_obj.TC4GetQ4LimitPower(C.byref(power)) if (result != DLL_SUCCESS): print("TC4GetQ4LimitPower failed") power = None return power
def get_resistance_act(self): """ Parameters: [out] p_ract Actual simulated resistance value Note: resistance is not measured - this will just read the set value Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ ract = C.c_longdouble() result = self.tcio_dll_obj.TC4GetResistanceAct(C.byref(ract)) if (result != DLL_SUCCESS): print("TC4GetResistanceAct failed") ract = None return ract.value
def set_voltage_ref(self, vref): """ Parameters: [in] vref PhysicalVoltage [V] Precondition: Remote control input must be set to RS232 Note: Calling these functions on a TopCon Slave will have no effect. Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ vref_double = C.c_longdouble() vref_double.value = float(vref) result = self.tcio_dll_obj.TC4SetVoltageRef(vref_double) if (result != DLL_SUCCESS): print("TC4SetVoltageRef failed") return vref_double.value
def set_resistance_ref(self, rref): """ Parameters: [in] rref PhysicalResistance [mOhm] Precondition: Remote control input must be set to RS232 Note: Calling these functions on a TopCon Slave will have no effect. Returns: DLL_SUCCESS for success or DLL_FAIL or other value if an error occurs """ rref_double = C.c_longdouble() rref_double.value = rref result = self.tcio_dll_obj.TC4SetResistanceRef(rref_double) if (result != DLL_SUCCESS): print("TC4SetResistanceRef failed") return result.value
from io import StringIO as TextIO # built-in functions (CH 2) a['ByteArrayType'] = bytearray([1]) # numeric and mathematical types (CH 9) a['FractionType'] = fractions.Fraction() a['NumberType'] = numbers.Number() # generic operating system services (CH 15) a['IOBaseType'] = io.IOBase() a['RawIOBaseType'] = io.RawIOBase() a['TextIOBaseType'] = io.TextIOBase() a['BufferedIOBaseType'] = io.BufferedIOBase() a['UnicodeIOType'] = TextIO() # the new StringIO a['LoggingAdapterType'] = logging.LoggingAdapter(_logger,_dict) # pickle ok if HAS_CTYPES: a['CBoolType'] = ctypes.c_bool(1) a['CLongDoubleType'] = ctypes.c_longdouble() except ImportError: pass try: # python 2.7 import argparse # data types (CH 8) a['OrderedDictType'] = collections.OrderedDict(_dict) a['CounterType'] = collections.Counter(_dict) if HAS_CTYPES: a['CSSizeTType'] = ctypes.c_ssize_t() # generic operating system services (CH 15) a['NullHandlerType'] = logging.NullHandler() # pickle ok # new 2.7 a['ArgParseFileType'] = argparse.FileType() # pickle ok #except AttributeError: except ImportError: pass
calculating = True mandel = None arrlen = width * height cwidth = c_uint(int(width)) cheight = c_uint(int(height)) lib.mandelbrot.restype = ctypes.POINTER(c_uint32 * arrlen) while True: if calculating: cresult = lib.mandelbrot( cwidth, cheight, c_longdouble(center[0] - mandel_range), c_longdouble(center[0] + mandel_range), c_longdouble(center[1] - mandel_range), c_longdouble(center[1] + mandel_range), c_uint32(int(max_iter)), c_longdouble(div_range), (ctypes.c_longdouble * len(coeffs))(*coeffs), (ctypes.c_longdouble * len(powers))(*powers), c_size_t(len(coeffs)), ) mandel = np.array(cresult.contents).reshape((width, height)) cmap = matplotlib.cm.get_cmap(cmaps[cmap_sel_ind], lut=max_iter) canvas = (cmap(mandel)[..., :3] * 255).astype("uint8") man = pygame.image.frombuffer(canvas.tobytes(), size, "RGB") screen.blit(man, (0, 0))
# built-in functions (CH 2) a["ByteArrayType"] = bytearray([1]) # numeric and mathematical types (CH 9) a["FractionType"] = fractions.Fraction() a["NumberType"] = numbers.Number() # generic operating system services (CH 15) a["IOBaseType"] = io.IOBase() a["RawIOBaseType"] = io.RawIOBase() a["TextIOBaseType"] = io.TextIOBase() a["BufferedIOBaseType"] = io.BufferedIOBase() a["UnicodeIOType"] = TextIO() # the new StringIO a["LoggingAdapterType"] = logging.LoggingAdapter(_logger, _dict) # pickle ok if HAS_CTYPES: a["CBoolType"] = ctypes.c_bool(1) a["CLongDoubleType"] = ctypes.c_longdouble() except ImportError: pass try: # python 2.7 import argparse # data types (CH 8) a["OrderedDictType"] = collections.OrderedDict(_dict) a["CounterType"] = collections.Counter(_dict) if HAS_CTYPES: a["CSSizeTType"] = ctypes.c_ssize_t() # generic operating system services (CH 15) a["NullHandlerType"] = logging.NullHandler() # pickle ok # new 2.7 a["ArgParseFileType"] = argparse.FileType() # pickle ok # except AttributeError: except ImportError:
d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_ushort(0x02) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_long(0x03) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_ulong(0x0A) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_int(0x0B) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_uint(0x0C) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_float(0x0D) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_double(0x0E) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_longdouble(0x0F) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_longlong(0x10) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_ulonglong(0x11) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_ubyte(0x12) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_byte(0x13) d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_char('a') d.msg += '<arg ' + get_arg_xml(v) + '></arg>' v = ctypes.c_wchar(u'b') d.msg += '<arg ' + get_arg_xml(v) + '></arg>' d.msg += '<arg ' + get_arg_xml("string test") + '></arg>'
def generate_models(network): ''' This method generates RACIPE models. ''' import numpy import numpy as np import ctypes import sys global clib node_dict = network.get_node_dict() node_id_dict = network.get_node_id_dict() edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() NUM_NODES = len(node_id_dict.keys()) #size of node_id_arr NUM_EDGES = len(edge_source_dict.keys()) #size of edge_id_arr #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create character array for work directory string: WORK_DIR = (network.get_work_dir()).encode('utf-8') #create character arrays for file names to be used in C: fname_dict_simu = network.get_fname_dict_simu() FNAME_STATES = fname_dict_simu['FNAME_STATES'].encode('utf-8') FNAME_LIMITCYCLES = fname_dict_simu['FNAME_LIMITCYCLES'].encode('utf-8') FNAME_SUMMARY = fname_dict_simu['FNAME_SUMMARY'].encode('utf-8') #create arrays for storing node and edge parameters: MPR_arr = np.zeros(NUM_NODES, dtype=np.double) DNR_arr = np.zeros(NUM_NODES, dtype=np.double) NODE_TYPE_arr = np.zeros(NUM_NODES, dtype=np.intc) TSH_arr = np.zeros(NUM_EDGES, dtype=np.double) HCO_arr = np.zeros(NUM_EDGES, dtype=np.intc) FCH_arr = np.zeros(NUM_EDGES, dtype=np.double) #create array for storing the types of the edges: edge_type_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_type_dict.keys(): edge_type_arr[i] = edge_type_dict[idx] i += 1 #open file to write parameters: params_fname = network.get_params_fname() fh_params = open(params_fname, 'w') #open files to write parameters: fh_dict_nodeparams = OrderedDict() fh_dict_edgeparams = OrderedDict() fh_dict_nodeparams, fh_dict_edgeparams = open_parameter_files(network) #open files to write solutions: fname_dict_solutions, fh_dict_solutions = open_solution_files(network) #open file to write limit cycle trace: LCtrace_fname = network.get_LCtrace_fname() fh_LCtrace = open(LCtrace_fname, 'w') #import config_dict: config_dict = network.get_config_dict() model_no = 1 while model_no <= int(config_dict['NUM_MODELS']): (nodeParam_dict, source_dict, master_dict) = set_parameters(network) i = 0 for X in nodeParam_dict.keys(): NODE_TYPE_arr[i] = nodeParam_dict[X][0] MPR_arr[i] = nodeParam_dict[X][1] #print(MPR_arr[i]) DNR_arr[i] = nodeParam_dict[X][2] i += 1 for idx, e in master_dict.items(): TSH_arr[idx] = master_dict[idx][3] HCO_arr[idx] = master_dict[idx][4] FCH_arr[idx] = master_dict[idx][5] EXP_dict_arr = np.zeros(NUM_NODES * int(config_dict['NUM_RANDOM_ICS']), dtype=np.double) #start_time=time.time() clib.find_solutions(\ ctypes.create_string_buffer(WORK_DIR), ctypes.create_string_buffer(FNAME_STATES), ctypes.create_string_buffer(FNAME_LIMITCYCLES), ctypes.create_string_buffer(FNAME_SUMMARY), ctypes.c_int(model_no), ctypes.c_int(NUM_NODES), ctypes.c_int(NUM_EDGES), ctypes.c_int(int(config_dict['NUM_RANDOM_ICS'])), ctypes.c_int(int(config_dict['ITER_FOR_ODE'])), ctypes.c_double(float(config_dict['EULER_SIM_TIME'])), ctypes.c_double(float(config_dict['EULER_SIM_STEP_SIZE'])), ctypes.c_longdouble(float(config_dict['CONVERGENCE_PROXIMITY'])), ctypes.c_double(float(config_dict['TRANS_RATE_FACTOR'])), ctypes.c_void_p(MPR_arr.ctypes.data), ctypes.c_void_p(DNR_arr.ctypes.data), ctypes.c_void_p(NODE_TYPE_arr.ctypes.data), ctypes.c_void_p(edge_source_arr.ctypes.data), ctypes.c_void_p(edge_target_arr.ctypes.data), ctypes.c_void_p(edge_type_arr.ctypes.data), ctypes.c_void_p(TSH_arr.ctypes.data), ctypes.c_void_p(HCO_arr.ctypes.data), ctypes.c_void_p(FCH_arr.ctypes.data), ctypes.c_void_p(EXP_dict_arr.ctypes.data) ) #end_time=time.time() #place the solutions in a dictionary: expression_dict = OrderedDict() expression_dict_ICs = OrderedDict() count_iteration = 0 for i in range(0, NUM_NODES * int(config_dict['NUM_RANDOM_ICS']), NUM_NODES): for node, node_id in node_id_dict.items(): expression_dict[node] = EXP_dict_arr[i + node_id] expression_dict_ICs[count_iteration] = expression_dict.copy() count_iteration += 1 (solution_dict, solution_count_dict) = count_states(config_dict, expression_dict_ICs, fh_LCtrace) save_parameters(fh_params, model_no, nodeParam_dict, master_dict, solution_dict) save_parameters_5(fh_dict_nodeparams, fh_dict_edgeparams, model_no, nodeParam_dict, master_dict, solution_dict) save_solutions(fh_dict_solutions, model_no, solution_dict) if (not model_no % 100): flush_solutions(fh_dict_solutions) model_no += 1 fh_params.close() fh_LCtrace.close() close_solution_files(fname_dict_solutions, fh_dict_solutions) close_parameter_files(fh_dict_nodeparams, fh_dict_edgeparams) return None
def cal_expressions(network): ''' This method generates RACIPE models. ''' import numpy import numpy as np import ctypes import sys global clib node_dict = network.get_node_dict() node_id_dict = network.get_node_id_dict() edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() NUM_NODES = len(node_id_dict.keys()) #size of node_id_arr NUM_EDGES = len(edge_source_dict.keys()) #size of edge_id_arr #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create character array for work directory string: WORK_DIR = (network.get_work_dir()).encode('utf-8') #create character arrays for file names to be used in C: fname_dict_simu = network.get_fname_dict_simu() FNAME_STATES = fname_dict_simu['FNAME_STATES'].encode('utf-8') FNAME_LIMITCYCLES = fname_dict_simu['FNAME_LIMITCYCLES'].encode('utf-8') FNAME_SUMMARY = fname_dict_simu['FNAME_SUMMARY'].encode('utf-8') #create arrays for storing node and edge parameters: MPR_arr = np.zeros(NUM_NODES, dtype=np.double) DNR_arr = np.zeros(NUM_NODES, dtype=np.double) NODE_TYPE_arr = np.zeros(NUM_NODES, dtype=np.intc) TSH_arr = np.zeros(NUM_EDGES, dtype=np.double) HCO_arr = np.zeros(NUM_EDGES, dtype=np.intc) FCH_arr = np.zeros(NUM_EDGES, dtype=np.double) #create array for storing node activities: NODE_ACT = np.zeros(NUM_NODES, dtype=np.intc) #create array for storing the types of the edges: edge_type_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_type_dict.keys(): edge_type_arr[i] = edge_type_dict[idx] i += 1 #open file to write parameters: params_fname = network.get_params_fname() fh_params = open(params_fname, 'w') #import config_dict: config_dict = network.get_config_dict() # initialize a dictionary: dict_act = OrderedDict() # get states activation from states file: fname_states_act = network.get_fname_states_act() fh_states = open(fname_states_act, 'r') # skip header: next(fh_states) # read line by line to place the activities into the dictionary: for line in fh_states: fields = line.strip().split("\t") key = fields[0] # model no as the key dict_act[key] = fields[3:len(fields)] model_no = 1 while model_no <= int(config_dict['NUM_MODELS']): (nodeParam_dict, source_dict, master_dict) = set_parameters(network) i = 0 for X in nodeParam_dict.keys(): NODE_TYPE_arr[i] = nodeParam_dict[X][0] MPR_arr[i] = nodeParam_dict[X][1] #print(MPR_arr[i]) DNR_arr[i] = nodeParam_dict[X][2] i += 1 for idx, e in master_dict.items(): TSH_arr[idx] = master_dict[idx][3] HCO_arr[idx] = master_dict[idx][4] FCH_arr[idx] = master_dict[idx][5] if str(model_no) not in dict_act.keys(): model_no = model_no + 1 continue #print(dict_act.get(str(model_no))) # put the expression in the array: EXP_arr = np.zeros(NUM_NODES, dtype=np.double) i = 0 for v in dict_act.get(str(model_no)): EXP_arr[i] = float(v) i = i + 1 #print(EXP_arr) #start_time=time.time() clib.cal_expressions(\ ctypes.create_string_buffer(WORK_DIR), ctypes.create_string_buffer(FNAME_STATES), ctypes.create_string_buffer(FNAME_LIMITCYCLES), ctypes.create_string_buffer(FNAME_SUMMARY), ctypes.c_int(model_no), ctypes.c_int(NUM_NODES), ctypes.c_int(NUM_EDGES), ctypes.c_int(int(config_dict['NUM_RANDOM_ICS'])), ctypes.c_int(int(config_dict['ITER_FOR_ODE'])), ctypes.c_double(float(config_dict['EULER_SIM_TIME'])), ctypes.c_double(float(config_dict['EULER_SIM_STEP_SIZE'])), ctypes.c_longdouble(float(config_dict['CONVERGENCE_PROXIMITY'])), ctypes.c_double(float(config_dict['TRANS_RATE_FACTOR'])), ctypes.c_void_p(MPR_arr.ctypes.data), ctypes.c_void_p(DNR_arr.ctypes.data), ctypes.c_void_p(NODE_TYPE_arr.ctypes.data), ctypes.c_void_p(edge_source_arr.ctypes.data), ctypes.c_void_p(edge_target_arr.ctypes.data), ctypes.c_void_p(edge_type_arr.ctypes.data), ctypes.c_void_p(TSH_arr.ctypes.data), ctypes.c_void_p(HCO_arr.ctypes.data), ctypes.c_void_p(FCH_arr.ctypes.data), ctypes.c_void_p(EXP_arr.ctypes.data) ) model_no += 1 return None
def attributeRoundTrip(self, file_ending): # write series = api.Series( "unittest_py_API." + file_ending, api.Access_Type.create ) # write one of each supported types series.set_attribute("char", 'c') # string series.set_attribute("pyint", 13) series.set_attribute("pyfloat", 3.1416) series.set_attribute("pystring", "howdy!") series.set_attribute("pystring2", str("howdy, too!")) series.set_attribute("pystring3", b"howdy, again!") series.set_attribute("pybool", False) # array of ... series.set_attribute("arr_pyint", (13, 26, 39, 52, )) series.set_attribute("arr_pyfloat", (1.2, 3.4, 4.5, 5.6, )) series.set_attribute("arr_pystring", ("x", "y", "z", "www", )) series.set_attribute("arr_pybool", (False, True, True, False, )) # list of ... series.set_attribute("l_pyint", [13, 26, 39, 52]) series.set_attribute("l_pyfloat", [1.2, 3.4, 4.5, 5.6]) series.set_attribute("l_pystring", ["x", "y", "z", "www"]) series.set_attribute("l_pybool", [False, True, True, False]) if found_numpy: series.set_attribute("int16", np.int16(234)) series.set_attribute("int32", np.int32(43)) series.set_attribute("int64", np.int64(987654321)) series.set_attribute("uint16", np.uint16(134)) series.set_attribute("uint32", np.uint32(32)) series.set_attribute("uint64", np.int64(9876543210)) series.set_attribute("single", np.single(1.234)) series.set_attribute("double", np.double(1.234567)) series.set_attribute("longdouble", np.longdouble(1.23456789)) # array of ... series.set_attribute("arr_int16", (np.int16(23), np.int16(26), )) series.set_attribute("arr_int32", (np.int32(34), np.int32(37), )) series.set_attribute("arr_int64", (np.int64(45), np.int64(48), )) series.set_attribute("arr_uint16", (np.uint16(23), np.uint16(26), )) series.set_attribute("arr_uint32", (np.uint32(34), np.uint32(37), )) series.set_attribute("arr_uint64", (np.uint64(45), np.uint64(48), )) series.set_attribute("arr_single", (np.single(5.6), np.single(5.9), )) series.set_attribute("arr_double", (np.double(6.7), np.double(7.1), )) # list of ... series.set_attribute("l_int16", [np.int16(23), np.int16(26)]) series.set_attribute("l_int32", [np.int32(34), np.int32(37)]) series.set_attribute("l_int64", [np.int64(45), np.int64(48)]) series.set_attribute("l_uint16", [np.uint16(23), np.uint16(26)]) series.set_attribute("l_uint32", [np.uint32(34), np.uint32(37)]) series.set_attribute("l_uint64", [np.uint64(45), np.uint64(48)]) series.set_attribute("l_single", [np.single(5.6), np.single(5.9)]) series.set_attribute("l_double", [np.double(6.7), np.double(7.1)]) series.set_attribute("l_longdouble", [np.longdouble(7.8e9), np.longdouble(8.2e3)]) # numpy.array of ... series.set_attribute("nparr_int16", np.array([234, 567], dtype=np.int16)) series.set_attribute("nparr_int32", np.array([456, 789], dtype=np.int32)) series.set_attribute("nparr_int64", np.array([678, 901], dtype=np.int64)) series.set_attribute("nparr_single", np.array([1.2, 2.3], dtype=np.single)) series.set_attribute("nparr_double", np.array([4.5, 6.7], dtype=np.double)) series.set_attribute("nparr_longdouble", np.array([8.9, 7.6], dtype=np.longdouble)) # c_types # TODO remove the .value and handle types directly? series.set_attribute("byte_c", ctypes.c_byte(30).value) series.set_attribute("ubyte_c", ctypes.c_ubyte(50).value) series.set_attribute("char_c", ctypes.c_char(100).value) # 'd' series.set_attribute("int16_c", ctypes.c_int16(2).value) series.set_attribute("int32_c", ctypes.c_int32(3).value) series.set_attribute("int64_c", ctypes.c_int64(4).value) series.set_attribute("uint16_c", ctypes.c_uint16(5).value) series.set_attribute("uint32_c", ctypes.c_uint32(6).value) series.set_attribute("uint64_c", ctypes.c_uint64(7).value) series.set_attribute("float_c", ctypes.c_float(8.e9).value) series.set_attribute("double_c", ctypes.c_double(7.e289).value) # TODO init of > e304 ? series.set_attribute("longdouble_c", ctypes.c_longdouble(6.e200).value) del series # read back series = api.Series( "unittest_py_API." + file_ending, api.Access_Type.read_only ) self.assertEqual(series.get_attribute("char"), "c") self.assertEqual(series.get_attribute("pystring"), "howdy!") self.assertEqual(series.get_attribute("pystring2"), "howdy, too!") self.assertEqual(bytes(series.get_attribute("pystring3")), b"howdy, again!") self.assertEqual(series.get_attribute("pyint"), 13) self.assertAlmostEqual(series.get_attribute("pyfloat"), 3.1416) self.assertEqual(series.get_attribute("pybool"), False) if found_numpy: self.assertEqual(series.get_attribute("int16"), 234) self.assertEqual(series.get_attribute("int32"), 43) self.assertEqual(series.get_attribute("int64"), 987654321) self.assertAlmostEqual(series.get_attribute("single"), 1.234) self.assertAlmostEqual(series.get_attribute("double"), 1.234567) self.assertAlmostEqual(series.get_attribute("longdouble"), 1.23456789) # array of ... (will be returned as list) self.assertListEqual(series.get_attribute("arr_int16"), [np.int16(23), np.int16(26), ]) # list of ... self.assertListEqual(series.get_attribute("l_int16"), [np.int16(23), np.int16(26)]) self.assertListEqual(series.get_attribute("l_int32"), [np.int32(34), np.int32(37)]) self.assertListEqual(series.get_attribute("l_int64"), [np.int64(45), np.int64(48)]) self.assertListEqual(series.get_attribute("l_uint16"), [np.uint16(23), np.uint16(26)]) self.assertListEqual(series.get_attribute("l_uint32"), [np.uint32(34), np.uint32(37)]) self.assertListEqual(series.get_attribute("l_uint64"), [np.uint64(45), np.uint64(48)]) # self.assertListEqual(series.get_attribute("l_single"), # [np.single(5.6), np.single(5.9)]) self.assertListEqual(series.get_attribute("l_double"), [np.double(6.7), np.double(7.1)]) self.assertListEqual(series.get_attribute("l_longdouble"), [np.longdouble(7.8e9), np.longdouble(8.2e3)]) # numpy.array of ... self.assertListEqual(series.get_attribute("nparr_int16"), [234, 567]) self.assertListEqual(series.get_attribute("nparr_int32"), [456, 789]) self.assertListEqual(series.get_attribute("nparr_int64"), [678, 901]) np.testing.assert_almost_equal( series.get_attribute("nparr_single"), [1.2, 2.3]) np.testing.assert_almost_equal( series.get_attribute("nparr_double"), [4.5, 6.7]) np.testing.assert_almost_equal( series.get_attribute("nparr_longdouble"), [8.9, 7.6]) # TODO instead of returning lists, return all arrays as np.array? # self.assertEqual( # series.get_attribute("nparr_int16").dtype, np.int16) # self.assertEqual( # series.get_attribute("nparr_int32").dtype, np.int32) # self.assertEqual( # series.get_attribute("nparr_int64").dtype, np.int64) # self.assertEqual( # series.get_attribute("nparr_single").dtype, np.single) # self.assertEqual( # series.get_attribute("nparr_double").dtype, np.double) # self.assertEqual( # series.get_attribute("nparr_longdouble").dtype, np.longdouble) # c_types self.assertEqual(series.get_attribute("byte_c"), 30) self.assertEqual(series.get_attribute("ubyte_c"), 50) self.assertEqual(chr(series.get_attribute("char_c")), 'd') self.assertEqual(series.get_attribute("int16_c"), 2) self.assertEqual(series.get_attribute("int32_c"), 3) self.assertEqual(series.get_attribute("int64_c"), 4) self.assertEqual(series.get_attribute("uint16_c"), 5) self.assertEqual(series.get_attribute("uint32_c"), 6) self.assertEqual(series.get_attribute("uint64_c"), 7) self.assertAlmostEqual(series.get_attribute("float_c"), 8.e9) self.assertAlmostEqual(series.get_attribute("double_c"), 7.e289) self.assertAlmostEqual(series.get_attribute("longdouble_c"), ctypes.c_longdouble(6.e200).value)
def simulate_network_cnoise(network, model_no, params_list): ''' This method generates RACIPE models. ''' global clib import numpy import numpy as np import ctypes import sys import modelManager as mm node_dict = network.get_node_dict() node_id_dict = network.get_node_id_dict() edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() NUM_NODES = len(node_id_dict.keys()) #size of node_id_arr NUM_EDGES = len(edge_source_dict.keys()) #size of edge_id_arr #create arrays for storing noise level for each node: NOISE_strength = np.zeros(NUM_NODES, dtype=np.double) NOISE_strength_shot = np.zeros(NUM_NODES, dtype=np.double) #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create character array for work directory string: WORK_DIR = (network.get_work_dir()).encode('utf-8') #create character arrays for file names to be used in C: fname_dict_simu = network.get_fname_dict_simu() #FNAME_STATES = fname_dict_simu['FNAME_STATES'].encode('utf-8') FNAME_STATES = fname_dict_simu['FNAME_STATES_CNOISE'].encode('utf-8') FNAME_LIMITCYCLES = fname_dict_simu['FNAME_LIMITCYCLES'].encode('utf-8') FNAME_SUMMARY = fname_dict_simu['FNAME_SUMMARY'].encode('utf-8') edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create array for storing the types of the edges: edge_type_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_type_dict.keys(): edge_type_arr[i] = edge_type_dict[idx] i += 1 # create arrays for storing the parameters: MPR_arr = params_list[0] DNR_arr = params_list[1] TSH_arr = params_list[2] HCO_arr = params_list[3] FCH_arr = params_list[4] NODE_TYPE_arr = np.zeros(NUM_NODES, dtype=np.intc) node_dict = network.get_node_dict() i = 0 for node in node_dict.keys(): (node_type, mpr_range, dnr_range) = node_dict[node] NODE_TYPE_arr[i] = node_type i = i + 1 #import config_dict: config_dict = network.get_config_dict() EXP_dict_arr = np.zeros(NUM_NODES * int(config_dict['NUM_RANDOM_ICS']), dtype=np.double) clib.simulate_network_cnoise_gnw(\ ctypes.create_string_buffer(WORK_DIR), ctypes.create_string_buffer(FNAME_STATES), ctypes.create_string_buffer(FNAME_LIMITCYCLES), ctypes.create_string_buffer(FNAME_SUMMARY), ctypes.c_int(model_no), ctypes.c_int(NUM_NODES), ctypes.c_int(NUM_EDGES), ctypes.c_int(int(config_dict['NUM_RANDOM_ICS'])), ctypes.c_int(int(config_dict['ITER_FOR_ODE'])), ctypes.c_double(float(config_dict['EULER_SIM_TIME'])), ctypes.c_double(float(config_dict['EULER_SIM_STEP_SIZE'])), ctypes.c_longdouble(float(config_dict['CONVERGENCE_PROXIMITY'])), ctypes.c_double(float(config_dict['TRANS_RATE_FACTOR'])), ctypes.c_void_p(MPR_arr.ctypes.data), ctypes.c_void_p(DNR_arr.ctypes.data), ctypes.c_void_p(NODE_TYPE_arr.ctypes.data), ctypes.c_void_p(edge_source_arr.ctypes.data), ctypes.c_void_p(edge_target_arr.ctypes.data), ctypes.c_void_p(edge_type_arr.ctypes.data), ctypes.c_void_p(TSH_arr.ctypes.data), ctypes.c_void_p(HCO_arr.ctypes.data), ctypes.c_void_p(FCH_arr.ctypes.data), ctypes.c_void_p(EXP_dict_arr.ctypes.data) ) return None
#!/usr/bin/python import sys, ctypes if sys.platform.startswith('linux'): libm = ctypes.cdll.LoadLibrary('libm.so.6') libc = ctypes.cdll.LoadLibrary('libc.so.6') elif sys.platform == 'darwin': libm = ctypes.cdll.LoadLibrary('libSystem.dylib') libc = libm elif sys.platform == 'win32': libm = ctypes.cdll.LoadLibrary('msvcr120.dll') libc = libm else: raise ImportError libm.sqrtl.restype = ctypes.c_longdouble n = ctypes.c_longdouble() z = int(sys.stdin.readline()) * 8 + 1 libc.sscanf(str(z), '%Lf', ctypes.byref(n)) n = libm.sqrtl(n) q = int(n) print('NO' if q * q != z else 'YES\n%d' % (q / 2))
#!/usr/bin/python import sys,ctypes if sys.platform.startswith('linux'): libm=ctypes.cdll.LoadLibrary('libm.so.6') libc=ctypes.cdll.LoadLibrary('libc.so.6') elif sys.platform=='darwin': libm=ctypes.cdll.LoadLibrary('libSystem.dylib') libc=libm elif sys.platform=='win32': libm=ctypes.cdll.LoadLibrary('msvcr120.dll') libc=libm else: raise ImportError libm.sqrtl.restype=ctypes.c_longdouble n=ctypes.c_longdouble() z=int(sys.stdin.readline())*8+1 libc.sscanf(str(z),'%Lf',ctypes.byref(n)) n=libm.sqrtl(n) q=int(n) print('NO' if q*q!=z else 'YES\n%d'%(q/2))
def cal_time_traj(network, model_no, params_list): ''' This method generates RACIPE models. ''' #global clib import numpy import numpy as np import ctypes import sys import modelManager as mm # Import library functions clib = ctypes.cdll.LoadLibrary('./pertParamSim.so') clib.randu.argtypes = (ctypes.c_double, ctypes.c_double) clib.randu.restype = ctypes.c_double #Import network attributes: node_dict = network.get_node_dict() node_id_dict = network.get_node_id_dict() edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() NUM_NODES = len(node_id_dict.keys()) #size of node_id_arr NUM_EDGES = len(edge_source_dict.keys()) #size of edge_id_arr #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create character array for work directory string: WORK_DIR = (network.get_work_dir()).encode('utf-8') #create character arrays for file names to be used in C: fname_dict_simu = network.get_fname_dict_simu() FNAME_STATES = fname_dict_simu['FNAME_STATES'].encode('utf-8') FNAME_LIMITCYCLES = fname_dict_simu['FNAME_LIMITCYCLES'].encode('utf-8') FNAME_SUMMARY = fname_dict_simu['FNAME_SUMMARY'].encode('utf-8') edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create array for storing the types of the edges: edge_type_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_type_dict.keys(): edge_type_arr[i] = edge_type_dict[idx] i += 1 # create arrays for storing the parameters: MPR_arr = params_list[0] DNR_arr = params_list[1] TSH_arr = params_list[2] HCO_arr = params_list[3] FCH_arr = params_list[4] print("cal_time_traj") print(MPR_arr) print(DNR_arr) print(TSH_arr) print(HCO_arr) print(FCH_arr) #sys.exit(0) NODE_TYPE_arr = np.zeros(NUM_NODES, dtype=np.intc) node_dict = network.get_node_dict() i = 0 for node in node_dict.keys(): (node_type, mpr_range, dnr_range) = node_dict[node] NODE_TYPE_arr[i] = node_type i = i + 1 #import config_dict: config_dict = network.get_config_dict() clib.find_traj_random_IC(\ ctypes.create_string_buffer(WORK_DIR), ctypes.create_string_buffer(FNAME_STATES), ctypes.create_string_buffer(FNAME_LIMITCYCLES), ctypes.create_string_buffer(FNAME_SUMMARY), ctypes.c_int(model_no), ctypes.c_int(NUM_NODES), ctypes.c_int(NUM_EDGES), ctypes.c_int(int(config_dict['NUM_RANDOM_ICS'])), ctypes.c_int(int(config_dict['ITER_FOR_ODE'])), ctypes.c_double(float(config_dict['EULER_SIM_TIME'])), ctypes.c_double(float(config_dict['EULER_SIM_STEP_SIZE'])), ctypes.c_longdouble(float(config_dict['CONVERGENCE_PROXIMITY'])), ctypes.c_double(float(config_dict['TRANS_RATE_FACTOR'])), ctypes.c_void_p(MPR_arr.ctypes.data), ctypes.c_void_p(DNR_arr.ctypes.data), ctypes.c_void_p(NODE_TYPE_arr.ctypes.data), ctypes.c_void_p(edge_source_arr.ctypes.data), ctypes.c_void_p(edge_target_arr.ctypes.data), ctypes.c_void_p(edge_type_arr.ctypes.data), ctypes.c_void_p(TSH_arr.ctypes.data), ctypes.c_void_p(HCO_arr.ctypes.data), ctypes.c_void_p(FCH_arr.ctypes.data) ) return None sys.exit(0) EXP_dict_arr = np.zeros(NUM_NODES * int(config_dict['NUM_RANDOM_ICS']), dtype=np.double) clib.find_solutions(\ ctypes.create_string_buffer(WORK_DIR), ctypes.create_string_buffer(FNAME_STATES), ctypes.create_string_buffer(FNAME_LIMITCYCLES), ctypes.create_string_buffer(FNAME_SUMMARY), ctypes.c_int(model_no), ctypes.c_int(NUM_NODES), ctypes.c_int(NUM_EDGES), ctypes.c_int(int(config_dict['NUM_RANDOM_ICS'])), ctypes.c_int(int(config_dict['ITER_FOR_ODE'])), ctypes.c_double(float(config_dict['EULER_SIM_TIME'])), ctypes.c_double(float(config_dict['EULER_SIM_STEP_SIZE'])), ctypes.c_longdouble(float(config_dict['CONVERGENCE_PROXIMITY'])), ctypes.c_double(float(config_dict['TRANS_RATE_FACTOR'])), ctypes.c_void_p(MPR_arr.ctypes.data), ctypes.c_void_p(DNR_arr.ctypes.data), ctypes.c_void_p(NODE_TYPE_arr.ctypes.data), ctypes.c_void_p(edge_source_arr.ctypes.data), ctypes.c_void_p(edge_target_arr.ctypes.data), ctypes.c_void_p(edge_type_arr.ctypes.data), ctypes.c_void_p(TSH_arr.ctypes.data), ctypes.c_void_p(HCO_arr.ctypes.data), ctypes.c_void_p(FCH_arr.ctypes.data), ctypes.c_void_p(EXP_dict_arr.ctypes.data) ) return None
def generate_models_to_be_deleted(rcp): ''' This method generates RACIPE models. ''' import numpy import numpy as np import ctypes import sys import modelManager as mm global clib MODEL_DIR = "/Users/kateba/research/cellcycle-3.stoch/data-raw/earlyG1-midG1/" MO = mm.Models(MODEL_DIR) EXP_dict = MO.get_EXP_dict() MPR_dict = MO.get_MPR_dict() DNR_dict = MO.get_DNR_dict() TSH_dict = MO.get_TSH_dict() FCH_dict = MO.get_FCH_dict() HCO_dict = MO.get_HCO_dict() # obtain the model ids: MODEL_LIST = list(HCO_dict.keys()) node_id_dict=rcp.get_node_id_dict() edge_source_dict=rcp.get_edge_source_dict() edge_target_dict=rcp.get_edge_target_dict() edge_type_dict=rcp.get_edge_type_dict() NUM_NODES=len(node_id_dict.keys()) #size of node_id_arr NUM_EDGES=len(edge_source_dict.keys()) #size of edge_id_arr # add appropriate noise: NOISE=10.0 # 30.0 NOISE_SHOT=0 SCALING=0.93 #create array for storing the source nodes of the edges: edge_source_arr=np.zeros(NUM_EDGES,dtype=np.intc) i=0 for idx in edge_source_dict.keys(): edge_source_arr[i]=edge_source_dict[idx] i+=1 #create array for storing the target nodes of the edges: edge_target_arr=np.zeros(NUM_EDGES,dtype=np.intc) i=0 for idx in edge_target_dict.keys(): edge_target_arr[i]=edge_target_dict[idx] i+=1 #create character array for work directory string: WORK_DIR=(rcp.get_work_dir()).encode('utf-8') #create arrays for storing node and edge parameters: MPR_arr=np.zeros(NUM_NODES,dtype=np.double) NOISE_strength=np.zeros(NUM_NODES,dtype=np.double) NOISE_strength_shot=np.zeros(NUM_NODES,dtype=np.double) DNR_arr=np.zeros(NUM_NODES,dtype=np.double) NODE_TYPE_arr=np.zeros(NUM_NODES,dtype=np.intc) TSH_arr=np.zeros(NUM_EDGES,dtype=np.double) HCO_arr=np.zeros(NUM_EDGES,dtype=np.intc) FCH_arr=np.zeros(NUM_EDGES,dtype=np.double) #create array for storing the types of the edges: edge_type_arr=np.zeros(NUM_EDGES,dtype=np.intc) i=0 for idx in edge_type_dict.keys(): edge_type_arr[i]=edge_type_dict[idx] i+=1 #open file to write parameters: params_fname=rcp.get_params_fname() fh_params=open(params_fname,'w') #open files to write parameters: fh_dict_nodeparams=OrderedDict() fh_dict_edgeparams=OrderedDict() fh_dict_nodeparams,fh_dict_edgeparams=open_parameter_files(rcp) #open files to write solutions: fname_dict_solutions,fh_dict_solutions=open_solution_files(rcp) #open file to write limit cycle trace: LCtrace_fname=rcp.get_LCtrace_fname() fh_LCtrace=open(LCtrace_fname,'w') #import config_dict: config_dict=rcp.get_config_dict() for model_no in MODEL_LIST: #(nodeParam_dict,source_dict,master_dict)=set_parameters(rcp) (nodeParam_dict,source_dict,master_dict)=mm.set_parameters_bymodel(rcp, MO, model_no) i=0 for X in nodeParam_dict.keys(): NODE_TYPE_arr[i]=nodeParam_dict[X][0] MPR_arr[i]=nodeParam_dict[X][1] NOISE_strength[i]=1 NOISE_strength_shot[i]=1 DNR_arr[i]=nodeParam_dict[X][2] i+=1 for idx,e in master_dict.items(): TSH_arr[idx]=master_dict[idx][3] HCO_arr[idx]=master_dict[idx][4] FCH_arr[idx]=master_dict[idx][5] EXP_dict_arr=np.zeros(NUM_NODES*int(config_dict['NUM_RANDOM_ICS']), dtype=np.double) #start_time=time.time() clib.find_solutions_stochastic_annealing(ctypes.create_string_buffer(WORK_DIR), ctypes.c_int(model_no), ctypes.c_int(NUM_NODES), ctypes.c_int(NUM_EDGES), ctypes.c_int(int(config_dict['NUM_RANDOM_ICS'])), ctypes.c_int(int(config_dict['ITER_FOR_ODE'])), ctypes.c_double(float(config_dict['EULER_SIM_TIME'])), ctypes.c_double(float(config_dict['EULER_SIM_STEP_SIZE'])), ctypes.c_longdouble(float(config_dict['CONVERGENCE_PROXIMITY'])), ctypes.c_double(float(config_dict['TRANS_RATE_FACTOR'])), ctypes.c_void_p(MPR_arr.ctypes.data), ctypes.c_void_p(DNR_arr.ctypes.data), ctypes.c_void_p(NODE_TYPE_arr.ctypes.data), ctypes.c_void_p(edge_source_arr.ctypes.data), ctypes.c_void_p(edge_target_arr.ctypes.data), ctypes.c_void_p(edge_type_arr.ctypes.data), ctypes.c_void_p(TSH_arr.ctypes.data), ctypes.c_void_p(HCO_arr.ctypes.data), ctypes.c_void_p(FCH_arr.ctypes.data), ctypes.c_void_p(EXP_dict_arr.ctypes.data), ctypes.c_void_p(NOISE_strength.ctypes.data), ctypes.c_void_p(NOISE_strength_shot.ctypes.data), ctypes.c_double(NOISE), ctypes.c_double(NOISE_SHOT), ctypes.c_double(SCALING) ) #end_time=time.time() #place the solutions in a dictionary: expression_dict=OrderedDict() expression_dict_ICs=OrderedDict() count_iteration=0 for i in range(0,NUM_NODES*int(config_dict['NUM_RANDOM_ICS']), NUM_NODES): for node,node_id in node_id_dict.items(): expression_dict[node]=EXP_dict_arr[i+node_id] expression_dict_ICs[count_iteration]=expression_dict.copy() count_iteration+=1 (solution_dict,solution_count_dict)=count_states(config_dict, expression_dict_ICs, fh_LCtrace) save_parameters(fh_params,model_no,nodeParam_dict, master_dict,solution_dict) save_parameters_5(fh_dict_nodeparams, fh_dict_edgeparams,model_no, nodeParam_dict,master_dict,solution_dict) save_solutions(fh_dict_solutions,model_no,solution_dict) if (not model_no%100): flush_solutions(fh_dict_solutions) #model_no+=1 fh_params.close() fh_LCtrace.close() close_solution_files(fname_dict_solutions,fh_dict_solutions) close_parameter_files(fh_dict_nodeparams,fh_dict_edgeparams) return None
def write_longdouble(hProcess, address, value): ctypes.windll.kernel32.WriteProcessMemory( hProcess, address, ctypes.byref(ctypes.c_longdouble(value)), ctypes.sizeof(ctypes.c_longdouble(value)), ctypes.c_ulong(0))
def anneal_network_stochastic_gnw(network, model_no, params_list, steady_state_exp): ''' This method generates RACIPE models. ''' global ensSimu import numpy import numpy as np import ctypes import sys import modelManager as mm #import config_dict: config_dict = network.get_config_dict() #add appropriate noise level: #extract starting noise for annealing from the dictionary: NOISE = np.double(config_dict['STARTING_NOISE_ANN']) #NOISE=10.0 # 30.0 NOISE_SHOT = 0 # add appropriate scaling for noise: #SCALING=0.90 SCALING = np.double(config_dict['NOISE_SCALING_FACTOR_ANN']) node_dict = network.get_node_dict() node_id_dict = network.get_node_id_dict() edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() NUM_NODES = len(node_id_dict.keys()) #size of node_id_arr NUM_EDGES = len(edge_source_dict.keys()) #size of edge_id_arr #create arrays for storing noise level for each node: NOISE_strength = np.zeros(NUM_NODES, dtype=np.double) NOISE_strength_shot = np.zeros(NUM_NODES, dtype=np.double) #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create character array for work directory string: WORK_DIR = (network.get_work_dir()).encode('utf-8') #create character arrays for file names to be used in C: fname_dict_simu = network.get_fname_dict_simu() FNAME_STATES = fname_dict_simu['FNAME_STATES'].encode('utf-8') FNAME_LIMITCYCLES = fname_dict_simu['FNAME_LIMITCYCLES'].encode('utf-8') FNAME_SUMMARY = fname_dict_simu['FNAME_SUMMARY'].encode('utf-8') FNAME_STATES_ANNEALED = fname_dict_simu['FNAME_STATES_ANNEALED'].encode( 'utf-8') #print(FNAME_STATES_ANNEALED) edge_source_dict = network.get_edge_source_dict() edge_target_dict = network.get_edge_target_dict() edge_type_dict = network.get_edge_type_dict() #create array for storing the source nodes of the edges: edge_source_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_source_dict.keys(): edge_source_arr[i] = edge_source_dict[idx] i += 1 #create array for storing the target nodes of the edges: edge_target_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_target_dict.keys(): edge_target_arr[i] = edge_target_dict[idx] i += 1 #create array for storing the types of the edges: edge_type_arr = np.zeros(NUM_EDGES, dtype=np.intc) i = 0 for idx in edge_type_dict.keys(): edge_type_arr[i] = edge_type_dict[idx] i += 1 # create arrays for storing the parameters: MPR_arr = params_list[0] DNR_arr = params_list[1] TSH_arr = params_list[2] HCO_arr = params_list[3] FCH_arr = params_list[4] NODE_TYPE_arr = np.zeros(NUM_NODES, dtype=np.intc) node_dict = network.get_node_dict() i = 0 for node in node_dict.keys(): (node_type, mpr_range, dnr_range) = node_dict[node] NODE_TYPE_arr[i] = node_type NOISE_strength[i] = 1 NOISE_strength_shot[i] = 1 i = i + 1 EXP_dict_arr = np.zeros(NUM_NODES * int(config_dict['NUM_RANDOM_ICS']), dtype=np.double) ensSimu.stochastic_anneal_network_gnw(\ ctypes.create_string_buffer(WORK_DIR), ctypes.create_string_buffer(FNAME_STATES_ANNEALED), ctypes.create_string_buffer(FNAME_LIMITCYCLES), ctypes.create_string_buffer(FNAME_SUMMARY), ctypes.c_int(model_no), ctypes.c_int(NUM_NODES), ctypes.c_int(NUM_EDGES), ctypes.c_int(int(config_dict['NUM_RANDOM_ICS'])), ctypes.c_int(int(config_dict['ITER_FOR_ODE'])), ctypes.c_double(float(config_dict['EULER_SIM_TIME'])), ctypes.c_double(float(config_dict['EULER_SIM_STEP_SIZE'])), ctypes.c_longdouble(float(config_dict['CONVERGENCE_PROXIMITY'])), ctypes.c_double(float(config_dict['TRANS_RATE_FACTOR'])), ctypes.c_void_p(steady_state_exp.ctypes.data), ctypes.c_void_p(MPR_arr.ctypes.data), ctypes.c_void_p(DNR_arr.ctypes.data), ctypes.c_void_p(NODE_TYPE_arr.ctypes.data), ctypes.c_void_p(edge_source_arr.ctypes.data), ctypes.c_void_p(edge_target_arr.ctypes.data), ctypes.c_void_p(edge_type_arr.ctypes.data), ctypes.c_void_p(TSH_arr.ctypes.data), ctypes.c_void_p(HCO_arr.ctypes.data), ctypes.c_void_p(FCH_arr.ctypes.data), ctypes.c_void_p(EXP_dict_arr.ctypes.data), ctypes.c_double(NOISE), ctypes.c_double(SCALING) ) return None
def test05_ctypes_as_ref_and_ptr(self): """Use ctypes for pass-by-ref/ptr""" # See: # https://docs.python.org/2/library/ctypes.html#fundamental-data-types # # ctypes type C type Python type # ------------------------------------------------------------------------------ # c_bool _Bool bool (1) # # c_char char 1-character string # c_wchar wchar_t 1-character unicode string # c_byte char int/long # c_ubyte unsigned char int/long # # c_short short int/long # c_ushort unsigned short int/long # c_int int int/long # c_uint unsigned int int/long # c_long long int/long # c_ulong unsigned long int/long # c_longlong __int64 or long long int/long # c_ulonglong unsigned __int64 or unsigned long long int/long # # c_float float float # c_double double float # c_longdouble long double float import cppyy, ctypes ctd = cppyy.gbl.CppyyTestData() ### pass by reference/pointer and set value back for e in ['_r', '_p']: # boolean type b = ctypes.c_bool(False) getattr(ctd, 'set_bool' + e)(b) assert b.value == True # char types if e == '_r': c = ctypes.c_char(b'\0') getattr(ctd, 'set_char' + e)(c) assert c.value == b'a' c = ctypes.c_wchar(u'\0') getattr(ctd, 'set_wchar' + e)(c) assert c.value == u'b' c = ctypes.c_byte(0) getattr(ctd, 'set_schar' + e)(c) assert c.value == ord('c') c = ctypes.c_ubyte(0) getattr(ctd, 'set_uchar' + e)(c) assert c.value == ord('d') # integer types i = ctypes.c_short(0) getattr(ctd, 'set_short' + e)(i) assert i.value == -1 i = ctypes.c_ushort(0) getattr(ctd, 'set_ushort' + e)(i) assert i.value == 2 i = ctypes.c_int(0) getattr(ctd, 'set_int' + e)(i) assert i.value == -3 i = ctypes.c_uint(0) getattr(ctd, 'set_uint' + e)(i) assert i.value == 4 i = ctypes.c_long(0) getattr(ctd, 'set_long' + e)(i) assert i.value == -5 i = ctypes.c_ulong(0) getattr(ctd, 'set_ulong' + e)(i) assert i.value == 6 i = ctypes.c_longlong(0) getattr(ctd, 'set_llong' + e)(i) assert i.value == -7 i = ctypes.c_ulonglong(0) getattr(ctd, 'set_ullong' + e)(i) assert i.value == 8 # floating point types f = ctypes.c_float(0) getattr(ctd, 'set_float' + e)(f) assert f.value == 5. f = ctypes.c_double(0) getattr(ctd, 'set_double' + e)(f) assert f.value == -5. f = ctypes.c_longdouble(0) getattr(ctd, 'set_ldouble' + e)(f) assert f.value == 10. ### pass by pointer and set value back, now using byref (not recommended) cb = ctypes.byref # boolean type b = ctypes.c_bool(False) ctd.set_bool_p(cb(b)) assert b.value == True # char types c = ctypes.c_ubyte(0) ctd.set_uchar_p(cb(c)) assert c.value == ord('d') # integer types i = ctypes.c_short(0) ctd.set_short_p(cb(i)) assert i.value == -1 i = ctypes.c_ushort(0) ctd.set_ushort_p(cb(i)) assert i.value == 2 i = ctypes.c_int(0) ctd.set_int_p(cb(i)) assert i.value == -3 i = ctypes.c_uint(0) ctd.set_uint_p(cb(i)) assert i.value == 4 i = ctypes.c_long(0) ctd.set_long_p(cb(i)) assert i.value == -5 i = ctypes.c_ulong(0) ctd.set_ulong_p(cb(i)) assert i.value == 6 i = ctypes.c_longlong(0) ctd.set_llong_p(cb(i)) assert i.value == -7 i = ctypes.c_ulonglong(0) ctd.set_ullong_p(cb(i)) assert i.value == 8 # floating point types f = ctypes.c_float(0) ctd.set_float_p(cb(f)) assert f.value == 5. f = ctypes.c_double(0) ctd.set_double_p(cb(f)) assert f.value == -5. ### pass by ptr/ptr with allocation (ptr/ptr is ambiguous in it's task, so many # types are allowed to pass; this tests allocation into the pointer) from ctypes import POINTER # boolean type b = POINTER(ctypes.c_bool)() ctd.set_bool_ppa(b) assert b[0] == True assert b[1] == False assert b[2] == True cppyy.ll.array_delete(b) # char types c = POINTER(ctypes.c_ubyte)() ctd.set_uchar_ppa(c) assert c[0] == ord('k') assert c[1] == ord('l') assert c[2] == ord('m') cppyy.ll.array_delete(c) # integer types i = POINTER(ctypes.c_short)() ctd.set_short_ppa(i) assert i[0] == -1 assert i[1] == -2 assert i[2] == -3 cppyy.ll.array_delete(i) i = POINTER(ctypes.c_ushort)() ctd.set_ushort_ppa(i) assert i[0] == 4 assert i[1] == 5 assert i[2] == 6 cppyy.ll.array_delete(i) i = POINTER(ctypes.c_int)() ctd.set_int_ppa(i) assert i[0] == -7 assert i[1] == -8 assert i[2] == -9 cppyy.ll.array_delete(i) i = POINTER(ctypes.c_uint)() ctd.set_uint_ppa(i) assert i[0] == 10 assert i[1] == 11 assert i[2] == 12 cppyy.ll.array_delete(i) i = POINTER(ctypes.c_long)() ctd.set_long_ppa(i) assert i[0] == -13 assert i[1] == -14 assert i[2] == -15 cppyy.ll.array_delete(i) i = POINTER(ctypes.c_ulong)() ctd.set_ulong_ppa(i) assert i[0] == 16 assert i[1] == 17 assert i[2] == 18 cppyy.ll.array_delete(i) i = POINTER(ctypes.c_longlong)() ctd.set_llong_ppa(i) assert i[0] == -19 assert i[1] == -20 assert i[2] == -21 cppyy.ll.array_delete(i) i = POINTER(ctypes.c_ulonglong)() ctd.set_ullong_ppa(i) assert i[0] == 22 assert i[1] == 23 assert i[2] == 24 cppyy.ll.array_delete(i) # floating point types f = POINTER(ctypes.c_float)() ctd.set_float_ppa(f) assert f[0] == 5 assert f[1] == 10 assert f[2] == 20 cppyy.ll.array_delete(f) f = POINTER(ctypes.c_double)() ctd.set_double_ppa(f) assert f[0] == -5 assert f[1] == -10 assert f[2] == -20 cppyy.ll.array_delete(f) f = POINTER(ctypes.c_longdouble)() ctd.set_ldouble_ppa(f) assert f[0] == 5 assert f[1] == 10 assert f[2] == 20 cppyy.ll.array_delete(f)
# built-in functions (CH 2) a['ByteArrayType'] = bytearray([1]) # numeric and mathematical types (CH 9) a['FractionType'] = fractions.Fraction() a['NumberType'] = numbers.Number() # generic operating system services (CH 15) a['IOBaseType'] = io.IOBase() a['RawIOBaseType'] = io.RawIOBase() a['TextIOBaseType'] = io.TextIOBase() a['BufferedIOBaseType'] = io.BufferedIOBase() a['UnicodeIOType'] = TextIO() # the new StringIO a['LoggingAdapterType'] = logging.LoggingAdapter(_logger, _dict) # pickle ok if HAS_CTYPES: a['CBoolType'] = ctypes.c_bool(1) a['CLongDoubleType'] = ctypes.c_longdouble() except ImportError: pass try: # python 2.7 import argparse # data types (CH 8) a['OrderedDictType'] = collections.OrderedDict(_dict) a['CounterType'] = collections.Counter(_dict) if HAS_CTYPES: a['CSSizeTType'] = ctypes.c_ssize_t() # generic operating system services (CH 15) a['NullHandlerType'] = logging.NullHandler() # pickle ok # new 2.7 a['ArgParseFileType'] = argparse.FileType() # pickle ok except (AttributeError, ImportError): pass
import ctypes as ct NUM_SAMPS_PER_CHAN = ct.c_int32(1) TIMEOUT = ct.c_longdouble(1.0) # one second NI_DAQ_BUFFER_SIZE = 1000 class DAQConfiguration(object): """Settings required for NI-DAQ""" def __init__(self, device_name, channels="ai0:7", rate=1000, minVal=-10, maxVal=10): self.device_name = device_name self.channels = channels self.rate = ct.c_double(rate) self.minVal = ct.c_double(minVal) self.maxVal = ct.c_double(maxVal) @property def physicalChannel(self): return "{0}/{1}".format(self.device_name, self.channels)