Skip to content

Commit

Permalink
read config file in init
Browse files Browse the repository at this point in the history
  • Loading branch information
Jun Chen committed Oct 29, 2024
1 parent 2062cd2 commit d6637c1
Show file tree
Hide file tree
Showing 2 changed files with 131 additions and 57 deletions.
144 changes: 95 additions & 49 deletions micro_manager/adaptivity/adaptivity.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,8 +10,6 @@
import xml.etree.ElementTree as ET
from warnings import warn

import numpy as np


class AdaptivityCalculator:
def __init__(self, configurator, logger) -> None:
Expand All @@ -28,7 +26,7 @@ def __init__(self, configurator, logger) -> None:
self._refine_const = self._refine_const_input
self._coarse_const_input = configurator.get_adaptivity_coarsening_const()
self._coarse_const = self._coarse_const_input
self._adaptive_coarse_const = configurator.get_adaptivity_for_coarsening_const()
self._adaptive_coarse_const = configurator.get_adaptivity_for_coarsening_const()
self._adaptive_refine_const = configurator.get_adaptivity_for_refining_const()
self._hist_param = configurator.get_adaptivity_hist_param()
self._adaptivity_data_names = configurator.get_data_for_adaptivity()
Expand All @@ -44,6 +42,38 @@ def __init__(self, configurator, logger) -> None:
configurator.get_adaptivity_similarity_measure()
)

with open(self._config_file_name, 'r') as xml_file:
self.xml_data = xml_file.read()

unique_names = ["absolute-convergence-measure",
"relative-convergence-measure", "residual-relative-convergence-measure"]

# Initialize lists to store the found attributes
self.data_values = []
self.limit_values = []

for unique_name in unique_names:
pattern = f'<{unique_name} limit="([^"]+)" data="([^"]+)" mesh="([^"]+)"'
matches = re.finditer(pattern, self.xml_data)
for match in matches:
self.data_values.append(match.group(2))
self.limit_values.append(match.group(1))

# Check if any matches were found
if self.data_values and self.limit_values:
for i, (data_value, limit_value) in enumerate(zip(self.data_values, self.limit_values), start=1):
print(f"Match {i}:")
print(f"Data: {data_value}")
print(f"Limit: {limit_value}")
else:
print(f"No attributes found for unique name '{unique_name}'")

def get_data_values(self):
return self.data_values

def get_limit_values(self):
return self.limit_values

