def write_v_map(self, name, remove=False, voltages=None, node_map=None):
     """Write voltage map identified by name. Remove the map after that if remove is True.
     If voltages and node_map are provided, create space for voltage map disregarding prior allocation.
     """
     if self.report_status==True:
         ComputeBase.logger.info('writing voltage map ' + name)
         
     if self.is_network:
         if voltages is None:
             vm = self.voltage_maps[name]
             nn = self.node_names
         else:
             vm = voltages
             nn = node_map
         CSIO.write_voltages(self.options.output_file, vm, nn, name)
     else:
         fileadd = name if (name=='') else ('_'+name)
         if voltages is None:
             vm = self.voltage_maps[name]
         else:
             vm = self._create_voltage_map(node_map, voltages)
         CSIO.write_aaigrid('voltmap', fileadd, vm, self.options, self.state)
         
     if remove:
         self.rm_v_map(name)
     elif voltages is not None:
         if self.is_network:
             self.alloc_v_map(name)
             self.accumulate_v_map(name, voltages, node_map)
         else:
             self.voltage_maps[name] = vm
Exemple #2
0
    def write_v_map(self, name, remove=False, voltages=None, node_map=None):
        """Write voltage map identified by name. Remove the map after that if remove is True.
        If voltages and node_map are provided, create space for voltage map disregarding prior allocation.
        """
        if self.report_status == True:
            ComputeBase.logger.info('writing voltage map ' + name)

        if self.is_network:
            if voltages is None:
                vm = self.voltage_maps[name]
                nn = self.node_names
            else:
                vm = voltages
                nn = node_map
            CSIO.write_voltages(self.options.output_file, vm, nn, name)
        else:
            fileadd = name if (name == '') else ('_' + name)
            if voltages is None:
                vm = self.voltage_maps[name]
            else:
                vm = self._create_voltage_map(node_map, voltages)
            CSIO.write_aaigrid('voltmap', fileadd, vm, self.options,
                               self.state)

        if remove:
            self.rm_v_map(name)
        elif voltages is not None:
            if self.is_network:
                self.alloc_v_map(name)
                self.accumulate_v_map(name, voltages, node_map)
            else:
                self.voltage_maps[name] = vm
Exemple #3
0
 def _write_store_c_map(self, name, remove, write, accumulate, voltages, G, node_map, finitegrounds, local_src, local_dst):
     if self.is_network:
         if voltages is not None:
             (node_currents, branch_currents) = self._create_current_maps(voltages, G, finitegrounds)
             branch_currents_array = Output._convert_graph_to_3_col(branch_currents, node_map)
         else:
             branch_currents, node_currents, branch_currents_array, _node_map = self.current_maps[name]
         
         if write:                
             # Append node names and convert to array format
             node_currents_array = Output._append_names_to_node_currents(node_currents, node_map)                
             # node_currents_array = Output._append_names_to_node_currents(node_currents, self.nn_sorted)# Fixme: Need something like this for multipe components in network mode?
             CSIO.write_currents(self.options.output_file, branch_currents_array, node_currents_array, name, self.options)
             
         if remove:
             self.rm_c_map(name)
         elif accumulate:
             full_branch_currents, full_node_currents, _bca, _np = self.current_maps[name]
             pos = np.searchsorted(self.nn_sorted, node_map)
             full_node_currents[pos] += node_currents
             bc_x = np.searchsorted(self.nn_sorted, branch_currents_array[:,0])
             bc_y = np.searchsorted(self.nn_sorted, branch_currents_array[:,1])                
             full_branch_currents = full_branch_currents + sparse.csr_matrix((branch_currents_array[:,2], (bc_x, bc_y)), shape=full_branch_currents.shape)
             self.current_maps[name] = (full_branch_currents, full_node_currents, branch_currents_array, node_map)
         else:
             self.current_maps[name] = (branch_currents, node_currents, branch_currents_array, node_map)
     else:
         if voltages is not None:
             while LowMemRetry.retry():
                 with LowMemRetry():
                     current_map = self._create_current_maps(voltages, G, finitegrounds, node_map)   
         else:
             current_map = self.current_maps[name]                                                                                
 
         if (self.options.set_focal_node_currents_to_zero==True) and (local_src is not None) and (local_dst is not None):
             # set source and target node currents to zero
             focal_node_pair_map = np.where(node_map == local_src+1, 0, 1)
             focal_node_pair_map = np.where(node_map == local_dst+1, 0, focal_node_pair_map)                                                
             current_map = np.multiply(focal_node_pair_map, current_map)
             del focal_node_pair_map
         
         if write:
             if name=='' and self.scenario != 'advanced': 
                 curMapName = 'cum_curmap' #For backward compatibility- ArcGIS
             else:
                 curMapName = 'curmap'
             fileadd = name if (name=='') else ('_'+name)
             CSIO.write_aaigrid(curMapName, fileadd, self._log_transform(current_map), self.options, self.state)
         if remove:
             self.rm_c_map(name)
         elif accumulate:
             self.current_maps[name] += current_map
         else:
             self.current_maps[name] = current_map