Now that a basic control interface is ready, I can begin with the power electronics library. Main focus would be on the diode and IGBT (or simply an ideal switch). With these, the intent would be to start rigorously testing the circuit solver. Something which I put off before because I wanted to get to the power electronics library ASAP.
A basic problem has arisen particularly in the solving of stiff equations. A single phase diode bridge rectifier threw this error up. It it in the way the loops are rewritten whenever a diode turns on and off.
Found out the problem this afternoon and will figure it out tomorrow.
Thursday, May 23, 2013
Wednesday, May 22, 2013
Version 0.2.0 released
Releasing version 0.2.0 with controlled voltage source as library element.
http://sourceforge.net/projects/pythonpowerelec/
Just realized while moving version 0.1.5 to the archives that the zip archive was empty. Added another zip file in the archives. In case of doubts, email to pythonpowerelectronics@gmail.com.
http://sourceforge.net/projects/pythonpowerelec/
Just realized while moving version 0.1.5 to the archives that the zip archive was empty. Added another zip file in the archives. In case of doubts, email to pythonpowerelectronics@gmail.com.
Controlled Voltage Source
Think I got a basic code working for a controlled voltage source. To begin with here is the code for the class (click on "view raw" below the code box to see the code in a new window):
The only difference between a normal voltage source is that it has two lists control_tag and control_values. The control tag is the name of the control input and the corresponding index in the other list is its value. These are lists because there can be multiple control inputs to any controllable device.
Next in the main program "circuit_solver.py". The first stage is to get the names of the control codes from the user. Then generate "descriptor" files for each of these control codes. Check if they exist. If they don't create blank templates (check the previous blog entry). This is the code (click on "view raw" below the code box to see it in a new window):
The next step is to take in the descriptor parameters. These will be used to update the dictionaries for the inputs, outputs, staticvariables and time events. Here is the code (click on "view raw" below the code box to see it in a new window):
The next step was a bit tricky. The idea is to write all these different control codes into one main program called __control.py and import this file. Each control code will be written as a function.
So basically, define the function, assign the input to variables, assign the static variables to local variables, assign the time events to local variables. And then finally embed the control code. Then assign the local variables to outputs, reassign local variables to static variables and time events as applicable to take these back to the main program.
Here is the code (click on "view raw" below the code box to see it in a new window):
Anyway, a basic circuit with a controlled voltage source works. So I'll just release this as the next minor version.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| class Controlled_Voltage_Source: | |
| """ Controlled Voltage Source class. Takes the instantaneous | |
| voltage as input from the user file. """ | |
| def __init__(self, volt_index, volt_pos, volt_tag): | |
| """ Constructor to initialize value. | |
| Also, takes in the identifiers - | |
| index (serial number), cell position and tag. """ | |
| self.type="ControlledVoltageSource" | |
| self.volt_number=volt_index | |
| self.volt_pos=volt_pos | |
| self.pos=volt_pos | |
| self.volt_tag=volt_tag | |
| self.tag=volt_tag | |
| self.voltage=0.0 | |
| self.current=0.0 | |
| self.op_value=0.0 | |
| self.v_polrty=[-1, -1] | |
| self.control_tag=["Control"] | |
| self.control_values=[0.0] | |
| def display(self): | |
| """ Displays info about the component.""" | |
| print "Controlled Voltage Source is ", | |
| print self.volt_tag, | |
| print " located at ", | |
| print self.volt_pos, | |
| print " with positive polarity towards %s" %(csv_element(self.v_polrty)) | |
| def ask_values(self, x_list, ckt_mat, sys_branch): | |
| """ Writes the values needed to the spreadsheet.""" | |
| volt_params=["ControlledVoltageSource"] | |
| volt_params.append(self.volt_tag) | |
| volt_params.append(self.volt_pos) | |
| if self.v_polrty==[-1, -1]: | |
| # Looking for a default value of polarity | |
| # in the neighbouring cells | |
| self.volt_elem=csv_tuple(self.volt_pos) | |
| if self.volt_elem[0]>0: | |
| if ckt_mat[self.volt_elem[0]-1][self.volt_elem[1]]: | |
| self.v_polrty=[self.volt_elem[0]-1, self.volt_elem[1]] | |
| if self.volt_elem[1]>0: | |
| if ckt_mat[self.volt_elem[0]][self.volt_elem[1]-1]: | |
| self.v_polrty=[self.volt_elem[0], self.volt_elem[1]-1] | |
| if self.volt_elem[0]<len(ckt_mat)-1: | |
| if ckt_mat[self.volt_elem[0]+1][self.volt_elem[1]]: | |
| self.v_polrty=[self.volt_elem[0]+1, self.volt_elem[1]] | |
| if self.volt_elem[1]<len(ckt_mat)-1: | |
| if ckt_mat[self.volt_elem[0]][self.volt_elem[1]+1]: | |
| self.v_polrty=[self.volt_elem[0], self.volt_elem[1]+1] | |
| else: | |
| for c1 in range(len(sys_branch)): | |
| if csv_tuple(self.volt_pos) in sys_branch[c1]: | |
| if not self.v_polrty in sys_branch[c1]: | |
| print "!"*50 | |
| print "ERROR!!! Voltage source polarity should be in the same branch as the voltage source. Check source at %s" %self.volt_pos | |
| print "!"*50 | |
| volt_params.append("Positive polarity towards (cell) = %s" %csv_element(self.v_polrty)) | |
| volt_params.append("Name of control signal = %s" %self.control_tag[0]) | |
| x_list.append(volt_params) | |
| def get_values(self, x_list, ckt_mat): | |
| """ Takes the parameter from the spreadsheet.""" | |
| volt_polrty=x_list[0].split("=")[1] | |
| # Convert the human readable form of cell | |
| # to [row, column] form | |
| while volt_polrty[0]==" ": | |
| volt_polrty=volt_polrty[1:] | |
| self.v_polrty=csv_tuple(volt_polrty) | |
| if not ckt_mat[self.v_polrty[0]][self.v_polrty[1]]: | |
| print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.v_polrty) | |
| self.control_tag[0]=x_list[1].split("=")[1] | |
| while self.control_tag[0][0]==" ": | |
| self.control_tag[0]=self.control_tag[0][1:] | |
| return | |
| def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list): | |
| """ The matrix B in E.dx/dt=Ax+Bu will be updated by the | |
| polarity of the voltage source.""" | |
| for c1 in range(len(sys_loops)): | |
| for c2 in range(len(sys_loops[c1][c1])): | |
| if csv_tuple(self.volt_pos) in sys_loops[c1][c1][c2]: | |
| # If the positive polarity appears before the voltage position | |
| # it means as per KVL, we are moving from +ve to -ve | |
| # and so the voltage will be taken negative | |
| if sys_loops[c1][c1][c2].index(self.v_polrty)<sys_loops[c1][c1][c2].index(csv_tuple(self.volt_pos)): | |
| if sys_loops[c1][c1][c2][-1]=="forward": | |
| mat_b.data[c1][source_list.index(self.volt_pos)]=-1.0 | |
| else: | |
| mat_b.data[c1][source_list.index(self.volt_pos)]=1.0 | |
| else: | |
| if sys_loops[c1][c1][c2][-1]=="forward": | |
| mat_b.data[c1][source_list.index(self.volt_pos)]=1.0 | |
| else: | |
| mat_b.data[c1][source_list.index(self.volt_pos)]=-1.0 | |
| return | |
| def transfer_to_branch(self, sys_branch, source_list): | |
| """ Transfers parameters to system branch if voltage | |
| source exists in the branch. """ | |
| if csv_tuple(self.volt_pos) in sys_branch: | |
| if sys_branch.index(self.v_polrty)<sys_branch.index(csv_tuple(self.volt_pos)): | |
| sys_branch[-1][1][source_list.index(self.volt_pos)]=-1.0 | |
| else: | |
| sys_branch[-1][1][source_list.index(self.volt_pos)]=1.0 | |
| def generate_val(self, source_lst, sys_loops, mat_e, mat_a, mat_b, mat_u, t, dt): | |
| """ The source voltage is updated in the matrix u in | |
| E.dx/dt=Ax+Bu .""" | |
| mat_u.data[source_lst.index(self.volt_pos)][0]=self.control_values[0] | |
| self.op_value=self.control_values[0] | |
| def update_val(self, sys_loops, lbyr_ratio, mat_e, mat_a, mat_b, state_vec, mat_u): | |
| pass |
Next in the main program "circuit_solver.py". The first stage is to get the names of the control codes from the user. Then generate "descriptor" files for each of these control codes. Check if they exist. If they don't create blank templates (check the previous blog entry). This is the code (click on "view raw" below the code box to see it in a new window):
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # This is the main control program | |
| # It will contain the individual control | |
| # codes as functions. | |
| complete_control=open("__control.py","w") | |
| # Check if there exists a controlled element | |
| if controlled_elements: | |
| user_input=raw_input("Enter the control files. Omit the .py extension and just leave spaces between files --> ") | |
| control_files=user_input.split() | |
| control_descs=[] | |
| for c1 in range(len(control_files)): | |
| control_descs.append(control_files[c1]+"_desc.csv") | |
| control_functions=[] | |
| for c1 in range(len(control_files)): | |
| control_functions.append(control_files[c1]+"_func") | |
| for c1 in range(len(control_files)): | |
| control_files[c1]=control_files[c1]+".py" | |
| # These lists will contain separate dictionaries | |
| # for every control file. | |
| control_file_inputs=[] | |
| control_file_outputs=[] | |
| control_file_staticvars=[] | |
| control_file_timeevents=[] | |
| control_desc_handles=[] | |
| for c1 in range(len(control_files)): | |
| # Adding an empty dictionary for a control file. | |
| control_file_inputs.append({}) | |
| control_file_outputs.append({}) | |
| control_file_staticvars.append({}) | |
| control_file_timeevents.append({}) | |
| # Check if the descriptor exists. | |
| try: | |
| control_desc_handles.append(open(control_descs[c1],"r")) | |
| except: | |
| # If it doesn't create a blank template. | |
| control_desc_handles.append(open(control_descs[c1],"w")) | |
| # Input template | |
| control_desc_handles[c1].write("Input") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag)) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag)) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| # Output template. Create a line for every | |
| # control input a particular controlled | |
| # element has. | |
| for c2 in range(len(component_objects[controlled_elements[0]].control_tag)): | |
| control_desc_handles[c1].write("Output") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[controlled_elements[0]].type+"_"+component_objects[controlled_elements[0]].tag)) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Control tag defined in parameters spreadhseet = %s" %(component_objects[controlled_elements[0]].control_tag[c2])) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[controlled_elements[0]].control_tag[c2])) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| # Static variable template | |
| control_desc_handles[c1].write("StaticVariable") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = Var1") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Initial value of variable = 0.0") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| # Time event template | |
| control_desc_handles[c1].write("TimeEvent") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = t1") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("First time event = 0.0") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| control_desc_handles[c1].close() |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # Wait for the user to enter parameters before | |
| # reading the *_desc.csv file. | |
| cont_ans="n" | |
| while cont_ans.lower()!="y": | |
| print "Enter control parameters in the following files --> " | |
| for c1 in range(len(control_descs)): | |
| print "%s " %control_descs[c1] | |
| cont_ans=raw_input("When ready press y and enter to continue -> ") | |
| # Read the parameters from the descriptor spreadsheet. | |
| control_desc_handles=[] | |
| for c1 in range(len(control_files)): | |
| control_desc_handles.append(open(control_descs[c1],"r")) | |
| params_from_file=reading_params(control_desc_handles[c1]) | |
| for c2 in range(len(params_from_file)): | |
| # Scrubbing blank spaces from the beginning | |
| # and the end of the first cell. | |
| while params_from_file[c2][0][0]==" ": | |
| params_from_file[c2][0]=params_from_file[c2][0][1:] | |
| while params_from_file[c2][0][-1]==" ": | |
| params_from_file[c2][0]=params_from_file[c2][0][:-1] | |
| if params_from_file[c2][0].lower()=="input": | |
| # If it is an input, it will be a meter. | |
| meter_type=params_from_file[c2][1].split("=")[1] | |
| while meter_type[0]==" ": | |
| meter_type=meter_type[1:] | |
| while meter_type[-1]==" ": | |
| meter_type=meter_type[:-1] | |
| # Look for the meter in components_found | |
| # and get the cell position from the meter tag. | |
| # The cell position which is unique will be the | |
| # dictionary key for control_file_inputs. | |
| for c3 in range(len(components_found[meter_type.split("_")[0].lower()])): | |
| if components_found[meter_type.split("_")[0].lower()][c3][1]==meter_type.split("_")[1]: | |
| meter_type_ref=meter_type.split("_")[0].lower() | |
| control_file_inputs[c1][components_found[meter_type_ref][c3][0]]=[components_found[meter_type_ref][c3][1]] | |
| var_name=params_from_file[c2][2].split("=")[1] | |
| while var_name[0]==" ": | |
| var_name=var_name[1:] | |
| while var_name[-1]==" ": | |
| var_name=var_name[:-1] | |
| control_file_inputs[c1][components_found[meter_type_ref][c3][0]].append(var_name) | |
| if params_from_file[c2][0].lower()=="output": | |
| # If it is an output, it is a controlled element | |
| element_type=params_from_file[c2][1].split("=")[1] | |
| while element_type[0]==" ": | |
| element_type=element_type[1:] | |
| while element_type[-1]==" ": | |
| element_type=element_type[:-1] | |
| # Look for the controlled element in components_found | |
| # and get the cell position from the device tag. | |
| # The cell position will be the unique dictionary key | |
| for c3 in range(len(components_found[element_type.split("_")[0].lower()])): | |
| if components_found[element_type.split("_")[0].lower()][c3][1]==element_type.split("_")[1]: | |
| element_type_ref=element_type.split("_")[0].lower() | |
| # Since a controlled element can have more than one control input | |
| # Check if it has been found before. | |
| if not components_found[element_type_ref][c3][0] in control_file_outputs[c1].keys(): | |
| control_file_outputs[c1][components_found[element_type_ref][c3][0]]=[components_found[element_type_ref][c3][1]] | |
| control_tag_name=params_from_file[c2][2].split("=")[1] | |
| control_var_name=params_from_file[c2][3].split("=")[1] | |
| while control_tag_name[0]==" ": | |
| control_tag_name=control_tag_name[1:] | |
| while control_tag_name[-1]==" ": | |
| control_tag_name=control_tag_name[:-1] | |
| while control_var_name[0]==" ": | |
| control_var_name=control_var_name[1:] | |
| while control_var_name[-1]==" ": | |
| control_var_name=control_var_name[:-1] | |
| control_file_outputs[c1][components_found[element_type_ref][c3][0]].append([control_tag_name, control_var_name, 0.0]) | |
| if params_from_file[c2][0].lower()=="staticvariable": | |
| # If it is a staticvariable, the dictionary key | |
| # will be the variable name. | |
| staticvar_type=params_from_file[c2][1].split("=")[1] | |
| while staticvar_type[0]==" ": | |
| staticvar_type=staticvar_type[1:] | |
| while staticvar_type[-1]==" ": | |
| staticvar_type=staticvar_type[:-1] | |
| staticvar_val=params_from_file[c2][2].split("=")[1] | |
| while staticvar_val[0]==" ": | |
| staticvar_val=staticvar_val[1:] | |
| while staticvar_val[-1]==" ": | |
| staticvar_val=staticvar_val[:-1] | |
| control_file_staticvars[c1][staticvar_type]=float(staticvar_val) | |
| if params_from_file[c2][0].lower()=="timeevent": | |
| # If it is a timeevent, the dictionary key | |
| # will be the variable name. | |
| timeevent_type=params_from_file[c2][1].split("=")[1] | |
| while timeevent_type[0]==" ": | |
| timeevent_type=timeevent_type[1:] | |
| while timeevent_type[-1]==" ": | |
| timeevent_type=timeevent_type[:-1] | |
| timeevent_val=params_from_file[c2][2].split("=")[1] | |
| while timeevent_val[0]==" ": | |
| timeevent_val=timeevent_val[1:] | |
| while timeevent_val[-1]==" ": | |
| timeevent_val=timeevent_val[:-1] | |
| control_file_timeevents[c1][timeevent_type]=float(timeevent_val) | |
| control_desc_handles[c1].close() |
So basically, define the function, assign the input to variables, assign the static variables to local variables, assign the time events to local variables. And then finally embed the control code. Then assign the local variables to outputs, reassign local variables to static variables and time events as applicable to take these back to the main program.
Here is the code (click on "view raw" below the code box to see it in a new window):
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # Wait for use to update the control code. | |
| cont_ans="n" | |
| while cont_ans.lower()!="y": | |
| print "Enter control code in the following files --> " | |
| for c1 in range(len(control_files)): | |
| print "%s " %control_files[c1] | |
| cont_ans=raw_input("When ready press y and enter to continue -> ") | |
| # This list will contain the control | |
| # code as lists of strings. | |
| control_code=[] | |
| for c1 in range(len(control_files)): | |
| control_code.append([]) | |
| control_handles=[] | |
| for c1 in range(len(control_files)): | |
| control_handles.append(open(control_files[c1],"r")) | |
| # Add the lines in the control codes | |
| # to the lists. | |
| for line in control_handles[c1]: | |
| control_code[c1].append(line) | |
| control_handles[c1].close() | |
| # Check for any import statements. | |
| # If any of the control codes have import statements | |
| # add them to the main control program. | |
| for c1 in range(len(control_code)): | |
| for c2 in range(len(control_code[c1])): | |
| if "import" in control_code[c1][c2].split(): | |
| complete_control.write(control_code[c1][c2]) | |
| complete_control.write("\n") | |
| for c1 in range(len(control_code)): | |
| # For each control code, define a function | |
| # Name of function has been defined in | |
| # control_functions. | |
| complete_control.write("def %s(interface_inputs, interface_outputs, interface_static, interface_time, circuit_components, pos, t_clock):" %control_functions[c1]) | |
| complete_control.write("\n") | |
| # The remaining statements have a tab \t for indentation | |
| # Assign the input variables to the meter outputs | |
| for ip_keys in control_file_inputs[c1].keys(): | |
| complete_control.write("\t") | |
| complete_control.write("%s=circuit_components['%s'].op_value" %(control_file_inputs[c1][ip_keys][1], ip_keys)) | |
| complete_control.write("\n") | |
| # Assign the static variables to their latest values | |
| for static_keys in control_file_staticvars[c1].keys(): | |
| complete_control.write("\t") | |
| complete_control.write("%s=interface_static[pos]['%s']" %(static_keys, static_keys)) | |
| complete_control.write("\n") | |
| # Assign the time events variables to their latest values | |
| for time_keys in control_file_timeevents[c1].keys(): | |
| complete_control.write("\t") | |
| complete_control.write("%s=interface_time[pos]['%s']" %(time_keys, time_keys)) | |
| complete_control.write("\n") | |
| # Include the control code. | |
| for c2 in range(len(control_code[c1])): | |
| complete_control.write("\t") | |
| complete_control.write(control_code[c1][c2]) | |
| # Assign the output controlled elements to the | |
| # variables. Additionally, check each control element | |
| # for multiple control inputs. | |
| for op_keys in control_file_outputs[c1].keys(): | |
| for c3 in range(1, len(control_file_outputs[c1][op_keys])): | |
| control_pos=component_objects[op_keys].control_tag.index(control_file_outputs[c1][op_keys][c3][0]) | |
| complete_control.write("\t") | |
| # Update the object control values | |
| complete_control.write("circuit_components['%s'].control_values[%d]=%s" %(op_keys, control_pos, control_file_outputs[c1][op_keys][c3][1])) | |
| complete_control.write("\n") | |
| complete_control.write("\t") | |
| # Update the dictionary values | |
| complete_control.write("interface_outputs[pos]['%s'][%d][2]=%s" %(op_keys, c3, control_file_outputs[c1][op_keys][c3][1])) | |
| complete_control.write("\n") | |
| # Store the static variables in the dictionary | |
| for static_keys in control_file_staticvars[c1].keys(): | |
| complete_control.write("\t") | |
| complete_control.write("interface_static[pos]['%s']=%s" %(static_keys, static_keys)) | |
| complete_control.write("\n") | |
| # Store the time events in the dictionary | |
| for time_keys in control_file_timeevents[c1].keys(): | |
| complete_control.write("\t") | |
| complete_control.write("interface_time[pos]['%s']=%s" %(time_keys, time_keys)) | |
| complete_control.write("\n") | |
| # end the function | |
| complete_control.write("\t") | |
| complete_control.write("return") | |
| complete_control.write("\n") | |
| complete_control.write("\n") | |
| complete_control.close() | |
| # Import the main control program | |
| from __control import * |
Control interface - code
Here's the code for just the basic design of the control interface (click on "view raw" to view it in another window):
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # Check if there exists a controlled element | |
| if controlled_elements: | |
| user_input=raw_input("Enter the control files. Omit the .py extension and just leave spaces between files --> ") | |
| control_files=user_input.split() | |
| control_descs=[] | |
| for c1 in range(len(control_files)): | |
| control_descs.append(control_files[c1]+"_desc.csv") | |
| for c1 in range(len(control_files)): | |
| control_files[c1]=control_files[c1]+".py" | |
| # These lists will contain separate dictionaries | |
| # for every control file. | |
| control_file_inputs=[] | |
| control_file_outputs=[] | |
| control_file_staticvars=[] | |
| control_file_timeevents=[] | |
| control_desc_handles=[] | |
| for c1 in range(len(control_files)): | |
| # Adding an empty dictionary for a control file. | |
| control_file_inputs.append({}) | |
| control_file_outputs.append({}) | |
| control_file_staticvars.append({}) | |
| control_file_timeevents.append({}) | |
| # Check if the descriptor exists. | |
| try: | |
| control_desc_handles.append(open(control_descs[c1],"r")) | |
| except: | |
| # If it doesn't create a blank template. | |
| control_desc_handles.append(open(control_descs[c1],"w")) | |
| # Input template | |
| control_desc_handles[c1].write("Input") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag)) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[meter_list[0]].type+"_"+component_objects[meter_list[0]].tag)) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| # Output template. Create a line for every | |
| # control input a particular controlled | |
| # element has. | |
| for c2 in range(len(component_objects[controlled_elements[0]].control_tag)): | |
| control_desc_handles[c1].write("Output") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Element name in circuit spreadsheet = %s" %(component_objects[controlled_elements[0]].type+"_"+component_objects[controlled_elements[0]].tag)) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Control tag defined in parameters spreadhseet = %s" %(component_objects[controlled_elements[0]].control_tag[c2])) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = %s" %(component_objects[controlled_elements[0]].control_tag[c2])) | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| # Static variable template | |
| control_desc_handles[c1].write("StaticVariable") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = Var1") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Initial value of variable = 0.0") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| # Time event template | |
| control_desc_handles[c1].write("TimeEvent") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("Desired variable name in control code = t1") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("First time event = 0.0") | |
| control_desc_handles[c1].write(", ") | |
| control_desc_handles[c1].write("\n") | |
| control_desc_handles[c1].close() | |
| # Wait for the user to enter parameters before | |
| # reading the nw_params.csv file. | |
| cont_ans="n" | |
| while cont_ans.lower()!="y": | |
| print "Enter control parameters in the following files --> " | |
| for c1 in range(len(control_descs)): | |
| print "%s " %control_descs[c1] | |
| cont_ans=raw_input("When ready press y and enter to continue -> ") | |
| # Read the parameters from the descriptor spreadsheet. | |
| control_desc_handles=[] | |
| for c1 in range(len(control_files)): | |
| control_desc_handles.append(open(control_descs[c1],"r")) | |
| params_from_file=reading_params(control_desc_handles[c1]) | |
| for c2 in range(len(params_from_file)): | |
| # Scrubbing blank spaces from the beginning | |
| # and the end of the first cell. | |
| while params_from_file[c2][0][0]==" ": | |
| params_from_file[c2][0]=params_from_file[c2][0][1:] | |
| while params_from_file[c2][0][-1]==" ": | |
| params_from_file[c2][0]=params_from_file[c2][0][:-1] | |
| if params_from_file[c2][0].lower()=="input": | |
| # If it is an input, it will be a meter. | |
| meter_type=params_from_file[c2][1].split("=")[1] | |
| while meter_type[0]==" ": | |
| meter_type=meter_type[1:] | |
| while meter_type[-1]==" ": | |
| meter_type=meter_type[:-1] | |
| # Look for the meter in components_found | |
| # and get the cell position from the meter tag. | |
| # The cell position which is unique will be the | |
| # dictionary key for control_file_inputs. | |
| for c3 in range(len(components_found[meter_type.split("_")[0].lower()])): | |
| if components_found[meter_type.split("_")[0].lower()][c3][1]==meter_type.split("_")[1]: | |
| meter_type_ref=meter_type.split("_")[0].lower() | |
| control_file_inputs[c1][components_found[meter_type_ref][c3][0]]=[components_found[meter_type_ref][c3][1]] | |
| var_name=params_from_file[c2][2].split("=")[1] | |
| while var_name[0]==" ": | |
| var_name=var_name[1:] | |
| while var_name[-1]==" ": | |
| var_name=var_name[:-1] | |
| control_file_inputs[c1][components_found[meter_type_ref][c3][0]].append(var_name) | |
| if params_from_file[c2][0].lower()=="output": | |
| # If it is an output, it is a controlled element | |
| element_type=params_from_file[c2][1].split("=")[1] | |
| while element_type[0]==" ": | |
| element_type=element_type[1:] | |
| while element_type[-1]==" ": | |
| element_type=element_type[:-1] | |
| # Look for the controlled element in components_found | |
| # and get the cell position from the device tag. | |
| # The cell position will be the unique dictionary key | |
| for c3 in range(len(components_found[element_type.split("_")[0].lower()])): | |
| if components_found[element_type.split("_")[0].lower()][c3][1]==element_type.split("_")[1]: | |
| element_type_ref=element_type.split("_")[0].lower() | |
| # Since a controlled element can have more than one control input | |
| # Check if it has been found before. | |
| if not components_found[element_type_ref][c3][0] in control_file_outputs[c1].keys(): | |
| control_file_outputs[c1][components_found[element_type_ref][c3][0]]=[components_found[element_type_ref][c3][1]] | |
| control_tag_name=params_from_file[c2][2].split("=")[1] | |
| control_var_name=params_from_file[c2][3].split("=")[1] | |
| while control_tag_name[0]==" ": | |
| control_tag_name=control_tag_name[1:] | |
| while control_tag_name[-1]==" ": | |
| control_tag_name=control_tag_name[:-1] | |
| while control_var_name[0]==" ": | |
| control_var_name=control_var_name[1:] | |
| while control_var_name[-1]==" ": | |
| control_var_name=control_var_name[:-1] | |
| control_file_outputs[c1][components_found[element_type_ref][c3][0]].append([control_tag_name, control_var_name, 0.0]) | |
| if params_from_file[c2][0].lower()=="staticvariable": | |
| # If it is a staticvariable, the dictionary key | |
| # will be the variable name. | |
| staticvar_type=params_from_file[c2][1].split("=")[1] | |
| while staticvar_type[0]==" ": | |
| staticvar_type=staticvar_type[1:] | |
| while staticvar_type[-1]==" ": | |
| staticvar_type=staticvar_type[:-1] | |
| staticvar_val=params_from_file[c2][2].split("=")[1] | |
| while staticvar_val[0]==" ": | |
| staticvar_val=staticvar_val[1:] | |
| while staticvar_val[-1]==" ": | |
| staticvar_val=staticvar_val[:-1] | |
| control_file_staticvars[c1][staticvar_type]=float(staticvar_val) | |
| if params_from_file[c2][0].lower()=="timeevent": | |
| # If it is a timeevent, the dictionary key | |
| # will be the variable name. | |
| timeevent_type=params_from_file[c2][1].split("=")[1] | |
| while timeevent_type[0]==" ": | |
| timeevent_type=timeevent_type[1:] | |
| while timeevent_type[-1]==" ": | |
| timeevent_type=timeevent_type[:-1] | |
| timeevent_val=params_from_file[c2][2].split("=")[1] | |
| while timeevent_val[0]==" ": | |
| timeevent_val=timeevent_val[1:] | |
| while timeevent_val[-1]==" ": | |
| timeevent_val=timeevent_val[:-1] | |
| control_file_timeevents[c1][timeevent_type]=float(timeevent_val) | |
| control_desc_handles[c1].close() |
Tuesday, May 21, 2013
Control interface design
I have been thinking of how the control interface would be like for the user. A user needs a few essentials:
1. An easy way to define inputs, outputs. So, in the same was you would join an ammeter output to an in-port, you need to be able to define such a connection and use the variable inside the code. Also, the output of a block should be connected to a controllable device. In case the controllable device has multiple controls, the user should be able to define which controls get what variables.
2. Time events: The simplest thing to do would be to define a constant sampling frequency but this would make multi-rate sampling impossible. Also, ideally, the user should be able to decide when the code will run next. As a reference, the user will be given the current simulation time as t_clock. Really, that is also not needed, because the user needs to define "after" how much time the control code will run again and not "at" what time the control code will run again.
3. The nature of the code: One of the reasons for using Python was to be able to combine some of the other efforts in signal processing, linear algebra etc that are happening and give the user the chance to write advanced control code. So the user can write anything that is valid code. For that matter I am not sure if it is possible to embed a C program/function within a Python program. But if that is possible, why not? Essentially, anything that you can do in Python in general.
So this is what the code I have written has designed so far.
1. Take from the user the name of the control files that he wants to use. For every control file, there will be a "descriptor" file with a _desc. This will be a CSV file. This file contains four keywords - "Input", "Output", "StaticVariable" and "TimeEvent".
2. As a framework, a sample of all these will be provided in every descriptor file. So there will be one of each to tell the user how to do the rest.
3. An "Input" will be from a meter. So the user will need to specify the name of the meter as in the circuit spreadsheet and the variable name by which they want to refer to it in the control code.
An "Output" will be at a controllable device and additionally a control tag to account for devices that have multiple control inputs and finally the variable name in the control code.
"StaticVariables" will be variables that will continue to be available with their latest values in the control code. So these will passed back and forth with the main program. All other variables used in the code will be temporary and will exist only in the control code (local variables).
"TimeEvent" will be when the code runs next. Here not fully sure what to do. Supposing there are multiple blocks of code the user wants to execute at different rates - say 100 microseconds and 145 microseconds. The user can define two time events. A simple way would be let the user take the simulation time in the form of "t_clock" and compare t_clock with the time events. A more elaborate way would be define any tevent as tevent=tevent+x. x could be constant or variable. And tevent can be initialized by the user.
4. With every control file, there will be a descriptor file. So there can be multiple control codes.
5. Once this is defined, the user writes the control code. The program takes the control code, embeds it inside a function and maps the inputs, outputs etc to variables passed from the main program. All this will be written automatically into another program with any import statements the user includes. This program will be imported by the main program and the functions will be executed automatically.
So this is the plan. Steps 1, 2, 3 and 4 are done. The code is almost ready and I need to think over it. Step 5 will then follow.
1. An easy way to define inputs, outputs. So, in the same was you would join an ammeter output to an in-port, you need to be able to define such a connection and use the variable inside the code. Also, the output of a block should be connected to a controllable device. In case the controllable device has multiple controls, the user should be able to define which controls get what variables.
2. Time events: The simplest thing to do would be to define a constant sampling frequency but this would make multi-rate sampling impossible. Also, ideally, the user should be able to decide when the code will run next. As a reference, the user will be given the current simulation time as t_clock. Really, that is also not needed, because the user needs to define "after" how much time the control code will run again and not "at" what time the control code will run again.
3. The nature of the code: One of the reasons for using Python was to be able to combine some of the other efforts in signal processing, linear algebra etc that are happening and give the user the chance to write advanced control code. So the user can write anything that is valid code. For that matter I am not sure if it is possible to embed a C program/function within a Python program. But if that is possible, why not? Essentially, anything that you can do in Python in general.
So this is what the code I have written has designed so far.
1. Take from the user the name of the control files that he wants to use. For every control file, there will be a "descriptor" file with a _desc. This will be a CSV file. This file contains four keywords - "Input", "Output", "StaticVariable" and "TimeEvent".
2. As a framework, a sample of all these will be provided in every descriptor file. So there will be one of each to tell the user how to do the rest.
3. An "Input" will be from a meter. So the user will need to specify the name of the meter as in the circuit spreadsheet and the variable name by which they want to refer to it in the control code.
An "Output" will be at a controllable device and additionally a control tag to account for devices that have multiple control inputs and finally the variable name in the control code.
"StaticVariables" will be variables that will continue to be available with their latest values in the control code. So these will passed back and forth with the main program. All other variables used in the code will be temporary and will exist only in the control code (local variables).
"TimeEvent" will be when the code runs next. Here not fully sure what to do. Supposing there are multiple blocks of code the user wants to execute at different rates - say 100 microseconds and 145 microseconds. The user can define two time events. A simple way would be let the user take the simulation time in the form of "t_clock" and compare t_clock with the time events. A more elaborate way would be define any tevent as tevent=tevent+x. x could be constant or variable. And tevent can be initialized by the user.
4. With every control file, there will be a descriptor file. So there can be multiple control codes.
5. Once this is defined, the user writes the control code. The program takes the control code, embeds it inside a function and maps the inputs, outputs etc to variables passed from the main program. All this will be written automatically into another program with any import statements the user includes. This program will be imported by the main program and the functions will be executed automatically.
So this is the plan. Steps 1, 2, 3 and 4 are done. The code is almost ready and I need to think over it. Step 5 will then follow.
Thursday, May 9, 2013
Next step - controlled sources and power electronics
The thought of spending the next few weeks sorting out the exception handling put me off completely. So I decided to skip that stage and move on to expanding the library instead. Whats the point of having my own project if I can't do what I want?
So, now designing the interface for a controllable object for example a controllable voltage source. The primary objective with this software is that an advanced user should be able to code whatever he wants as the control code. Taking my requirements specifically, I would like the control code that I write to be able to translate into a C program that I can compile into a DSP.
So, with any controllable object, what are the major interface requirements?
1. Inputs - preferrably in the form of meaurements from meters
2. Control outputs - can be defined in the parameter specification sheet.
3. An event generator - when must the control values be updated.
With no. 1 and no. 2 the objective will be that the user should have convenient interface to access the outputs of measurement meters and update the controls without getting too much into the way objects are defined. So this means, I would have to add another layer between the "component_objects" dictionary in the main circuit_solver.py and the control code. So the next question, how will this interface be decided? In most simulators, input ports are defined and these are connected to signals in the outer layer. This might be one way to design an interface. Ask the user to choose what are the inputs to the control code.
With no. 3 the purpose of an event generator is that different objects have to be upated at different rates - i.e multi-rate sampling. So the control code must execute when the object with the nearest update time is called. Also, how to ensure that objects are updated only when necessary?
So, now designing the interface for a controllable object for example a controllable voltage source. The primary objective with this software is that an advanced user should be able to code whatever he wants as the control code. Taking my requirements specifically, I would like the control code that I write to be able to translate into a C program that I can compile into a DSP.
So, with any controllable object, what are the major interface requirements?
1. Inputs - preferrably in the form of meaurements from meters
2. Control outputs - can be defined in the parameter specification sheet.
3. An event generator - when must the control values be updated.
With no. 1 and no. 2 the objective will be that the user should have convenient interface to access the outputs of measurement meters and update the controls without getting too much into the way objects are defined. So this means, I would have to add another layer between the "component_objects" dictionary in the main circuit_solver.py and the control code. So the next question, how will this interface be decided? In most simulators, input ports are defined and these are connected to signals in the outer layer. This might be one way to design an interface. Ask the user to choose what are the inputs to the control code.
With no. 3 the purpose of an event generator is that different objects have to be upated at different rates - i.e multi-rate sampling. So the control code must execute when the object with the nearest update time is called. Also, how to ensure that objects are updated only when necessary?
Sunday, May 5, 2013
Version 0.1.5 released
Version 0.1.5 released.
http://sourceforge.net/projects/pythonpowerelec/?source=navbar
Also, just in case, since some of the blog may be written in a cryptic manner, specific questions can be directed to pythonpowerelectronics@gmail.com
http://sourceforge.net/projects/pythonpowerelec/?source=navbar
Also, just in case, since some of the blog may be written in a cryptic manner, specific questions can be directed to pythonpowerelectronics@gmail.com
Current Source
This current source turned out to be a little more tricky that I thought because I was looking for an elegant solution, something with cool network tricks or that uses object oriented programming inheritance techniques. Ended up using the easiest way - model the current source as a voltage source in series with a resistance. The end result is a little dirty - calculate one temporary value to update another temporary value. This is evident from the glitches in the first quarter cycle. Will have to test how this works particularly in an inductive-capacitive circuit. So nothing final yet.
Been a while since I released a version, so I am going to release it soon. Also, the next step will be to move on to version 0.2.0 which will look at structural changes to the code that will bring in error messages and directions of usage.
Anyway, here is the code (click on "view raw" below the code box to see it in a new window):
Been a while since I released a version, so I am going to release it soon. Also, the next step will be to move on to version 0.2.0 which will look at structural changes to the code that will bring in error messages and directions of usage.
Anyway, here is the code (click on "view raw" below the code box to see it in a new window):
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| class Current_Source: | |
| """ Current source class. Contains functions to initiliaze | |
| the resistor according to name tag, unique cell position, | |
| update system matrix on each iteration. """ | |
| def __init__(self, cs_index, cs_pos, cs_tag): | |
| """ Constructor to initialize value. | |
| Also, takes in the identifiers - | |
| index (serial number), cell position and tag. """ | |
| self.type="CurrentSource" | |
| self.cs_number=cs_index | |
| self.cs_pos=cs_pos | |
| self.cs_tag=cs_tag | |
| self.cs_peak=5.0 | |
| self.cs_freq=60.0 | |
| self.cs_phase=0.0 | |
| self.cs_level=120.0 | |
| self.resistor=1.0 | |
| self.current=0.0 | |
| self.voltage=0.0 | |
| self.op_value=0.0 | |
| self.cs_polrty=[-1, -1] | |
| def display(self): | |
| print "Current Source is ", | |
| print self.cs_tag, | |
| print "of %f A (peak), %f Hz(frequency) and %f (degrees phase shift)" %(self.cs_peak, self.cs_freq, self.cs_phase), | |
| print " located at ", | |
| print self.cs_pos, | |
| print " with positive polarity towards %s" %(csv_element(self.cs_polrty)) | |
| return | |
| def ask_values(self, x_list, ckt_mat, sys_branch): | |
| """ Writes the values needed to the spreadsheet.""" | |
| cs_params=["CurrentSource"] | |
| cs_params.append(self.cs_tag) | |
| cs_params.append(self.cs_pos) | |
| cs_params.append("Peak (Amps) = %f" %self.cs_peak) | |
| cs_params.append("Frequency (Hertz) = %f" %self.cs_freq) | |
| cs_params.append("Phase (degrees) = %f" %self.cs_phase) | |
| if self.cs_polrty==[-1, -1]: | |
| # Looking for a default value of polarity | |
| # in the neighbouring cells | |
| self.cs_elem=csv_tuple(self.cs_pos) | |
| if self.cs_elem[0]>0: | |
| if ckt_mat[self.cs_elem[0]-1][self.cs_elem[1]]: | |
| self.cs_polrty=[self.cs_elem[0]-1, self.cs_elem[1]] | |
| if self.cs_elem[1]>0: | |
| if ckt_mat[self.cs_elem[0]][self.cs_elem[1]-1]: | |
| self.cs_polrty=[self.cs_elem[0], self.cs_elem[1]-1] | |
| if self.cs_elem[0]<len(ckt_mat)-1: | |
| if ckt_mat[self.cs_elem[0]+1][self.cs_elem[1]]: | |
| self.cs_polrty=[self.cs_elem[0]+1, self.cs_elem[1]] | |
| if self.cs_elem[1]<len(ckt_mat)-1: | |
| if ckt_mat[self.cs_elem[0]][self.cs_elem[1]+1]: | |
| self.cs_polrty=[self.cs_elem[0], self.cs_elem[1]+1] | |
| else: | |
| for c1 in range(len(sys_branch)): | |
| if csv_tuple(self.cs_pos) in sys_branch[c1]: | |
| if not self.cs_polrty in sys_branch[c1]: | |
| print "!"*50 | |
| print "ERROR!!! Current source polarity should be in the same branch as the current source. Check source at %s" %self.cs_pos | |
| print "!"*50 | |
| cs_params.append("Positive polarity towards (cell) = %s" %csv_element(self.cs_polrty)) | |
| x_list.append(cs_params) | |
| return | |
| def get_values(self, x_list, ckt_mat): | |
| """ Takes the parameter from the spreadsheet.""" | |
| self.cs_peak=float(x_list[0].split("=")[1]) | |
| self.cs_freq=float(x_list[1].split("=")[1]) | |
| self.cs_phase=float(x_list[2].split("=")[1]) | |
| curr_polrty=x_list[3].split("=")[1] | |
| # Convert the human readable form of cell | |
| # to [row, column] form | |
| while curr_polrty[0]==" ": | |
| curr_polrty=curr_polrty[1:] | |
| self.cs_polrty=csv_tuple(curr_polrty) | |
| if not ckt_mat[self.cs_polrty[0]][self.cs_polrty[1]]: | |
| print "Polarity incorrect. Branch does not exist at %s" %csv_element(self.cs_polrty) | |
| return | |
| def transfer_to_sys(self, sys_loops, mat_e, mat_a, mat_b, mat_u, source_list): | |
| """ The matrix A in E.dx/dt=Ax+Bu will be updated by the | |
| resistor value.""" | |
| for c1 in range(len(sys_loops)): | |
| for c2 in range(c1, len(sys_loops)): | |
| # Updating the elements depending | |
| # on the sense of the loops (aiding or opposing) | |
| for c3 in range(len(sys_loops[c1][c2])): | |
| # Check if current source position is there in the loop. | |
| if csv_tuple(self.cs_pos) in sys_loops[c1][c2][c3]: | |
| # Add current source series resistor | |
| # if branch is in forward direction | |
| if sys_loops[c1][c2][c3][-1]=="forward": | |
| mat_a.data[c1][c2]+=self.resistor | |
| else: | |
| # Else subtract if branch is in reverse direction | |
| mat_a.data[c1][c2]-=self.resistor | |
| # Because the matrices are symmetric | |
| mat_a.data[c2][c1]=mat_a.data[c1][c2] | |
| return | |
| def transfer_to_branch(self, sys_branch, source_list): | |
| """ Update the resistor info of the voltmeter | |
| to the branch list """ | |
| if csv_tuple(self.cs_pos) in sys_branch: | |
| sys_branch[-1][0][0]+=self.resistor | |
| if csv_tuple(self.cs_pos) in sys_branch: | |
| if sys_branch.index(self.cs_polrty)<sys_branch.index(csv_tuple(self.cs_pos)): | |
| sys_branch[-1][1][source_list.index(self.cs_pos)]=-1.0 | |
| else: | |
| sys_branch[-1][1][source_list.index(self.cs_pos)]=1.0 | |
| return | |
| def generate_val(self, source_lst, sys_loops, mat_e, mat_a, mat_b, mat_u, state_vec, t, dt): | |
| """ The source current is updated in the matrix u in | |
| E.dx/dt=Ax+Bu. The matrix E has a row set to zero. The | |
| matrix B has the diagonal element in the row set to 1, | |
| others set to zero.""" | |
| # Updating the current source value | |
| self.current=self.cs_peak*math.sin(2*math.pi*self.cs_freq*t+self.cs_phase) | |
| # The value passed to the input matrix is | |
| # the voltage calculated | |
| mat_u.data[source_lst.index(self.cs_pos)][0]=self.voltage | |
| # The output value of the source will the current | |
| # even though it is actually modelled as a | |
| # voltage source with a series resistance. | |
| self.op_value=self.current | |
| return | |
| def update_val(self, sys_loops, lbyr_ratio, mat_e, mat_a, mat_b, state_vec, mat_u): | |
| """ This function calculates the actual current in | |
| the current source branch. With this, the branch voltage is | |
| found with respect to the existing voltage source. The branch | |
| voltage is then used to calculate the new voltage source value. """ | |
| # Local variable to calculate the branch | |
| # current from all loops that contain | |
| # the current source branch. | |
| act_current=0.0 | |
| for c1 in range(len(sys_loops)): | |
| for c2 in range(len(sys_loops[c1][c1])): | |
| if csv_tuple(self.cs_pos) in sys_loops[c1][c1][c2]: | |
| # If current source polarity is before the source | |
| # position, it means actual current is negative. | |
| if sys_loops[c1][c1][c2].index(self.cs_polrty)<sys_loops[c1][c1][c2].index(csv_tuple(self.cs_pos)): | |
| # Then check is the loop is aiding or opposing | |
| # the main loop. | |
| if sys_loops[c1][c1][c2][-1]=="forward": | |
| act_current+=state_vec.data[c1][0] | |
| else: | |
| act_current-=state_vec.data[c1][0] | |
| else: | |
| if sys_loops[c1][c1][c2][-1]=="forward": | |
| act_current-=state_vec.data[c1][0] | |
| else: | |
| act_current+=state_vec.data[c1][0] | |
| # The branch voltage is the KVL with the | |
| # existing voltage source and the branch current | |
| branch_voltage=self.voltage+act_current*self.resistor | |
| # The new source voltage will be the branch voltage | |
| # in addition to the desired value of current. | |
| self.voltage=branch_voltage+self.current*self.resistor | |
| return |
Wednesday, May 1, 2013
User defined objects - II
Spent a couple of days thinking about ways in which a user can define a "block" that could be connected repeatedly in the circuit. But something similar has made that half-possible already - the "jump" labels.
A crude way of defining blocks would be to simply describe a part of a circuit (for example an RLC circuit or a three-phase inverter) and connect it to the rest of the circuit using jump labels. The reason this would be crude is that the entire sub-circuit would have to be copied that many number of times and for each object, the constituent components would have to be given separate labels.
A much more elegant manner would be to define a single sub-circuit as the base class. The main circuit will then contain references to this class and the connections could be made by jump labels with additional unique identifiers. For example a RL sub-circuit could have a jump1 and jump2 labels as connectors. The main circuit can have jump labels as jump1_RL1 and jump2_RL1 to signify a component RL1. The extention "RL1" will result in labels RL1 automatically created that will be appended to the resistor and inductor within the sub-circuit.
The problem with this method is that in a very large circuit with several sub-components repeated, it may be necessary to change the parameters of some of them to simulate special conditions such as nonideal parameters. So by having a single block, additional changes to the structure won't be possible. So, by copying the sub-circuit again and again, this flexibility is provided. The only drawback is that the user will have to edit all the component labels. But that may not be such a bad thing because the program does the error checking for duplicate labels. So a circuit will not run with multiple labels if the user accidentally forgets to edit some of the labels.
So this option of copying a circuit as many times as you need in the circuit is not such a bad idea because even for the sake of appearance, you can have these blocks anywhere in the spreadhseet, not necesarily bang in the middle of the main circuit.
So, now all I have to do is define a current source and I'll be done with the first set of elements.
A crude way of defining blocks would be to simply describe a part of a circuit (for example an RLC circuit or a three-phase inverter) and connect it to the rest of the circuit using jump labels. The reason this would be crude is that the entire sub-circuit would have to be copied that many number of times and for each object, the constituent components would have to be given separate labels.
A much more elegant manner would be to define a single sub-circuit as the base class. The main circuit will then contain references to this class and the connections could be made by jump labels with additional unique identifiers. For example a RL sub-circuit could have a jump1 and jump2 labels as connectors. The main circuit can have jump labels as jump1_RL1 and jump2_RL1 to signify a component RL1. The extention "RL1" will result in labels RL1 automatically created that will be appended to the resistor and inductor within the sub-circuit.
The problem with this method is that in a very large circuit with several sub-components repeated, it may be necessary to change the parameters of some of them to simulate special conditions such as nonideal parameters. So by having a single block, additional changes to the structure won't be possible. So, by copying the sub-circuit again and again, this flexibility is provided. The only drawback is that the user will have to edit all the component labels. But that may not be such a bad thing because the program does the error checking for duplicate labels. So a circuit will not run with multiple labels if the user accidentally forgets to edit some of the labels.
So this option of copying a circuit as many times as you need in the circuit is not such a bad idea because even for the sake of appearance, you can have these blocks anywhere in the spreadhseet, not necesarily bang in the middle of the main circuit.
So, now all I have to do is define a current source and I'll be done with the first set of elements.
Subscribe to:
Posts (Atom)