def _get_similarity_dists(
self, dt: float, similarity_dists: np.ndarray, data: dict
) -> np.ndarray:
Expand Down Expand Up @@ -85,37 +115,13 @@ def _get_adaptive_similarity_const(self, similarity_const: float) -> float:
Returns
-------
adaptive_similartity_const : float
adapted_similarity_const : float
"""
# Read the XML file as text
with open(self._config_file_name, 'r') as xml_file:
xml_data = xml_file.read()

unique_names = ["absolute-convergence-measure","relative-convergence-measure","residual-relative-convergence-measure"]

# Initialize lists to store the found attributes
data_values = []
limit_values = []

for unique_name in unique_names:
patteren = f'<{unique_name} limit="([^"]+)" data="([^"]+)" mesh="([^"]+)"'
matches = re.finditer(patteren, xml_data)
for match in matches:
data_values.append(match.group(2))
limit_values.append(match.group(1))

# Check if any matches were found
if data_values and limit_values:
for i, (data_value, limit_value) in enumerate(zip(data_values, limit_values), start=1):
print(f"Match {i}:")
print(f"Data: {data_value}")
print(f"Limit: {limit_value}")
else:
print(f"No attributes found for unique name '{unique_name}'")

# read convergence value from precice-Mysolver-convergence.log file
# Initialize lists to store the extracted values
convergence_values = []
convergence_values = [] # last iteration
convergence_values_LI = [] # last 2nd iteration
convergence_rate = 1.0

file_path = None
file_name_suffix = "-convergence.log"
Expand All @@ -126,34 +132,68 @@ def _get_adaptive_similarity_const(self, similarity_const: float) -> float:
if file_name.endswith(file_name_suffix):
file_path = os.path.join(root, file_name)
break

if file_path:
with open(file_path, "r") as file:
lines = file.readlines()
if len(lines) < 2:
print("File does not contain enough lines.")
adaptive_similartity_const = similarity_const
adaptive_similarity_const = similarity_const
else:
# Read the header line and last line of the file
header_line = lines[0].strip().split( ) # Assuming columns are tab-separated
last_line = lines[-1].strip().split( )
for data in data_values:
# Assuming columns are tab-separated
header_line = lines[0].strip().split()
last_line = lines[-1].strip().split()
for data in self.data_values:
for element in header_line:
if data in element:
index = header_line.index(element)
if last_line[index] == "inf":
convergence_values.append(1e+20)
else:
convergence_values.append(last_line[index])
adaptive_similartity_const = (1 + 1.0 / (np.log10(np.prod(np.array(limit_values,dtype=float)/np.array(convergence_values,dtype=float))) - 1))**3 * (1 - similarity_const) + similarity_const
index_config = self.data_values.index(data)
convergence_values.append(max(
float(last_line[index]),
float(self.limit_values[index_config])))
min_convergence = np.log10(np.prod(np.array(
self.limit_values, dtype=float)/np.array(convergence_values, dtype=float)))
if last_line[1] == "60":
min_convergence = max(0.0, min_convergence)

use_rate = False
alpha = 1
if use_rate:
if int(last_line[1]) >= 2:
last_sec_line = lines[-2].strip().split()
for data in self.data_values:
for element in header_line:
if data in element:
index = header_line.index(element)
if last_sec_line[index] == "inf":
convergence_values_LI.append(1e+20)
else:
index_config = self.data_values.index(
data)
convergence_values_LI.append(max(
float(last_sec_line[index]),
float(self.limit_values[index_config])))
min_convergence_LI = np.log10(np.prod(np.array(
self.limit_values, dtype=float)/np.array(convergence_values_LI, dtype=float)))
convergence_rate = min_convergence/min_convergence_LI
addtional = (1 + 1.0 / (min(0.0, min_convergence) - 1.0))**min(
(alpha/(convergence_rate), 10.0)) * (1 - similarity_const)
else:
addtional = (
1 + 1.0 / (min(0.0, min_convergence) - 1.0))**alpha * (1 - similarity_const)
adaptive_similarity_const = addtional + similarity_const
else:
print("File not found in the current directory (A) or its subdirectories.")
adaptive_similartity_const = similarity_const

self._logger.info("similarity_const: {} ".format(similarity_const))
self._logger.info("adaptive_similartity_const: {} ".format(adaptive_similartity_const))
print(
"Convergence log not found in the current directory (A) or its subdirectories.")

return adaptive_similartity_const
self._logger.info("adaptive_similarity_const: {} ".format(
adaptive_similarity_const))

return adaptive_similarity_const

def _update_active_sims(
self, similarity_dists: np.ndarray, is_sim_active: np.ndarray
Expand All @@ -175,9 +215,13 @@ def _update_active_sims(
Updated 1D array having state (active or inactive) of each micro simulation
"""
if self._adaptive_coarse_const:
self._coarse_const = self._get_adaptive_similarity_const(self._coarse_const_input)
self._coarse_const = self._get_adaptive_similarity_const(
self._coarse_const_input)
print(f"Adaptive coarse constant: {self._coarse_const}")
if self._adaptive_refine_const:
self._refine_const = self._get_adaptive_similarity_const(self._refine_const_input)
self._refine_const = self._get_adaptive_similarity_const(
self._refine_const_input)
print(f"Adaptive refine constant: {self._refine_const}")

max_similarity_dist = np.amax(similarity_dists)

