ElecSolver 0.1.0__py3-none-any.whl

ElecSolver/FrequencySystemBuilder.py

@@ -0,0 +1,264 @@
+import numpy as np
+import networkx as nx
+from scipy.sparse import coo_matrix
+
+
+class FrequencySystemBuilder():
+    def __init__(self,impedence_coords,impedence_data,mutuals_coords,mutuals_data):
+        """FrequencySystemBuilder class for building an electrical sparse system
+        that can be solved by any sparse solver
+        it supports all forms of complex making this class fit for non linear impedences
+
+        Parameters
+        ----------
+        impedence_coords : np.array of ints, shape = (2,N)
+            impedence coordinates
+        impedence_data : np.array of complex, shape = (N,)
+            impedence value between points impedence_coords[:,i]
+        mutuals_coords : np.array of ints, shape = (2,M)
+            indexes of the impedence within impedence data which have a mutual
+        mutuals_data : np.array of complex, shape=(M,)
+            mutual value between impedences impedence_data[mutuals_coords[0,i]] impedence_data[mutuals_coords[1,i]]
+            The mutual follows the order given in impedence coords
+        """
+        all_points = np.unique(impedence_coords)
+        if all_points.shape != np.max(impedence_coords)+1:
+            IndexError("There is one or multiple lonely nodes please clean your impedence graph")
+        self.impedence_coords = impedence_coords
+        self.impedence_data = impedence_data
+        self.mutuals_coords = mutuals_coords
+        self.mutuals_data = mutuals_data
+        self.size = np.max(impedence_coords)+1
+        self.number_intensities = self.impedence_data.shape[0]
+        ## making graph and checking number of subgraphs
+        unique_coords = np.unique(self.impedence_coords,axis=1)
+        sym_graph = np.concatenate((unique_coords,np.stack((unique_coords[1],unique_coords[0]),axis=0)),axis=1)
+        links = np.ones(sym_graph.shape[1])
+        self.graph =  nx.from_scipy_sparse_array(coo_matrix((links,(sym_graph[0],sym_graph[1]))))
+        self.list_of_subgraphs = [ list(sub) for sub in nx.connected_components(self.graph)]
+        self.number_of_subsystems = len(self.list_of_subgraphs)
+        self.affected_potentials = [-1]*self.number_of_subsystems
+        self.deleted_equation_current = [subsystem[0] for subsystem in self.list_of_subgraphs]
+        ## number of tension sources
+        self.source_count = 0
+        self.source_signs = np.array([],dtype=int)
+        self.rhs = (np.array([]),(np.array([],dtype=int),))
+        rescaler = np.zeros(self.size)
+        rescaler[self.deleted_equation_current]=1
+        rescaler = -np.cumsum(rescaler)
+        self.rescaler =rescaler.astype(int)
+        offset_j = self.impedence_data.shape[0]
+        offset_i = self.size-len(self.deleted_equation_current)
+        self.offset_i = offset_i
+        self.offset_j = offset_j
+
+    def set_mass(self,*args):
+        for index in args:
+            for pivot,subsystem in enumerate(self.list_of_subgraphs):
+                if index in subsystem:
+                    if self.affected_potentials[pivot]!=-1:
+                        print(f"Subsystem {pivot} already add a mass, reaffecting the value")
+                    self.affected_potentials[pivot]=index
+                    break
+
+    def affect_potentials(self):
+        """Function to check whether the masses were affected and assign some if not
+        """
+        for i in range(len(self.affected_potentials)):
+            if -1 == self.affected_potentials[i]:
+                self.affected_potentials[i]= self.list_of_subgraphs[i][0]
+                print(f"Subsytem {i} has not been affected to the mass, we chose {self.list_of_subgraphs[i][0]}")
+
+    def build_system(self):
+        """Building sytem assuming that data was given as COO matrices
+        Fully vectorized for best performance
+        it is faster but less understandable
+        """
+        ## affecting masses if need be
+        self.affect_potentials()
+        ## Building a sparse COO matrix
+
+
+        ## Building all vectorized values necessary
+        i_s_vals = np.max(self.impedence_coords,axis=0)
+        j_s_vals = np.min(self.impedence_coords,axis=0)
+        values = self.impedence_data
+
+
+        ## node laws
+        data_nodes = np.concatenate((np.ones(self.number_intensities),-np.ones(self.number_intensities)),axis=0)
+        j_s_nodes = np.tile(np.arange(self.number_intensities,dtype=int),(2,))
+        i_s_nodes =np.concatenate((i_s_vals,j_s_vals),axis=0)
+
+        # Removing one current equation per subsytem
+        mask_removed_eq = ~np.isin(i_s_nodes,self.deleted_equation_current)
+        data_nodes = data_nodes[mask_removed_eq]
+        j_s_nodes = j_s_nodes[mask_removed_eq]
+        i_s_nodes = i_s_nodes[mask_removed_eq]
+        i_s_nodes = i_s_nodes + self.rescaler[i_s_nodes]
+
+
+
+        ## Kirchoff
+        i_s_edges = self.offset_i + np.concatenate([np.arange(self.number_intensities,dtype=int)]*3,axis=0 )
+        j_s_edges = np.concatenate([self.offset_j+i_s_vals,self.offset_j+j_s_vals,np.arange(self.number_intensities,dtype=int)],axis=0)
+        data_edges = np.concatenate([np.ones(values.shape[0],dtype=complex),-np.ones(values.shape[0],dtype=complex),values],axis=0)
+
+
+
+        ## adding mutuals to the system
+        sign = np.sign(self.impedence_coords[0]-self.impedence_coords[1])
+
+
+        i_s_additionnal = self.offset_i + np.concatenate((self.mutuals_coords[0],self.mutuals_coords[1]),axis=0)
+        j_s_additionnal = np.concatenate((self.mutuals_coords[1],self.mutuals_coords[0]),axis=0)
+        data_additionnal = np.tile(self.mutuals_data*sign[self.mutuals_coords[0]]*sign[self.mutuals_coords[1]],(2,))
+
+
+        ## mass equations (1 per subsystem)
+        i_s_mass = np.arange(self.offset_i+self.offset_j,self.offset_i+self.offset_j+len(self.affected_potentials))
+        j_s_mass = self.offset_j+np.array(self.affected_potentials)
+        data_mass = np.ones(len(self.affected_potentials))
+
+
+        i_s = np.concatenate((i_s_nodes,i_s_edges,i_s_additionnal,i_s_mass),axis=0)
+        j_s = np.concatenate((j_s_nodes,j_s_edges,j_s_additionnal,j_s_mass),axis=0)
+        data = np.concatenate((data_nodes,data_edges,data_additionnal,data_mass),axis=0)
+
+        self.system = (data,(i_s.astype(int),j_s.astype(int)))
+        return self.system
+
+    def get_system(self):
+        """Function to get the system
+        Returns
+        -------
+        sys: scipy.coo_matrix
+            Linear system to solve
+        rhs: np.ndarray
+            Second member of the system
+        """
+        (data_rhs,(nodes,)) = self.rhs
+        (data,(i_s,j_s)) = self.system
+        sys = coo_matrix(self.system)
+        rhs = np.zeros(self.number_intensities+self.size+self.source_count)
+        np.add.at(rhs, nodes, data_rhs)
+        return sys,rhs
+
+    def build_second_member_intensity(self,intensity,input_node,output_node):
+        """Function to build a second member for the scenario of current injection in the sparse system
+
+        Parameters
+        ----------
+        intensity : float
+            intensity to inject
+        input_node : int
+            which node to take for injection
+        output_node : int
+            which node for current retrieval
+
+        Returns
+        -------
+        Tuple(np.array,(np.array))
+            second member of the linear system in a COO like format
+        """
+        data = []
+        nodes = []
+        if self.number_of_subsystems>=2:
+            valid = False
+            for system in self.list_of_subgraphs:
+                if input_node in system and output_node in system:
+                    valid =True
+                else:
+                    continue
+            if not valid:
+                raise IndexError("Nodes indicated do not belong to the same subsystem")
+
+        if input_node not in self.deleted_equation_current:
+            nodes.append(input_node+self.rescaler[input_node])
+            data.append(-intensity) # inbound intensity
+        if output_node not in self.deleted_equation_current:
+            nodes.append(output_node+self.rescaler[output_node])
+            data.append(intensity) # outbound intensity
+        (data_rhs,(nodes_rhs,)) = self.rhs
+        self.rhs = (np.append(data_rhs,np.array(data),axis=0),(np.append(nodes_rhs,np.array(nodes),axis=0),))
+        return self.rhs
+
+    def build_second_member_tension(self,tension,input_node,output_node):
+        """building second member in the case of an enforced tension
+        To be able to enforce a tension we need to remove one of the equation in the system
+        and add the tension enforced equation
+        By default we remove the first kirchoff law within the correct subsystem
+        Warning this function changes the system, please re-get the system before solving it (call get_system)
+
+        Parameters
+        ----------
+        tension : complex
+            enforced tension
+        input_node : int
+            node where the tension is enforce
+        output_node : int
+            node from where the tension is enforced
+
+        Returns
+        -------
+        Tuple(np.array,(np.array))
+            second member of the linear system in a COO like format
+        """
+        targeted_subsystem = 0
+        if self.number_of_subsystems>=2:
+            valid = False
+            for index_sub,system in enumerate(self.list_of_subgraphs):
+                if input_node in system and output_node in system:
+                    valid =True
+                    targeted_subsystem=index_sub
+                else:
+                    continue
+            if not valid:
+                raise IndexError("Nodes indicated do not belong to the same subsystem")
+        print("Warning this function changes the system, please re-evaluate it before solving the system (call get_system)")
+        (data,(i_s,j_s)) = self.system
+        (data_rhs,(nodes,)) = self.rhs
+
+        new_eq = self.number_intensities+self.size +self.source_count
+        sign = np.sign(output_node-input_node)
+
+        ## Adding the new equation in S1
+        if input_node in self.deleted_equation_current:
+            data = np.append(data,np.array([1.,-1.,-sign]),axis=0)
+            i_s = np.append(i_s,np.array([new_eq,new_eq,output_node+self.rescaler[output_node]]),axis=0)
+            j_s = np.append(j_s,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq]),axis=0)
+        elif output_node in self.deleted_equation_current:
+            data = np.append(data,np.array([1.,-1.,sign]),axis=0)
+            i_s = np.append(i_s,np.array([new_eq,new_eq,input_node+self.rescaler[input_node]]),axis=0)
+            j_s = np.append(j_s,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq]),axis=0)
+        else:
+            data = np.append(data,np.array([1.,-1.,sign,-sign]),axis=0)
+            i_s = np.append(i_s,np.array([new_eq,new_eq,input_node+self.rescaler[input_node],output_node+self.rescaler[output_node]]),axis=0)
+            j_s = np.append(j_s,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq,new_eq]),axis=0)
+
+        ## second member value
+        nodes= np.append(nodes, [new_eq],axis=0)
+        data_rhs= np.append(data_rhs, [tension],axis=0)
+
+         ## reaffecting the systems and second member
+        self.system = (data,(i_s,j_s))
+        self.rhs = (data_rhs,(nodes,))
+
+        ## counter for tension source
+        self.source_count +=1
+        self.source_signs=np.append(self.source_signs,[sign])
+        return self.rhs
+
+    def build_intensity_and_voltage_from_vector(self,sol):
+        sign = np.sign(self.impedence_coords[1]-self.impedence_coords[0])
+        if self.source_count!=0:
+            return (sol[:self.number_intensities]*sign,
+                    sol[self.number_intensities:-self.source_count],
+                    sol[...,-self.source_count:]*self.source_signs
+                    )
+
+        else:
+            return (sol[:self.number_intensities]*sign,
+                    sol[self.number_intensities:],
+                    np.array([],dtype=float)
+                    )

