コード例 #1
0
    def createStateVar(self,index):
        name=self.state_names[index]
        # print name
        typ=type_params.state
        
        
        dividerCoeff=self.E[index][index]
 
        coeffarr=self.A[index]
        #create the common denominator
        i=0
       
      
        for element in coeffarr:
            if(i==index):
                denominator=np.array([dividerCoeff, -element])
               # denominator=denominator*dividerCoeff
            i+=1


        
        state_dict={}
        #find all numerators for states, and input the common denominator
        self.fillDict(coeffarr,state_dict,denominator,index,self.state_names)
        #do the same for inputs
        input_dict={}
        
        coeffarr=self.B[index]
        self.fillDict(coeffarr, input_dict, denominator, index,self.input_names,True)
        
        
        disturbance_dict=0
        
        
    
        
        toReturn=pmv_variable.pmv_variable(name,typ,state_dict,disturbance_dict,input_dict)
        toReturn.workingPoint=str(self.matrix_dict.get("x0")[index])
        
        return toReturn
コード例 #2
0
 def createInputVar(self,index):
     name=self.input_names[index]
     typ=type_params.input
     toReturn=pmv_variable.pmv_variable(name,typ)
     toReturn.workingPoint=str(self.matrix_dict.get("u0")[index])
     return toReturn
コード例 #3
0
    def getStateVar(self,rowNumber,var_name): 
        Erow=self.E[rowNumber]
        print "EEEROW"
        print Erow
        Arow=self.A[rowNumber]
        Brow=self.B[rowNumber]
        Frow=self.F[rowNumber]
        index=self.state_names.index(var_name)
        
        name=var_name
        typ=type_params.state
        
        derPart=Erow[index]
        denominator=np.array([])
        if(derPart==0):
            denominator=np.array([-Arow[index]])
        else:
            denominator=np.array([derPart,-Arow[index]])
            
        print "hoho"
        state_dict={}
        #find all numerators for states, and input the common denominator
        i=0;
        while(i<len(self.state_names)):
            if i!=index:
                derPart=Erow[i]
                numerator=np.array([])
                if(derPart==0):
                    numerator=np.array([Arow[i]])
                else:
                    numerator=np.array([-derPart,Arow[i]])

                tf=pmv_tf.pmv_tf(numerator,denominator,self.state_names[i])
                if(Erow[i]!=0 or Arow[i]!=0):
                    state_dict[self.state_names[i]]=tf
            i+=1;
        #self.fillDict(coeffarr,state_dict,denominator,index,self.state_names)
        #do the same for inputs
        print "states"
        input_dict={}
        i=0;
        print "working with inputs "+name
        print Brow
        while(i<len(self.input_names)):
            numerator=np.array([Brow[i]])
            print "numeartor is " +str(numerator) +" and " +str(Brow[i]!=0)
            tf=pmv_tf.pmv_tf(numerator,denominator,self.input_names[i])
            if(Brow[i]!=0):
                print "adding to dict"
                input_dict[self.input_names[i]]=tf
            i+=1;
        
        #self.fillDict(coeffarr, input_dict, denominator, index,self.input_names,True)
        print "mothers"
        
        disturbance_dict={}
        i=0;
        while(i<len(self.algebraic_names)):
            numerator=np.array([Frow[i]])
            tf=pmv_tf.pmv_tf(numerator,denominator,self.algebraic_names[i])
            if(Frow[i]!=0):
                disturbance_dict[self.algebraic_names[i]]=tf
            i+=1;
            
        
    
        
        toReturn=pmv_variable.pmv_variable(name,typ,state_dict,disturbance_dict,input_dict)
        #set working points
        toReturn.workingPoint=str(self.matrix_dict.get("x0")[index])
        return toReturn