def test_tic_toc(self):
t = misc.tic()
assert t is None
t = misc.toc(quiet=False)
assert t is None
t = misc.toc(quiet=True)
assert t > 0
def _condition_update(self):
# Calculate the distance between the new pore and outlet pores
if self._end_condition == 'breakthrough':
newpore_position = self._net['pore.coords'][self._NewPore]
dist_sqrd = (self._outlet_position - newpore_position) * (
self._outlet_position - newpore_position)
if dist_sqrd[0].shape == (
3,
): # need to do this for MatFile networks because newpore_position is a nested array, not a vector (?)
dist_sqrd = dist_sqrd[0]
newpore_distance = np.sqrt(dist_sqrd[0] + dist_sqrd[1] +
dist_sqrd[2])
logger.debug('newpore distance')
logger.debug(newpore_distance)
if newpore_distance < self._current_distance:
self._percent_complete = np.round(
(self._initial_distance - newpore_distance) /
self._initial_distance * 100,
decimals=1)
logger.info('percent complete')
logger.info(self._percent_complete)
self._current_distance = newpore_distance
elif self._end_condition == 'total':
self._percent_complete = np.round(
(np.sum(self['pore.cluster_final'] > 0) /
self._net.num_pores()) * 100,
decimals=1)
if self._percent_complete > self._rough_complete + self._rough_increment:
self._rough_complete = np.floor(
self._percent_complete /
self._rough_increment) * self._rough_increment
print(' IP algorithm at', np.int(self._rough_complete),
'% completion at', np.round(misc.toc(quiet=True)), 'seconds')
# Determine if a new breakthrough position has occured
if self._NewPore in self._outlets:
logger.info(' ')
logger.info('BREAKTHROUGH AT PORE: ')
logger.info(self._NewPore)
logger.info('in cluster ')
logger.info(self._current_cluster)
if self._timing:
logger.info('at time')
logger.info(self._sim_time)
pass
if self._end_condition == 'breakthrough':
self.cluster_remove(self._current_cluster)
elif self._end_condition == 'total':
self._brkevent.append(self._NewPore)
if np.sum(self._cluster_data['active']) == 0:
logger.info(' ')
logger.info('SIMULATION FINISHED; no more active clusters')
if self._timing:
logger.info('at time')
logger.info(self._sim_time)
pass
self._condition = 0
print(' IP algorithm at 100% completion at ',
np.round(misc.toc(quiet=True)), ' seconds')
def test_tic_toc(self):
t = misc.tic()
assert t is None
t = misc.toc(quiet=False)
assert t is None
time.sleep(0.005)
t = misc.toc(quiet=True)
assert t > 0
def _condition_update(self):
# Calculate the distance between the new pore and outlet pores
if self._end_condition == 'breakthrough':
newpore_position = self._net['pore.coords'][self._NewPore]
dist_sqrd = (self._outlet_position-newpore_position)*(self._outlet_position-newpore_position)
if dist_sqrd[0].shape==(3,): # need to do this for MatFile networks because newpore_position is a nested array, not a vector (?)
dist_sqrd = dist_sqrd[0]
newpore_distance = np.sqrt(dist_sqrd[0]+dist_sqrd[1]+dist_sqrd[2])
logger.debug( 'newpore distance')
logger.debug( newpore_distance)
if newpore_distance < self._current_distance:
self._percent_complete = np.round((self._initial_distance-newpore_distance)/self._initial_distance*100, decimals = 1)
logger.info( 'percent complete')
logger.info( self._percent_complete)
self._current_distance = newpore_distance
elif self._end_condition == 'total':
self._percent_complete = np.round((np.sum(self['pore.cluster_final']>0)/self._net.num_pores())*100, decimals = 1)
if self._percent_complete > self._rough_complete + self._rough_increment:
self._rough_complete = np.floor(self._percent_complete/self._rough_increment)*self._rough_increment
print(' IP algorithm at',np.int(self._rough_complete),'% completion at',np.round(misc.toc(quiet=True)),'seconds')
# Determine if a new breakthrough position has occured
if self._NewPore in self._outlets:
logger.info( ' ')
logger.info( 'BREAKTHROUGH AT PORE: ')
logger.info(self._NewPore)
logger.info('in cluster ')
logger.info(self._current_cluster)
if self._timing:
logger.info('at time')
logger.info(self._sim_time)
pass
if self._end_condition == 'breakthrough':
self.cluster_remove(self._current_cluster)
elif self._end_condition == 'total':
self._brkevent.append(self._NewPore)
if np.sum(self._cluster_data['active']) == 0:
logger.info( ' ')
logger.info( 'SIMULATION FINISHED; no more active clusters')
if self._timing:
logger.info('at time')
logger.info(self._sim_time)
pass
self._condition = 0
print(' IP algorithm at 100% completion at ',np.round(misc.toc(quiet=True)),' seconds')
def _setup_for_IP(self):
r"""
Determines cluster labelling and condition for completion
"""
self._clock_start = misc.tic()
self._logger.debug( '+='*25)
self._logger.debug( 'INITIAL SETUP (STEP 1)')
# if empty, add Pc_entry to throat_properties
tdia = self._net['throat.'+self._throat_diameter_name]
# calculate Pc_entry from diameters
try:
self['throat.inv_Pc'] = self._phase['throat.'+self._capillary_pressure_name]
except:
self._logger.error('Capillary pressure not assigned to '+self._phase.name)
if self._timing:
# calculate Volume_coef for each throat
self._Tvol_coef = tdia*tdia*tdia*np.pi/12/self['throat.inv_Pc']
# Creating an array for invaded Pores(Np long, 0 for uninvaded, cluster number for inaveded)
self['pore.cluster_final'] = 0
self['pore.cluster_original'] = 0
# Creating an array for invaded throats(Nt long, 0 for uninvaded, cluster number for inaveded)
self['throat.cluster_final'] = 0
# Creating arrays for tracking invaded Pores(Np long, 0 for uninvaded, sequence for inaveded)
self['pore.inv_seq'] =0
if self._timing:
# Creating arrays for tracking invaded Pores(Np long, -1 for uninvaded, simulation time for inaveded)
self['pore.inv_time'] = -1.
# Creating arrays for tracking invaded throats(Nt long, 0 for uninvaded, sequence for inaveded)
self['throat.inv_seq'] = 0
if self._timing:
# Creating arrays for tracking invaded Pores(Np long, -1 for uninvaded, simulation time for inaveded)
self['throat.inv_time'] = -1.
# Iterator variables for sequences and cluster numbers
clusterNumber = 1
# Determine how many clusters there are
self._clusterCount = 0
for i in self._inlets:
self._clusterCount += 1
# Storage for cluster information
self._cluster_data = {}
if self._timing:
self._cluster_data['flow_rate'] = np.ones((self._clusterCount),dtype=float)*self._inlet_flow
self._cluster_data['haines_pressure'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['haines_time'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['vol_coef'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['cap_volume'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['pore_volume'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['throat_volume'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['haines_throat'] = np.zeros((self._clusterCount),dtype=int)
self._cluster_data['active'] = np.ones((self._clusterCount),dtype=int)
self._cluster_data['transform'] = np.zeros((self._clusterCount),dtype=int)
for i in range(self._clusterCount):
self._cluster_data['transform'][i] = i+1
# Creating an empty list to store the list of potential throats for invasion in each cluster.
# its length is equal to the maximum number of possible clusters.
self._tlists = [[] for i in self._inlets]
# Creating a list for each cluster to store both potential throat and corresponding throat value
self._tpoints = [[] for i in self._inlets]
# Initializing invasion percolation for each possible cluster
self._pore_volumes = self._net['pore.'+self._pore_volume_name]
self._throat_volumes = self._net['throat.'+self._throat_volume_name]
for pores in self._inlets:
if sp.shape(pores) == ():
pores = [pores]
# Label all invaded pores with their cluster
self['pore.cluster_original'][pores] = clusterNumber
# Label all inlet pores as invaded
self['pore.inv_seq'][pores] = self._tseq
if self._timing:
self['pore.inv_time'][pores] = self._sim_time
# Find all throats that border invaded pores
interface_throat_numbers = self._net.find_neighbor_throats(pores)
self.cluster_update(clusterNumber,pores,[],interface_throat_numbers)
clusterNumber += 1
if self._timing:
self._logger.debug( 'pore volumes')
self._logger.debug(self._cluster_data['pore_volume'])
self._logger.debug( 'cap volumes')
self._logger.debug( self._cluster_data['cap_volume'])
self._logger.debug( 'haines_throats')
self._logger.debug( self._cluster_data['haines_throat'])
self._tseq += 1
self._pseq += 1
self._current_cluster = 0
# Calculate the distance between the inlet and outlet pores
self._outlet_position = np.average(self._net.get_data(prop='coords',pores='all')[self._outlets],0)
if any([sp.shape(i) > () for i in self._inlets]):
inlets = []
for i in self._inlets:
inlets = sp.union1d(inlets,i)
inlets = sp.array(inlets,int)
else:
inlets = self._inlets
inlet_position = np.average(self._net.get_data(prop='coords',pores='all')[inlets],0)
dist_sqrd = (self._outlet_position-inlet_position)*(self._outlet_position-inlet_position)
self._initial_distance = np.sqrt(dist_sqrd[0]+dist_sqrd[1]+dist_sqrd[2])
self._logger.debug( 'initial distance')
self._logger.debug( self._initial_distance)
self._current_distance = self._initial_distance
self._percent_complete = np.round((self._initial_distance-self._current_distance)/self._initial_distance*100, decimals = 1)
self._logger.info( 'percent complete')
self._logger.info( self._percent_complete)
self._rough_complete = 0
print(' IP algorithm at',np.int(self._rough_complete),'% completion at',np.round(misc.toc(quiet=True)),'seconds')
self._logger.debug( '+='*25)
def _setup_for_IP(self):
r"""
Determines cluster labelling and condition for completion
"""
self._clock_start = misc.tic()
logger.debug( '+='*25)
logger.debug( 'INITIAL SETUP (STEP 1)')
# if empty, add Pc_entry to throat_properties
tdia = self._net['throat.'+self._throat_diameter_name]
# calculate Pc_entry from diameters
try:
self['throat.inv_Pc'] = self._phase['throat.'+self._capillary_pressure_name]
except:
logger.error('Capillary pressure not assigned to invading phase '+self._phase.name
+', check for capillary pressure in defending phase '+self._phase_def.name +' instead')
try:
self['throat.inv_Pc'] = self._phase_def['throat.'+self._capillary_pressure_name]
self._phase['throat.'+self._capillary_pressure_name] = self._phase_def['throat.'+self._capillary_pressure_name]
except:
logger.error('Capillary pressure neither assigned to defending phase '+self._phase_def.name
+' nor to invading phase '+self._phase.name)
pass
if self._timing:
# calculate Volume_coef for each throat
self._Tvol_coef = tdia*tdia*tdia*np.pi/12/self['throat.inv_Pc']
# Creating an array for invaded Pores(Np long, 0 for uninvaded, cluster number for inaveded)
self['pore.cluster_final'] = 0
self['pore.cluster_original'] = 0
# Creating an array for invaded throats(Nt long, 0 for uninvaded, cluster number for inaveded)
self['throat.cluster_final'] = 0
# Creating arrays for tracking invaded Pores(Np long, 0 for uninvaded, sequence for inaveded)
self['pore.inv_seq'] =0
# Creating arrays for tracking invaded Pores(Np long, 0 for uninvaded, pressure for inaveded)
self['pore.inv_pres'] =0
if self._timing:
# Creating arrays for tracking invaded Pores(Np long, -1 for uninvaded, simulation time for inaveded)
self['pore.inv_time'] = -1.
# Creating arrays for tracking invaded throats(Nt long, 0 for uninvaded, sequence for inaveded)
self['throat.inv_seq'] = 0
# Creating arrays for tracking invaded throats(Nt long, 0 for uninvaded, pressure for inaveded)
self['throat.inv_pres'] = 0
if self._timing:
# Creating arrays for tracking invaded Pores(Np long, -1 for uninvaded, simulation time for inaveded)
self['throat.inv_time'] = -1.
# Iterator variables for sequences and cluster numbers
clusterNumber = 1
# Determine how many clusters there are
self._clusterCount = 0
for i in self._inlets:
self._clusterCount += 1
# Storage for cluster information
self._cluster_data = {}
if self._timing:
self._cluster_data['flow_rate'] = np.ones((self._clusterCount),dtype=float)*self._inlet_flow
self._cluster_data['haines_pressure'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['haines_time'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['vol_coef'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['cap_volume'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['pore_volume'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['throat_volume'] = np.zeros((self._clusterCount),dtype=float)
self._cluster_data['haines_throat'] = np.zeros((self._clusterCount),dtype=int)
self._cluster_data['active'] = np.ones((self._clusterCount),dtype=int)
self._cluster_data['transform'] = np.zeros((self._clusterCount),dtype=int)
for i in range(self._clusterCount):
self._cluster_data['transform'][i] = i+1
# Creating an empty list to store the list of potential throats for invasion in each cluster.
# its length is equal to the maximum number of possible clusters.
self._tlists = [[] for i in self._inlets]
# Creating a list for each cluster to store both potential throat and corresponding throat value
self._tpoints = [[] for i in self._inlets]
# Initializing invasion percolation for each possible cluster
self._pore_volumes = self._net['pore.'+self._pore_volume_name]
self._throat_volumes = self._net['throat.'+self._throat_volume_name]
for pores in self._inlets:
if sp.shape(pores) == ():
pores = [pores]
# Label all invaded pores with their cluster
self['pore.cluster_original'][pores] = clusterNumber
# Label all inlet pores as invaded
self['pore.inv_seq'][pores] = self._tseq
self['pore.inv_pres'][pores] = 0
if self._timing:
self['pore.inv_time'][pores] = self._sim_time
# Find all throats that border invaded pores
interface_throat_numbers = self._net.find_neighbor_throats(pores)
self.cluster_update(clusterNumber,pores,[],interface_throat_numbers)
clusterNumber += 1
if self._timing:
logger.debug( 'pore volumes')
logger.debug(self._cluster_data['pore_volume'])
logger.debug( 'cap volumes')
logger.debug( self._cluster_data['cap_volume'])
pass
logger.debug( 'haines_throats')
logger.debug( self._cluster_data['haines_throat'])
self._tseq += 1
self._pseq += 1
self._current_cluster = 0
# Calculate the distance between the inlet and outlet pores
self._outlet_position = np.average(self._net['pore.coords'][self._outlets],0)
if any([sp.shape(i) > () for i in self._inlets]):
inlets = []
for i in self._inlets:
inlets = sp.union1d(inlets,i)
inlets = sp.array(inlets,int)
else:
inlets = self._inlets
inlet_position = np.average(self._net['pore.coords'][inlets],0)
dist_sqrd = (self._outlet_position-inlet_position)*(self._outlet_position-inlet_position)
self._initial_distance = np.sqrt(dist_sqrd[0]+dist_sqrd[1]+dist_sqrd[2])
logger.debug( 'initial distance')
logger.debug( self._initial_distance)
self._current_distance = self._initial_distance
self._percent_complete = np.round((self._initial_distance-self._current_distance)/self._initial_distance*100, decimals = 1)
logger.info( 'percent complete')
logger.info( self._percent_complete)
self._rough_complete = 0
print(' IP algorithm at',np.int(self._rough_complete),'% completion at',np.round(misc.toc(quiet=True)),'seconds')
logger.debug( '+='*25)