ElecSolver/TemporalSystemBuilder.py

@@ -0,0 +1,462 @@
+import numpy as np
+import networkx as nx
+from scipy.sparse import coo_matrix, block_diag
+
+
+class TemporalSystemBuilder():
+    def __init__(self,coil_coords,coil_data,res_coords,res_data,capa_coords,capa_data,inductive_mutuals_coords,inductive_mutuals_data,res_mutual_coords,res_mutual_data):
+        """Class for building the linear system to solve for both temporal and frequency studies
+
+        Parameters
+        ----------
+        coil_coords : np.array of shape (L,2) L being the number of coils
+            Connectivity coordinates in the graph of each inductance
+            Repetitions will be considered as another coil in //
+        coil_data : np.array of shape (L,) L being the number of coils
+            Values of inductance whose coordinates are in coil_coords
+        res_coords : np.array of shape (R,2) R being the number of resistances
+            Connectivity coordinates in the graph of each resistance
+            Repetitions will be considered as another resistance in //
+        res_data : np.array of shape (R,) R being the number of resistances
+            Values of resistance whose coordinates are in res_coords
+        capa_coords : np.array of shape (C,2) C being the number of capacities
+            Connectivity coordinates in the graph of each capacity
+            Repetitions will be considered as another capacity in //
+        capa_data : np.array of shape (R,) R being the number of capacities
+            Values of capacity whose coordinates are in res_coords
+        inductive_mutuals_coords : np.array of shape (M,2) M being the number of mutuals in the system
+            The coordinates are the indices of the coils in the coil_data array that have a mutual effect
+            Inductive mutuals are only supported between coils
+            Repetitions will be considered as another mutual
+        inductive_mutuals_data : np.array of shape (M,) M being the number of mutuals in the system
+            Values of mutuals whose coordinates are in inductive_mutuals_coords.
+            The mutual follows the sign of the nodes given in the coil_coords array
+        res_mutual_coords :np.array of shape (N,2) N being the number of resistive mutuals in the system
+            the coordinates are the indices of the coils or resistance in the coil_data and res_data array that have a resistive mutual effect
+            resitive mutuals are only supported between coils and resistances
+        res_mutual_data : np.array of shape (N,) N being the number of resistive mutuals in the system
+            Values of mutuals whose coordinates are in res_mutuals_coords.
+            The mutual follows the sign of the nodes given in the coil_coords or res_coord array
+        """
+        self.all_coords = np.concatenate((coil_coords,res_coords,capa_coords),axis=1)
+        all_points = np.unique(self.all_coords)
+        if all_points.shape != np.max(self.all_coords)+1:
+            IndexError("There is one or multiple lonely nodes please clean your impedence graph")
+        self.all_impedences = np.concatenate([coil_data,res_data,capa_data],axis=0)
+
+        self.coil_coords=coil_coords
+        self.coil_data=coil_data
+        self.res_coords=res_coords
+        self.res_data=res_data
+        self.capa_coords=capa_coords
+        self.capa_data=capa_data
+        self.inductive_mutuals_coords=inductive_mutuals_coords
+        self.inductive_mutuals_data=inductive_mutuals_data
+        self.res_mutual_coords=res_mutual_coords
+        self.res_mutual_data=res_mutual_data
+
+
+        # actual number of node in the system
+        self.size = np.max(self.all_coords)+1
+        # number of intensities
+        self.number_intensities = self.all_impedences.shape[0]
+        ## making graph and checking number of subgraphs for mass enforcing and intensity checking
+        unique_coords = np.unique(self.all_coords,axis=1)
+        sym_graph = np.concatenate((unique_coords,np.stack((unique_coords[1],unique_coords[0]),axis=0)),axis=1)
+        links = np.ones(sym_graph.shape[1])
+        self.graph =  nx.from_scipy_sparse_array(coo_matrix((links,(sym_graph[0],sym_graph[1]))))
+        ## keep the subgraphs
+        self.list_of_subgraphs = [ list(sub) for sub in nx.connected_components(self.graph)]
+        self.number_of_subsystems = len(self.list_of_subgraphs)
+        ## location of mass
+        self.affected_potentials = [-1]*self.number_of_subsystems
+        ## by default remove 1 node equation per subsytem otherwise system is singular
+        self.deleted_equation_current = [subsystem[0] for subsystem in self.list_of_subgraphs]
+        ## number of tension sources
+        self.source_count = 0
+        self.source_signs = np.array([],dtype=int)
+        ## initializing second member as empty
+        self.rhs = (np.array([]),(np.array([],dtype=int),))
+        ## shifter for intensities equations
+        rescaler = np.zeros(self.size)
+        rescaler[self.deleted_equation_current]=1
+        rescaler = -np.cumsum(rescaler)
+        self.rescaler =rescaler.astype(int)
+        ## offsets for simplifying building the system
+        offset_j = self.all_impedences.shape[0]
+        offset_i = self.size-len(self.deleted_equation_current)
+        self.offset_i = offset_i
+        self.offset_j = offset_j
+
+    def set_mass(self,*args):
+        """Function to affect a mass to subsystems
+        If the system already has a mass provided then a warning is displayed and mass reaffected
+        """
+        for index in args:
+            for pivot,subsystem in enumerate(self.list_of_subgraphs):
+                if index in subsystem:
+                    if self.affected_potentials[pivot]!=-1:
+                        print(f"Subsystem {pivot} already add a mass, reaffecting the value")
+                    self.affected_potentials[pivot]=index
+                    break
+
+    def affect_potentials(self):
+        """Function to check whether the masses were all affected and assign some if some are missing
+        """
+        for i in range(len(self.affected_potentials)):
+            if -1 == self.affected_potentials[i]:
+                self.affected_potentials[i]= self.list_of_subgraphs[i][0]
+                print(f"Subsytem {i} has not been affected to the mass, we chose {self.list_of_subgraphs[i][0]}")
+
+    def build_system(self):
+        """Building sytem assuming that data was given as coords / data tuples
+        This function builds 3 matrixes:
+        S1 which is the real part of the system
+        S2 which is the derivative part of the system
+        S_init which is the system that needs to be solved for having initial conditions departing from null conditions
+        """
+        ## affecting masses if need be
+        self.affect_potentials()
+        ## Building a sparse COO matrix
+
+
+        ## Building all vectorized values necessary
+        i_s_vals = np.max(self.all_coords,axis=0)
+        j_s_vals = np.min(self.all_coords,axis=0)
+        values = self.all_impedences
+
+
+        ## node laws (only add to S1)
+        data_nodes = np.concatenate((np.ones(self.number_intensities),-np.ones(self.number_intensities)),axis=0)
+        j_s_nodes = np.tile(np.arange(self.number_intensities,dtype=int),(2,))
+        i_s_nodes = np.concatenate((i_s_vals,j_s_vals),axis=0)
+
+        # Removing one current equation per subsytem
+        mask_removed_eq = ~np.isin(i_s_nodes,self.deleted_equation_current)
+        data_nodes_S1 = data_nodes[mask_removed_eq]
+        j_s_nodes_S1 = j_s_nodes[mask_removed_eq]
+        i_s_nodes_S1 = i_s_nodes[mask_removed_eq]
+        i_s_nodes_S1 = i_s_nodes_S1 + self.rescaler[i_s_nodes_S1]
+
+
+
+        ## Kirchoff
+
+        ## coils (contribution to S1 for potentials, S2 for intensities)
+        i_s_coils = np.max(self.coil_coords,axis=0)
+        j_s_coils = np.min(self.coil_coords,axis=0)
+        i_s_edges_coil_S1 = self.offset_i + np.concatenate([np.arange(self.coil_data.shape[0],dtype=int)]*2,axis=0 )
+        j_s_edges_coil_S1 = np.concatenate([self.offset_j+i_s_coils,self.offset_j+j_s_coils],axis=0)
+        data_edges_coil_S1 = np.concatenate([np.ones(self.coil_data.shape[0]),-np.ones(self.coil_data.shape[0])],axis=0)
+
+        i_s_edges_coil_S2 = self.offset_i + np.arange(self.coil_data.shape[0],dtype=int)
+        j_s_edges_coil_S2 = np.arange(self.coil_data.shape[0],dtype=int)
+        data_edges_coil_S2 = self.coil_data
+
+
+        offset_coil= self.coil_data.shape[0]
+
+        ## resistance (only goes to S1)
+        i_s_res = np.max(self.res_coords,axis=0)
+        j_s_res = np.min(self.res_coords,axis=0)
+        i_s_edges_res_S1 = self.offset_i+offset_coil + np.concatenate([np.arange(self.res_data.shape[0],dtype=int)]*3,axis=0 )
+        j_s_edges_res_S1 = np.concatenate([self.offset_j+i_s_res,self.offset_j+j_s_res,offset_coil+np.arange(self.res_data.shape[0],dtype=int)],axis=0)
+        data_edges_res_S1 = np.concatenate([np.ones(self.res_data.shape[0]),-np.ones(self.res_data.shape[0]),self.res_data],axis=0)
+
+        offset_res = self.res_data.shape[0]
+
+
+
+        ## capacities (contribution to S2 for potentials, S1 for intensities)
+        i_s_capa = np.max(self.capa_coords,axis=0)
+        j_s_capa = np.min(self.capa_coords,axis=0)
+        i_s_edges_capa_S1 = self.offset_i+offset_coil+offset_res + np.arange(self.capa_data.shape[0],dtype=int)
+        j_s_edges_capa_S1 = offset_coil+offset_res+np.arange(self.capa_data.shape[0],dtype=int)
+        data_edges_capa_S1 = np.ones(self.capa_data.shape[0])
+
+        i_s_edges_capa_S2 = self.offset_i+offset_coil+offset_res + np.concatenate([np.arange(self.capa_data.shape[0],dtype=int)]*2,axis=0 )
+        j_s_edges_capa_S2 = np.concatenate([self.offset_j+i_s_capa,self.offset_j+j_s_capa],axis=0)
+        data_edges_capa_S2 = np.concatenate([self.capa_data,-self.capa_data],axis=0)
+
+
+        ## adding mutuals to the system
+        sign = np.sign(self.all_coords[0]-self.all_coords[1])
+
+        ## inductive mutuals (contribution to S2 only)
+        i_s_additionnal_S2 = self.offset_i + np.concatenate((self.inductive_mutuals_coords[0],self.inductive_mutuals_coords[1]),axis=0)
+        j_s_additionnal_S2 = np.concatenate((self.inductive_mutuals_coords[1],self.inductive_mutuals_coords[0]),axis=0)
+        data_additionnal_S2 = np.tile(self.inductive_mutuals_data*sign[self.inductive_mutuals_coords[0]]*sign[self.inductive_mutuals_coords[1]],(2,))
+
+        ## resistive mutuals (contribution to S1 only)
+        i_s_additionnal_S1= self.offset_i + np.concatenate((self.res_mutual_coords[0],self.res_mutual_coords[1]),axis=0)
+        j_s_additionnal_S1 = np.concatenate((self.res_mutual_coords[1],self.res_mutual_coords[0]),axis=0)
+        data_additionnal_S1 = np.tile(self.res_mutual_data*sign[self.res_mutual_coords[0]]*sign[self.res_mutual_coords[1]],(2,))
+
+
+        ## mass equations (1 per subsystem)
+        i_s_mass_S1 = np.arange(self.offset_i+self.offset_j,self.offset_i+self.offset_j+len(self.affected_potentials))
+        j_s_mass_S1 = self.offset_j+np.array(self.affected_potentials)
+        data_mass_S1 = np.ones(len(self.affected_potentials))
+
+
+
+        ## building S1 system
+        i_s_S1 = np.concatenate((i_s_nodes_S1,i_s_edges_coil_S1,i_s_edges_res_S1,i_s_edges_capa_S1,i_s_additionnal_S1,i_s_mass_S1),axis=0)
+        j_s_S1 = np.concatenate((j_s_nodes_S1,j_s_edges_coil_S1,j_s_edges_res_S1,j_s_edges_capa_S1,j_s_additionnal_S1,j_s_mass_S1),axis=0)
+        data_S1 = np.concatenate((data_nodes_S1,data_edges_coil_S1,data_edges_res_S1,data_edges_capa_S1,data_additionnal_S1,data_mass_S1),axis=0)
+
+        ## building S2 system
+        i_s_S2 = np.concatenate((i_s_edges_coil_S2,i_s_edges_capa_S2,i_s_additionnal_S2),axis=0)
+        j_s_S2 = np.concatenate((j_s_edges_coil_S2,j_s_edges_capa_S2,j_s_additionnal_S2),axis=0)
+        data_S2 = np.concatenate((data_edges_coil_S2,data_edges_capa_S2,data_additionnal_S2),axis=0)
+
+        ## building S_init system
+        i_s_init = np.concatenate((i_s_nodes_S1,i_s_edges_coil_S2,i_s_edges_res_S1,i_s_edges_capa_S2,i_s_mass_S1),axis=0)
+        j_s_init = np.concatenate((j_s_nodes_S1,j_s_edges_coil_S2,j_s_edges_res_S1,j_s_edges_capa_S2,j_s_mass_S1),axis=0)
+        data_init = np.concatenate((data_nodes_S1,data_edges_coil_S2,data_edges_res_S1,data_edges_capa_S2,data_mass_S1),axis=0)
+
+        self.S_init=(data_init,(i_s_init,j_s_init))
+
+        self.S1 = (data_S1,(i_s_S1.astype(int),j_s_S1.astype(int)))
+        self.S2 = (data_S2,(i_s_S2.astype(int),j_s_S2.astype(int)))
+        ## return for debug if needed
+        return self.S1,self.S2,self.S_init
+
+
+    def build_second_member_intensity(self,intensity,input_node,output_node):
+        """Function to build a second member for the scenario of current injection in the sparse system
+
+        Parameters
+        ----------
+        intensity : float
+            intensity to inject
+        input_node : int
+            which node to take for injection
+        output_node : int
+            which node for current retrieval
+
+        Returns
+        -------
+        Tuple(np.array,(np.array))
+            second member of the linear system in a COO like format
+        """
+        data = []
+        nodes = []
+        if self.number_of_subsystems>=2:
+            valid = False
+            for system in self.list_of_subgraphs:
+                if input_node in system and output_node in system:
+                    valid =True
+                else:
+                    continue
+            if not valid:
+                raise IndexError("Nodes indicated do not belong to the same subsystem")
+        ## making sure the equation is actually in the system
+        if input_node not in self.deleted_equation_current:
+            nodes.append(input_node+self.rescaler[input_node])
+            data.append(-intensity) # inbound intensity
+        if output_node not in self.deleted_equation_current:
+            nodes.append(output_node+self.rescaler[output_node])
+            data.append(intensity) # outbound intensity
+        (data_rhs,(nodes_rhs,)) = self.rhs
+        self.rhs = (np.append(data_rhs,np.array(data),axis=0),(np.append(nodes_rhs,np.array(nodes),axis=0),))
+        return self.rhs
+
+    def build_second_member_tension(self,tension,input_node,output_node):
+        """Building second member in the case of an enforced tension
+        This adds one equation and one degree of freedom in the system (the source intensity)
+        Warning this function changes the system, please re-get the system before solving it (call get_system)
+
+        Parameters
+        ----------
+        tension : complex
+            enforced tension
+        input_node : int
+            node where the tension is enforced
+        output_node : int
+            node from where the tension is enforced
+
+        Returns
+        -------
+        Tuple(np.array,(np.array))
+            second member of the linear system in a COO like format
+        """
+        targeted_subsystem = 0
+        if self.number_of_subsystems>=2:
+            valid = False
+            for index_sub,system in enumerate(self.list_of_subgraphs):
+                if input_node in system and output_node in system:
+                    valid =True
+                    targeted_subsystem=index_sub
+                else:
+                    continue
+            if not valid:
+                raise IndexError("Nodes indicated do not belong to the same subsystem")
+        print("Warning this function changes the system, please re-evaluate it before solving the system (call get_system)")
+        (data_init,(i_s_init,j_s_init)) = self.S_init
+        (data_S1,(i_s_S1,j_s_S1)) = self.S1
+        (data_S2,(i_s_S2,j_s_S2)) = self.S2
+        (data_rhs,(nodes,)) = self.rhs
+        new_eq = self.number_intensities+self.size +self.source_count
+        sign = np.sign(output_node-input_node)
+
+        ## Adding the new equation in S_init
+        if input_node in self.deleted_equation_current:
+            data_init = np.append(data_init,np.array([1.,-1.,-sign]),axis=0)
+            i_s_init = np.append(i_s_init,np.array([new_eq,new_eq,output_node+self.rescaler[output_node]]),axis=0)
+            j_s_init = np.append(j_s_init,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq]),axis=0)
+        elif output_node in self.deleted_equation_current:
+            data_init = np.append(data_init,np.array([1.,-1.,sign]),axis=0)
+            i_s_init = np.append(i_s_init,np.array([new_eq,new_eq,input_node+self.rescaler[input_node]]),axis=0)
+            j_s_init = np.append(j_s_init,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq]),axis=0)
+        else:
+            data_init = np.append(data_init,np.array([1.,-1.,sign,-sign]),axis=0)
+            i_s_init = np.append(i_s_init,np.array([new_eq,new_eq,input_node+self.rescaler[input_node],output_node+self.rescaler[output_node]]),axis=0)
+            j_s_init = np.append(j_s_init,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq,new_eq]),axis=0)
+
+        ## Adding the new equation in S1
+        if input_node in self.deleted_equation_current:
+            data_S1 = np.append(data_S1,np.array([1.,-1.,-sign]),axis=0)
+            i_s_S1 = np.append(i_s_S1,np.array([new_eq,new_eq,output_node+self.rescaler[output_node]]),axis=0)
+            j_s_S1 = np.append(j_s_S1,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq]),axis=0)
+        elif output_node in self.deleted_equation_current:
+            data_S1 = np.append(data_S1,np.array([1.,-1.,sign]),axis=0)
+            i_s_S1 = np.append(i_s_S1,np.array([new_eq,new_eq,input_node+self.rescaler[input_node]]),axis=0)
+            j_s_S1 = np.append(j_s_S1,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq]),axis=0)
+        else:
+            data_S1 = np.append(data_S1,np.array([1.,-1.,sign,-sign]),axis=0)
+            i_s_S1 = np.append(i_s_init,np.array([new_eq,new_eq,input_node+self.rescaler[input_node],output_node+self.rescaler[output_node]]),axis=0)
+            j_s_S1 = np.append(j_s_S1,np.array([self.offset_j + input_node,self.offset_j+output_node,new_eq,new_eq]),axis=0)
+
+
+        ## second member value
+        nodes= np.append(nodes, [new_eq],axis=0)
+        data_rhs= np.append(data_rhs, [tension],axis=0)
+
+
+        ## reaffecting the systems and second member
+        self.S_init = (data_init,(i_s_init,j_s_init))
+        self.S1 = (data_S1,(i_s_S1,j_s_S1))
+        self.S2 = (data_S2,(i_s_S2,j_s_S2)) ## S2 is unchanged
+        self.rhs = (data_rhs,(nodes,))
+
+        ## counter for tension source
+        self.source_count +=1
+        self.source_signs=np.append(self.source_signs,[sign])
+        return self.rhs
+
+    def get_init_system(self):
+        """Function to determine the initial state of the system as coo_matrix
+
+        Returns
+        -------
+        sys: coo_matrix
+            left hand side of the equation to solve
+        rhs:
+            right hand side of the system to solve
+        """
+        sys = coo_matrix(self.S_init,shape=(self.number_intensities+self.size+self.source_count,self.number_intensities+self.size+self.source_count))
+        rhs = np.zeros(self.number_intensities+self.size+self.source_count)
+        (data_rhs,(nodes,)) = self.rhs
+        np.add.at(rhs, nodes, data_rhs)
+        return sys,rhs
+
+    def get_system(self):
+        """Function to get the whole system to solve as coo_matrix
+
+        Returns
+        -------
+        sys1 : coo_matrix
+            real part of the system
+        sys2 : coo_matrix
+            img part of the system (need to be multiplyied by j.omega for frequency studies)
+        rhs: np.array
+        """
+        sys1 = coo_matrix(self.S1,shape=(self.number_intensities+self.size+self.source_count,self.number_intensities+self.size+self.source_count))
+        sys2 = coo_matrix(self.S2,shape=(self.number_intensities+self.size+self.source_count,self.number_intensities+self.size+self.source_count))
+        rhs = np.zeros(self.number_intensities+self.size+self.source_count)
+        (data_rhs,(nodes,)) = self.rhs
+        np.add.at(rhs, nodes, data_rhs)
+        return sys1,sys2,rhs
+
+    def get_frequency_system(self,omega):
+        """Function to get the complex matrix for frequency studies
+
+        Parameters
+        ----------
+        omega : float
+            pulsation of the system
+
+        Returns
+        -------
+        sys: coo_matrix, dtype=complex
+            complex system for frequency studies
+        rhs: np.array
+            right hand side of the system
+        """
+        sys1,sys2,rhs = self.get_system()
+        return sys1+1j*omega*sys2,rhs
+
+    def get_frequency_system_all_omegas(self,omegas):
+        """Builds a big system for solving once for all all frequencies given
+        once this system has been solved, you need to reshape the output of the system with batches of size A.shape[0]//len(omegas)
+        to get the output for each omegas
+
+        Parameters
+        ----------
+        omegas : list(float)
+            iterable that has a __len__ function that oontains all values of omega to compute
+
+        Returns
+        -------
+        A :  coo_matrix, dtype=complex
+            system containing all the frequencies given in omegas
+        RHS : np.array
+            second member for the system A
+
+        """
+        sys1,sys2,rhs = self.get_system()
+        A = block_diag([sys1+1j*omega*sys2 for omega in omegas])
+        RHS = np.tile(rhs,(len(omegas),))
+        return A,RHS
+
+    def build_intensity_and_voltage_from_vector(self,sol):
+        """Utility function to reshape the solution of frequency studies or temporal studies
+
+        Parameters
+        ----------
+        sol : np.array of shape (*, self.number_intensities+self.size+self.source_count)
+            array containing as many solutions as wanted
+
+        Returns
+        -------
+        coil_intensities: np.array of shape (*,coil_data.shape[0])
+            intensities following the directions given by coil_coords
+        res_intensities: np.array of shape (*,res_data.shape[0])
+            intensities following the directions given by res_coords
+        capa_intensities: np.array of shape (*,capa_data.shape[0])
+            intensities following the directions given by res_coords
+        voltages: np.array of shape (*,self.size)
+            voltage of the points in the graph
+        source_intensities: np.array of shape (*, self.source_count)
+            if there are voltage sources this contains the source intensities
+        """
+        sign = np.sign(self.all_coords[1]-self.all_coords[0])
+        offset_coil = self.coil_data.shape[0]
+        offset_res = self.res_data.shape[0]
+        offset_capa = self.capa_data.shape[0]
+        if self.source_count!=0:
+            return (sol[...,:offset_coil]*sign[:offset_coil],
+                sol[...,offset_coil:offset_coil+offset_res]*sign[offset_coil:offset_coil+offset_res],
+                sol[...,offset_coil+offset_res:offset_coil+offset_res+offset_capa]*sign[offset_coil+offset_res:offset_coil+offset_res+offset_capa],
+                sol[...,self.number_intensities:-self.source_count],
+                sol[...,-self.source_count:]*self.source_signs
+            )
+        else:
+            return (sol[...,:offset_coil]*sign[:offset_coil],
+                sol[...,offset_coil:offset_coil+offset_res]*sign[offset_coil:offset_coil+offset_res],
+                sol[...,offset_coil+offset_res:offset_coil+offset_res+offset_capa]*sign[offset_coil+offset_res:offset_coil+offset_res+offset_capa],
+                sol[...,self.number_intensities:-self.source_count],
+                np.array([],dtype=float)
+            )
+