Expand All @@ -194,7 +238,7 @@ def _update_active_sims(
_is_sim_active = np.copy(
is_sim_active
) # Input is_sim_active is not longer used after this point

# Update the set of active micro sims
for i in range(_is_sim_active.size):
if _is_sim_active[i]: # if sim is active
Expand Down Expand Up @@ -380,7 +424,8 @@ def _l1rel(self, data: np.ndarray) -> np.ndarray:
# divide by data to get relative difference
# divide i,j by max(data[i],data[j]) to get relative difference
relative = np.nan_to_num(
(pointwise_diff / np.maximum(data[np.newaxis, :], data[:, np.newaxis]))
(pointwise_diff /
np.maximum(data[np.newaxis, :], data[:, np.newaxis]))
)
return np.linalg.norm(relative, ord=1, axis=-1)

Expand All @@ -403,6 +448,7 @@ def _l2rel(self, data: np.ndarray) -> np.ndarray:
# divide by data to get relative difference
# divide i,j by max(data[i],data[j]) to get relative difference
relative = np.nan_to_num(
(pointwise_diff / np.maximum(data[np.newaxis, :], data[:, np.newaxis]))
(pointwise_diff /
np.maximum(data[np.newaxis, :], data[:, np.newaxis]))
)
return np.linalg.norm(relative, ord=2, axis=-1)
44 changes: 36 additions & 8 deletions micro_manager/config.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -182,16 +182,24 @@ def read_json(self, config_filename):
)
self._adaptivity_similarity_measure = "L1"

adaptivity_for_coarsening_constant = "False"
adaptivity_for_refining_constant = "False"
try:
self._adaptivity_for_coarsening_constant = data["simulation_params"]["adaptivity"]["adaptive_coarsening_constant"]
self._logger.info("The adaptivity for coarsening constant is {}.".format(self._adaptivity_for_coarsening_constant))
adaptivity_for_coarsening_constant = data["simulation_params"][
"adaptivity_settings"
]["adaptive_coarsening_constant"]
except:
self._logger.info("The adaptivity for coarsening constant is False as default.")
self._logger.info(
"The adaptivity for coarsening constant is False as default."
)
try:
self._adaptivity_for_refining_constant = data["simulation_params"]["adaptivity"]["adaptive_refining_constant"]
self._logger.info("The adaptivity for refining constant is {}.".format(self._adaptivity_for_refining_constant))
adaptivity_for_refining_constant = data["simulation_params"][
"adaptivity_settings"
]["adaptive_refining_constant"]
except:
self._logger.info("The adaptivity for refining constant is False as default.")
self._logger.info(
"The adaptivity for refining constant is False as default."
)

adaptivity_every_implicit_iteration = data["simulation_params"][
"adaptivity_settings"
Expand All @@ -202,6 +210,26 @@ def read_json(self, config_filename):
elif adaptivity_every_implicit_iteration == "False":
self._adaptivity_every_implicit_iteration = False

if adaptivity_for_coarsening_constant == "True":
self._adaptivity_for_coarsening_constant = True
elif adaptivity_for_coarsening_constant == "False":
self._adaptivity_for_coarsening_constant = False
self._logger.info(
"The adaptivity for coarsening constant is {}.".format(
self._adaptivity_for_coarsening_constant
)
)

if adaptivity_for_refining_constant == "True":
self._adaptivity_for_refining_constant = True
elif adaptivity_for_refining_constant == "False":
self._adaptivity_for_refining_constant = False
self._logger.info(
"The adaptivity for refining constant is {}.".format(
self._adaptivity_for_refining_constant
)
)

if not self._adaptivity_every_implicit_iteration:
self._logger.info(
"Micro Manager will compute adaptivity once at the start of every time window"
Expand Down Expand Up @@ -421,7 +449,7 @@ def get_adaptivity_refining_const(self):
Adaptivity refining constant
"""
return self._adaptivity_refining_constant

def get_adaptivity_for_coarsening_const(self):
"""
Get adaptivity for coarsening constant.
Expand All @@ -433,7 +461,7 @@ def get_adaptivity_for_coarsening_const(self):
Adaptivity for coarsening constant
"""
return self._adaptivity_for_coarsening_constant

def get_adaptivity_for_refining_const(self):
"""
Get adaptivity for refining constant.
Expand Down

0 comments on commit d6637c1

Please sign in to comment.