def _main():
parser = argparse.ArgumentParser(description='--- cascade annealing ---')
parser.add_argument('INPUT', help='the input json database')
args = parser.parse_args()
fp = open(args.INPUT, 'r')
jdata = json.load(fp)
seed = None
if j_have(jdata, 'seed'):
seed = jdata['seed']
seed = seed % (2**32)
np.random.seed(seed)
individual_cascade = False
if j_have(jdata, 'individual_cascade'):
individual_cascade = jdata['individual_cascade']
multi_cascade = False
if j_have(jdata, 'multi_cascade'): multi_cascade = jdata['multi_cascade']
if individual_cascade == False and multi_cascade == False:
raise RuntimeError(
'individual_cascade and multi_cascade are all set False, wrong ! Please set true for one of them !'
)
cascade = Cascade(jdata)
if individual_cascade: individual_cascade_annealing(jdata, cascade)
if multi_cascade: multi_cascade_annealing(jdata, cascade)
def individual_cascade_annealing(jdata, cascade):
trap = False
trapSys = None
if j_have(jdata, 'trap'): trap = jdata['trap']
if trap: trapSys = TrapSystem(jdata)
for i in range(cascade.return_cascade_numb()):
start_time = time.time()
'build a defectSys of Class DefectSystem for okmc simulation.'
defectSys = DefectSystem(jdata,
cascade.return_defectStr_list(jdata, i))
outputFile = OutputFile(defectSys, jdata, i)
'reset trap for all defectObject in model of Class DefectSystem.'
if trap: defectSys.reset_trap_defectSystem(jdata, trapSys)
defectSys.evolution(jdata, outputFile, trapSys)
end_time = time.time()
print('# cascade %d running time: %.3f s' % (i, end_time - start_time))
print('# ')
print('# All cascades annealing done !')
return None
def multi_cascade_annealing(jdata, cascade):
tmp_ConstNumber = ConstNumber(jdata)
box = j_must_have(jdata, 'box')
trap = False
trapSys = None
if j_have(jdata, 'trap'): trap = jdata['trap']
if trap: trapSys = TrapSystem(jdata)
total_cascade_numb = int(jdata['fluence'] * box[0] * box[1])
position_random = jdata['position_random']
cascade_numb = cascade.return_cascade_numb()
i_select = np.random.randint(0, cascade_numb)
'build a defectSys of Class DefectSystem for okmc simulation.'
defectSys = DefectSystem(jdata,
cascade.return_defectStr_list(jdata, i_select))
outputFile = OutputFile(defectSys, jdata)
print('# %d cascades in database, total %d cascades annealing' %
(cascade_numb, total_cascade_numb))
for i in range(total_cascade_numb):
start_time = time.time()
'reset trap for all defectObject in model of Class DefectSystem.'
if trap: defectSys.reset_trap_defectSystem(jdata, trapSys)
defectSys.evolution(jdata, outputFile, trapSys)
i_select = np.random.randint(0, cascade_numb)
add_defectStr_list = cascade.return_defectStr_list(jdata, i_select)
defectSys.add_defectObject(jdata, add_defectStr_list, position_random)
defectSys.set_initial_recombine_and_related_properties(
jdata, tmp_ConstNumber)
defectSys.set_zero_c_time()
end_time = time.time()
print('# cascade %d running time: %.3f s' % (i, end_time - start_time))
print('# ')
print('# All cascades annealing done !')
return None
def __init__(self, defectsys, jdata, index=None):
'property'
self.out_dir = os.path.join(j_must_have(jdata, 'out_dir'), 'output')
if index == None or index == 0:
if os.path.exists(self.out_dir): shutil.rmtree(self.out_dir)
os.mkdir(self.out_dir)
if index != None:
self.out_dir = os.path.join(self.out_dir, str(index))
if os.path.exists(self.out_dir): shutil.rmtree(self.out_dir)
os.mkdir(self.out_dir)
self.step = defectsys.c_step
self.time = defectsys.c_time
self.out_style_freq = j_must_have(jdata, 'out_style_freq')
self.out_cfg = False
if j_have(jdata, 'out_cfg_dir_name'):
'0. self.out_cfg, 1. self.cfg_path, 2. self.cfg_name, 3. self.target_cfg'
self.out_cfg = True
out_cfg_dir_name = jdata['out_cfg_dir_name']
self.cfg_path = os.path.join(self.out_dir, out_cfg_dir_name[0])
os.mkdir(self.cfg_path)
self.cfg_name = out_cfg_dir_name[1]
self.target_cfg = os.path.join(
self.cfg_path, self.cfg_name + '.' + str(self.step) + '.cfg')
self.out_defectStr = False
if j_have(jdata, 'out_defectStr_dir_name'):
'0. self.out_defectStr, 1. self.defectStr_path, 2. self.defectStr_name, 3. self.target_defectStr'
self.out_defectStr = True
out_defectStr_dir_name = jdata['out_defectStr_dir_name']
self.defectStr_path = os.path.join(self.out_dir,
out_defectStr_dir_name[0])
os.mkdir(self.defectStr_path)
self.defectStr_name = out_defectStr_dir_name[1]
self.target_defectStr = os.path.join(
self.defectStr_path,
self.defectStr_name + '.' + str(self.step))
self.out_volume_density = False
if j_have(jdata, 'out_volume_density_dir_name'):
'0. self.out_volume_density, 1. self.volume_density_path, 2. self.volume_density_name, 3. self.target_volume_density'
self.out_volume_density = True
out_volume_density_dir_name = jdata['out_volume_density_dir_name']
self.volume_density_path = os.path.join(
self.out_dir, out_volume_density_dir_name[0])
os.mkdir(self.volume_density_path)
self.volume_density_name = out_volume_density_dir_name[1]
self.target_volume_density = os.path.join(
self.volume_density_path,
self.volume_density_name + '.' + str(self.step))
self.out_area_density = False
if j_have(jdata, 'out_area_density_dir_name'):
'0. self.out_area_density, 1. self.area_density_path, 2. self.area_density_name, 3. self.target_area_density'
self.out_area_density = True
out_area_density_dir_name = jdata['out_area_density_dir_name']
self.area_density_path = os.path.join(self.out_dir,
out_area_density_dir_name[0])
os.mkdir(self.area_density_path)
self.area_density_name = out_area_density_dir_name[1]
self.target_area_density = os.path.join(
self.area_density_path,
self.area_density_name + '.' + str(self.step))
self.out_points = False
if j_have(jdata, 'out_point_defects_dir_name'):
'0. self.out_points, 1. self.points_path, 2. self.points_name, 3. self.target_points'
self.out_points = True
out_points_dir_name = jdata['out_point_defects_dir_name']
self.points_path = os.path.join(self.out_dir,
out_points_dir_name[0])
os.mkdir(self.points_path)
self.points_name = out_points_dir_name[1]
self.target_points = os.path.join(
self.points_path, self.points_name + '.' + str(self.step))
self.out_size_distri = False
if j_have(jdata, 'out_size_distri_dir_name'):
'0. self.out_size_distri, 1. self.size_distri_path, 2. self.size_distri_name, 3. self.target_size_distri.'
self.out_size_distri = True
out_size_distri_dir_name = jdata['out_size_distri_dir_name']
self.size_distri_path = os.path.join(self.out_dir,
out_size_distri_dir_name)
os.mkdir(self.size_distri_path)
self.out_size_distri_defecttype = jdata[
'out_size_distri_defecttype']
for item in self.out_size_distri_defecttype:
os.mkdir(os.path.join(self.size_distri_path, item))
'1. self.target_steptime.'
out_steptime_dir_name = j_must_have(jdata, 'out_steptime_dir_name')
steptime_path = os.path.join(self.out_dir, out_steptime_dir_name[0])
os.mkdir(steptime_path)
self.target_steptime = os.path.join(steptime_path,
out_steptime_dir_name[1])
self.file_out_steptime = open(self.target_steptime, 'w')
self.file_out_steptime.writelines([
'# step, c_time(s), total_defects_I, total_defects_V, numb_defectObject'
+ '\n'
])
self.file_out_steptime.close()
self.set_min_max_nsize_dict(defectsys, jdata)
self.set_sum_numb_nsize_dict(defectsys, jdata)
def load_cascade_from_file(self, jdata, serial_numb):
'''
1. self.cluster == True, cascade file format:
100.0 100.0 100.0 # b011, b022, b033, units: nm
I 1 10.0 10.0 10.0
V 1 10.0 10.0 10.0
...
reading defects and convert clusters
2. self.cluster == False, cascade file format:
100.0 100.0 100.0 # b011, b022, b033, units: nm
(1): ILoop100 13 10.0 10.0 10.0
(2): ILoop111 13 10.0 10.0 10.0 0.5 0.5 0.5
...
reading defects directly
'''
if serial_numb > self.cascade_numb:
raise RuntimeError('serial_numb %d not in range [ 0, %d ]' %
(serial_numb, self.cascade_numb))
file_in = open(self.cascade_file[serial_numb], 'r')
alatt = j_must_have(jdata, 'alatt')
burgers_vector_unit_array = np.array(
j_must_have(jdata, 'burgers_vector_unit'))
burgers_vector_scale_length_array = np.array(
j_must_have(jdata, 'burgers_vector_scale_length'))
'set d_probability = 1.0 / burgers_vector_scale_length_array.size + 0.037142857 formatly.'
d_probability = 0.037142857 + 1.0 / burgers_vector_scale_length_array.size
if j_have(jdata, 'probability'): d_probability = jdata['probability']
if self.cluster:
# test_cgzhang
print('defect cluster algorithm is done!')
I_position_list = []
V_position_list = []
s = file_in.readline()
defectStr = s.lstrip().rstrip()
defectStr_list = defectStr.split()
tmp_box = np.array(
[np.float64(item) for item in defectStr_list[0:3]])
while True:
s = file_in.readline()
if s == '':
break
defectStr = s.lstrip().rstrip()
defectStr_list = defectStr.split()
position = [np.float64(item) for item in defectStr_list[2:5]]
if defectStr_list[0] == 'I':
I_position_list.append(position)
else:
V_position_list.append(position)
I_position_array = np.array(I_position_list)
V_position_array = np.array(V_position_list)
clusterSys = ClusterSystem(alatt, self.ICluster_upper,
self.VLoop_lower, 'I',
self.IC_VC_rcut[0], I_position_array,
tmp_box, burgers_vector_unit_array,
burgers_vector_scale_length_array,
d_probability)
clusterSys.add_clusters(alatt, self.ICluster_upper,
self.VLoop_lower, 'V', self.IC_VC_rcut[1],
V_position_array, tmp_box)
self.defectStr_list = clusterSys.return_defectStr_list()
else:
self.defectStr_list = []
s = file_in.readline()
while True:
s = file_in.readline()
if s == '':
break
self.defectStr_list.append(s)
def __init__(self, jdata):
'''
Class Cascade properties:
1. self.defectStr_list
format:
(1): ILoop100 13 10.0 10.0 10.0
(2): ILoop111 13 10.0 10.0 10.0 0.5 0.5 0.5
mode :
1. cascade from formula
2. cascade from file
a. self.cluster == True, defects of I and V convert into clusters
b. self.cluster == False, defects of I and V does not convert into clusters
3. cascade I and V randomly and uniformly distributed in simulation box, for electron irradiation
'''
self.cascade_from_formula = False
if j_have(jdata, 'cascade_from_formula'):
self.cascade_from_formula = jdata['cascade_from_formula']
if self.cascade_from_formula:
self.cascade_numb = j_must_have(jdata, 'cascade_numb')
self.I_total = j_must_have(jdata, 'I_total')
self.SI = j_must_have(jdata, 'SI')
self.mu = j_must_have(jdata, 'mu')
self.sigma = j_must_have(jdata, 'sigma')
self.SV = j_must_have(jdata, 'SV')
self.ICluster_upper = j_must_have(jdata, 'ICluster_upper')
self.ratio_ILoop111_ILoop100 = j_must_have(
jdata, 'ratio_ILoop111_ILoop100')
self.VLoop_lower = j_must_have(jdata, 'VLoop_lower')
self.ratio_VCluster_VLoop100_VLoop111 = j_must_have(
jdata, 'ratio_VCluster_VLoop100_VLoop111')
self.cascade_from_file = False
if j_have(jdata, 'cascade_from_file'):
self.cascade_from_file = jdata['cascade_from_file']
if self.cascade_from_file:
sys_path = j_must_have(jdata, 'systems')
cascade_prefix = j_must_have(jdata, 'cascade_prefix')
if j_have(jdata, 'sys_defects_cfg'):
sys_defects_cfg = jdata['sys_defects_cfg']
defects_cfg_prefix = j_must_have(jdata, 'defects_cfg_prefix')
self.defects_cfg_file = glob.glob(
os.path.join(sys_defects_cfg, defects_cfg_prefix + '.*'))
self.defects_cfg_file.sort(key=return_serial_numb_in_str)
if os.path.exists(sys_path): shutil.rmtree(sys_path)
os.mkdir(sys_path)
self.cascade_cfg_2_points_defectStr(sys_path, cascade_prefix)
self.cascade_file = glob.glob(
os.path.join(sys_path, cascade_prefix + '.*'))
self.cascade_file.sort(key=return_serial_numb_in_str)
self.cascade_numb = len(self.cascade_file)
self.cluster = j_must_have(jdata, 'cluster')
if self.cluster:
self.IC_VC_rcut = j_must_have(jdata, 'IC_VC_rcut')
self.VLoop_lower = j_must_have(jdata, 'VLoop_lower')
self.ICluster_upper = j_must_have(jdata, 'ICluster_upper')
self.point_defects_uniform_distribution = False
if j_have(jdata, 'point_defects_uniform_distribution'):
self.point_defects_uniform_distribution = jdata[
'point_defects_uniform_distribution']
if self.point_defects_uniform_distribution:
self.cascade_numb = j_must_have(jdata, 'cascade_numb')
self.I_total = j_must_have(jdata, 'I_total')