ElecSolver/__init__.py

@@ -0,0 +1,7 @@
+try:
+    from ._version import __version__
+except ImportError:  # pragma: no cover
+    __version__ = "None"
+
+from .FrequencySystemBuilder import FrequencySystemBuilder
+from .TemporalSystemBuilder import TemporalSystemBuilder

ElecSolver/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)

ElecSolver/utils.py

@@ -0,0 +1,149 @@
+import numpy as np
+from scipy.sparse import coo_matrix
+
+def parallel_sum(*impedences):
+    """Function to compute the graph of impedences resulting from // graphs
+    works for any number of impedence graphs
+
+    Returns
+    -------
+    scipy.sparse.coo_matrix
+        resulting impedence
+    """
+    coords_tot = np.concatenate([impedence.coords for impedence in impedences],axis=1)
+    data_tot = np.concatenate([impedence.data for impedence in impedences])
+    current_indexes = np.arange(0,data_tot.shape[0],dtype=int)
+
+    uniques,indexes,inverse,counts = np.unique(coords_tot,return_index=True,return_inverse=True,return_counts=True,axis=1)
+    new_coords = uniques
+    new_data = data_tot[indexes].astype(complex)
+
+    remaining_coords = coords_tot.copy()
+    remaining_data = data_tot.copy()
+    reverse_counts = counts[inverse]
+    reverse_counts_ref = reverse_counts.copy()
+
+    reverse_counts[indexes]=0
+    reverse_indexes = indexes[inverse]
+
+
+    while np.max(reverse_counts)>1:
+        mask = (reverse_counts>1)
+        remaining_coords = remaining_coords[:,mask]
+
+        remaining_data = remaining_data[mask]
+        current_indexes=current_indexes[mask]
+
+        uniques,indexes,inverse,counts = np.unique(remaining_coords,return_index=True,return_inverse=True,return_counts=True,axis=1)
+        new_data[reverse_indexes[current_indexes[indexes]]] = new_data[reverse_indexes[current_indexes[indexes]]]*remaining_data[indexes]/(new_data[reverse_indexes[current_indexes[indexes]]]+ remaining_data[indexes])
+        reverse_counts = counts[inverse]
+        reverse_counts[indexes]=0
+
+    indexed_data = np.zeros(impedences[0].shape[0]**2,dtype=complex)
+    indexed_data[new_coords[0]*impedences[0].shape[0]+new_coords[1]]=new_data
+    return coo_matrix((new_data,(new_coords[0],new_coords[1])))
+
+
+def serie_sum(*impedences):
+    """Function to compute the impedences that go serial
+
+    Returns
+    -------
+    scipy.sparse.coo_matrix
+        resulting impedence
+
+    """
+    return sum(impedences).tocoo()
+
+
+def cast_complex_system_in_real_system(sys,b):
+    """Function to cast an n dimensional complex system into an
+    equivalent 2n dimension real system
+    the solution of the initial system is the concatenation of the real and
+    imaginary part of the solution of this system:
+    sol_comp = sol_real[:n]+1.0j*sol_real[n:]
+
+    Parameters
+    ----------
+    sys : scipy.sparse.coo_matric
+        system with complex data
+    b : np.array
+        second member with real or complex values
+
+    Returns
+    -------
+    sys_comp
+        real system equivalent to complex system
+    new_b
+        real second member equivalent to complex system
+    """
+    coords = np.stack((sys.row,sys.col),axis=1)
+    data = np.array(sys.data,dtype=complex)
+    b= b.astype(complex)
+    new_coords = np.concatenate((coords,coords+[[0],[sys.shape[0]]],coords+[[sys.shape[0]],[0]],coords+[[sys.shape[0]],[sys.shape[0]]]),axis=1)
+    new_data = np.concatenate((data.real,-data.imag,data.imag,data.real),axis=0)
+    sys_comp = coo_matrix((new_data,(new_coords[0],new_coords[1])))
+    new_b = np.concatenate((b.real,b.imag),axis=0)
+    return sys_comp,new_b
+
+
+def constant_block_diag(A,repetitions):
+    """Function to repeat the matrix A multiple times along the diagonal
+    This is a faster version of block_diag in the case of having always the same block
+
+    Parameters
+    ----------
+    A : scpiy.sparse.coo_matrix
+        block to repeat multiple times on the diagonal
+    repetitions : int
+        number of repetitions to perform
+
+    Returns
+    -------
+    coo_matrix
+        block diagonal sparse matrix
+    """
+    size = A.shape[0]
+    indexes = A.data.shape[0]
+    rows = np.tile(A.row,(repetitions,))+size*np.repeat(np.arange(0,repetitions,dtype=int),indexes)
+    cols = np.tile(A.col,(repetitions,))+size*np.repeat(np.arange(0,repetitions,dtype=int),indexes)
+    data = np.tile(A.data,(repetitions,))
+    return coo_matrix((data,(rows,cols)),shape=(repetitions*size,repetitions*size))
+
+
+
+def build_big_temporal_system(S1,S2,dt,rhs,sol,nb_timesteps):
+    """Function to build the temporal system for nb_timesteps
+    The solution of this system is the concatenation of the all the timsteps
+    except for the initial timestep that the user is free to concatenate with the solutions
+    Tip: reshaping the solution of the systme with shape (nb_timesteps,sol.shape[0]) provides
+    the solution array indexed by the timestep
+
+    Parameters
+    ----------
+    S1 : coo_matrix
+        real part of the temporal system
+    S2 : coo_matrix
+        derivative part of the temporal system
+    dt : float
+        timestep for the simulation
+    rhs : np.array
+        second member of the system
+    sol : initial condition
+        solution of initial condition system
+    nb_timesteps : int
+        number of timesteps
+
+    Returns
+    -------
+    S : coo_matrix
+        system left hand side for the temporal
+    """
+    A = constant_block_diag((S2+dt*S1).tocoo(),nb_timesteps)
+    B = constant_block_diag(-S2,nb_timesteps-1)
+    B = coo_matrix((B.data,(B.row+S1.shape[0],B.col)),shape=A.shape)
+    S = A+B
+    RHS = np.concatenate([rhs*dt+S2@sol]+[rhs*dt]*(nb_timesteps-1),axis=0)
+    return S,RHS
+
+

elecsolver-0.1.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: ElecSolver
+Version: 0.1.0
+Summary: Formalizes electric systems as linear problems for temporal and frequency-domain studies.
+Author-email: William Piat <william.piat3@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/williampiat3/ElecSolver
+Platform: Linux
+Platform: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENCE.txt
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: networkx
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pymumps; extra == "dev"
+Dynamic: license-file
+
+# ElectricSystemSolver
+
+## Overview
+
+**ElectricSystemSolver** formalizes electric systems as linear problems, suitable for both **temporal** and **frequency-domain** studies.
+It focuses on constructing the linear system representation, leaving the actual numerical resolution to the user.
+
+This repository is **not** a general-purpose electrical system solver. Instead, it acts as a **bridge** between:
+
+- The graph-based description of an electric network
+- The corresponding sparse linear system to solve
+
+Its main goal is to provide a friendly Python interface for simulating analog electric systems. While suitable for small circuit simulations, its strength lies in scalability—handling millions of nodes and components, provided that you possess sufficient computational resources.
+
+
+> [!NOTE]
+> Non-linear components are not supported. You must manage event detection and system updates yourself.
+
+
+## Table of content
+
+- [ElectricSystemSolver](#electricsystemsolver)
+  - [Overview](#overview)
+  - [Table of content](#table-of-content)
+  - [How to install](#how-to-install)
+  - [Components](#components)
+    - [FrequencySystemBuilder](#frequencysystembuilder)
+      - [Features](#features)
+      - [Example](#example)
+      - [Adding a Parallel Resistance](#adding-a-parallel-resistance)
+    - [TemporalSystemBuilder](#temporalsystembuilder)
+      - [Features](#features-1)
+      - [Example](#example-1)
+  - [Solver suggestions](#solver-suggestions)
+
+## How to install
+For now this package is not distributed the only way to install it is by:
+
+1. Cloning this repo:
+
+```
+git clone https://github.com/williampiat3/ElectricSystemSolver.git
+```
+
+2. Creating a conda environement using the `env.yml` file:
+
+```
+conda env create -n ElecSolver -f ElectricSystemSolver/env.yml
+```
+
+> [!WARNING]
+> pyMumps is not supported on Windows (But it is on WSL!!): If you want to execute this code on Windows, remove pyMumps from the `env.yml` file and use other solvers instead
+
+3. Exporting the `PYTHONPATH` variable to import the system builders more smoothly
+
+```
+export PYTHONPATH='path/to/ElectricSystemSolver/src'
+```
+
+
+## Components
+
+### FrequencySystemBuilder
+
+This class handles **frequency-domain** analysis of linear electric systems.
+
+#### Features
+
+- Supports tension and intensity sources
+- Models inductive and resistive mutuals
+- Detects and couples multiple subsystems
+- Accepts arbitrary complex impedances and mutuals
+- Constructs sparse linear systems (COO format)
+
+
+> [!TIP]
+> Some solvers do not support complex-valued systems. Use the utility function `cast_complex_system_in_real_system` in `utils.py` to convert an `n`-dimensional complex system into a `2n`-dimensional real system.
+
+#### Example
+
+We would like to study the following system:
+![Multiple system](img/schema.png)
+
+this can simply be defined in the following manner (We took R=1, L=1 and M=2):
+```python
+import numpy as np
+from scipy.sparse.linalg import spsolve
+from ElecSolver import FrequencySystemBuilder
+
+
+# Complex and sparse impedance matrix
+# notice coil impedence between points 0 and 2, and coil impedence between 3 and 4
+impedence_coords = np.array([[0,0,1,3],[1,2,2,4]], dtype=int)
+impedence_data = np.array([1, 1j, 1, 1j], dtype=complex)
+
+# Mutual inductance or coupling
+# The indexes here are the impedence indexes in impedence_data
+# The coupling is inductive
+mutuals_coords = np.array([[1],[3]], dtype=int)
+mutuals_data = np.array([2.j], dtype=complex)
+
+electric_sys = FrequencySystemBuilder(
+    impedence_coords,
+    impedence_data,
+    mutuals_coords,
+    mutuals_data
+)
+
+# Set node masses
+# 2 values because 2 subsystems
+electric_sys.set_mass(0, 3)
+# Building system
+electric_sys.build_system()
+electric_sys.build_second_member_intensity(intensity=10, input_node=2, output_node=0)
+
+# Get and solve the system
+sys, b = electric_sys.get_system()
+sol = spsolve(sys.tocsr(), b)
+intensities, potentials = electric_sys.build_intensity_and_voltage_from_vector(sol)
+
+## We see a tension appearing on the lonely coil (between node 3 and 4)
+print(potentials[3]-potentials[4])
+```
+#### Adding a Parallel Resistance
+We want to add components in parallel with existing components for instance inserting a resistor in parallel with the first inductance (between nodes 0 and 2)
+![Parallel system](img/schema3.png)
+
+In python, simply add the resistance to the list of impedence in the very first lines of the script:
+
+```python
+import numpy as np
+from scipy.sparse.linalg import spsolve
+from ElecSolver import FrequencySystemBuilder
+
+
+# We add an additionnal resistance between 0 and 2
+impedence_coords = np.array([[0,0,1,3,0],[1,2,2,4,2]], dtype=int)
+impedence_data = np.array([1, 1j,1, 1j,1], dtype=complex)
+
+# No need to change the couplings since indexes of the coils did not change
+mutuals_coords = np.array([[1],[3]], dtype=int)
+mutuals_data = np.array([2.j], dtype=complex)
+
+```
+
+
+### TemporalSystemBuilder
+
+This class models **time-dependent** systems using resistors, capacitors, coils, and mutuals.
+
+#### Features
+
+- Supports tension and intensity sources
+- Models inductive and resistive mutuals
+- Detects and couples multiple subsystems
+- Accepts 3 dipole types: resistances, capacities and coils
+- Constructs sparse linear systems (COO format)
+
+#### Example
+
+
+We would like to study the following system:
+![Temporal system](img/schema2.png)
+
+with R=1, L=0.1, C=2 this gives:
+
+```python
+import numpy as np
+from scipy.sparse.linalg import spsolve
+from ElecSolver import TemporalSystemBuilder
+
+## Defining resistances
+res_coords  = np.array([[0,2],[1,3]],dtype=int)
+res_data = np.array([1,1],dtype=float)
+## Defining coils
+coil_coords  = np.array([[1,0],[3,2]],dtype=int)
+coil_data = np.array([0.1,0.1],dtype=float)
+## Defining capacities
+capa_coords = np.array([[1,3],[2,0]],dtype=int)
+capa_data = np.array([2,2],dtype=float)
+
+## Defining empty mutuals here
+mutuals_coords=np.array([[],[]],dtype=int)
+mutuals_data = np.array([],dtype=float)
+
+
+res_mutuals_coords=np.array([[],[]],dtype=int)
+res_mutuals_data = np.array([],dtype=float)
+
+## initializing system
+elec_sys = TemporalSystemBuilder(coil_coords,coil_data,res_coords,res_data,capa_coords,capa_data,mutuals_coords,mutuals_data,res_mutuals_coords,res_mutuals_data)
+## Seting mass at point 0
+elec_sys.set_mass(0)
+## Build second member
+elec_sys.build_system()
+elec_sys.build_second_member_intensity(10,1,0)
+# getting initial condition system
+S_i,b = elec_sys.get_init_system()
+# initial condition
+sol = spsolve(S_i.tocsr(),b)
+# get system (S1 is real part, S2 derivative part)
+S1,S2,rhs = elec_sys.get_system()
+
+## Solving using euler implicit scheme
+dt=0.08
+vals_res1 = []
+vals_res2 = []
+for i in range(50):
+    currents_coil,currents_res,currents_capa,voltages,_ = elec_sys.build_intensity_and_voltage_from_vector(sol)
+    vals_res1.append(currents_res[1])
+    vals_res2.append(currents_res[0])
+    ## implicit euler time iterations
+    sol = spsolve(S2+dt*S1,b*dt+S2@sol)
+import matplotlib.pyplot as plt
+plt.xlabel("Time")
+plt.ylabel("Intensity")
+plt.plot(vals_res1,label="intensity res 1")
+plt.plot(vals_res2,label="intensity res 2")
+plt.legend()
+plt.savefig("intensities_res.png")
+```
+
+This outputs the following graph that displays the intensity passing through the resistances
+![Temporal system](img/intensities_res.png)
+
+
+## Solver suggestions
+
+- For **small or moderately sized systems**, the built-in `scipy.sparse.linalg.spsolve` is effective.
+- For **large-scale temporal problems**, consider using **MUMPS** (via `pyMUMPS`).
+  MUMPS is more efficient when only the second member (`b`) changes during time-stepping.
+
+> [!TIP]
+> See example `tests.test_temporal_system` in the tests on how to use pyMUMPS for solving the resulting system efficiently.
+

elecsolver-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ElecSolver/FrequencySystemBuilder.py,sha256=8GoF8R1d1Qfs3f2y4tXJfu5Yq7iPrZXM-cwogdzu5v0,11962
+ElecSolver/TemporalSystemBuilder.py,sha256=ierqBI2Vr9LoLVi9ddNzKo7Z7dmZ3uPEywGHn8F73jg,23515
+ElecSolver/__init__.py,sha256=jYln4Hwpz5Y7aXUxCnHU6kPs--2MXc58rbaTTQvcE8I,224
+ElecSolver/_version.py,sha256=-LyU5F1uZDjn6Q8_Z6-_FJt_8RE4Kq9zcKdg1abSSps,511
+ElecSolver/utils.py,sha256=M-42jBk3BW0jPq1DDAC04VwrDIgTAS0sI9q28l2j5YY,5215
+elecsolver-0.1.0.dist-info/licenses/LICENCE.txt,sha256=v-lfIiLUg0gkkSbraLUejUcFsyG7SbKQaK7GqgIEWFQ,1068
+elecsolver-0.1.0.dist-info/METADATA,sha256=Uy8P0iJJIVj3ZRJ99o8SBJ-ueLrx5UZiXhzT_9DZjG4,8548
+elecsolver-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+elecsolver-0.1.0.dist-info/top_level.txt,sha256=2toqgPNV9y44OzukZZEL4qeFZFkNR1GXZjIlZVmC-Ic,11
+elecsolver-0.1.0.dist-info/RECORD,,

elecsolver-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

elecsolver-0.1.0.dist-info/licenses/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 William PIAT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

elecsolver-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+ElecSolver