def Sim(data,VARS=VARS):
VARS=VARS
F =[]
beta=rgh.beta
total_wt=0
domain={}
for i in range(DOMAIN_NUMBER):
#do this part by fitting u and OC instead
#extract the fitting par values in the associated attribute and then do the scaling(initiation+processing, actually update the fitting parameter values)
#VARS['domain_class_'+str(int(i+1))].init_sim_batch(batch_path_head+VARS['sim_batch_file_domain'+str(int(i+1))])
#VARS['domain_class_'+str(int(i+1))].scale_opt_batch(batch_path_head+VARS['scale_operation_file_domain'+str(int(i+1))])
#create matching lib dynamically during fitting
if USE_BV:
vars()['match_lib_fitting_'+str(i+1)+'A'],vars()['match_lib_fitting_'+str(i+1)+'B']=deepcopy(VARS['match_lib_'+str(i+1)+'A']),deepcopy(VARS['match_lib_'+str(i+1)+'B'])
create_match_lib_during_fitting(domain_class=VARS['domain_class_'+str(int(i+1))],domain=VARS['domain'+str(int(i+1))+'A'],atm_list=VARS['atm_list_'+str(int(i+1))+'A'],pb_list=VARS['pb_list_domain'+str(int(i+1))+'a'],HO_list=VARS['HO_list_domain'+str(int(i+1))+'a'],match_lib=vars()['match_lib_fitting_'+str(int(i+1))+'A'])
#grap wt for each domain and cal the total wt
vars()['wt_domain'+str(int(i+1))]=VARS['rgh_domain'+str(int(i+1))].wt
total_wt=total_wt+vars()['wt_domain'+str(int(i+1))]
#update sorbates
for j in range(VARS['Pb_NUMBER'][i]):
pb_coors_a=[]
O_coors_a=[]
if len(VARS['Pb_ATTACH_ATOM'][i][j])==1:#monodentate case
phi=getattr(VARS['rgh_domain'+str(int(i+1))],'phi')
r=getattr(VARS['rgh_domain'+str(int(i+1))],'r')
ids=[VARS['Pb_ATTACH_ATOM'][i][j][0]+'_D'+str(int(i+1))+'A']
offset=VARS['Pb_ATTACH_ATOM_OFFSET'][i][j][0]
pb_id=VARS['pb_list_domain'+str(int(i+1))+'a'][j]#pb_id is a str NOT list
O_index=[0]+[sum(VARS['O_NUMBER'][i][0:ii+1]) for ii in range(len(VARS['O_NUMBER'][i]))]
#for [1,2,2], which means inside one domain there are 1OH corresponding to pb1, 2 OH's corresponding to pb2 and so son.
#will return [0,1,3,5], O_id extract OH according to O_index
O_id=VARS['HO_list_domain'+str(int(i+1))+'a'][O_index[j]:O_index[j+1]]#O_ide is a list of str
sorbate_coors=VARS['domain_class_'+str(int(i+1))].adding_sorbate_bipyramid_monodentate(domain=VARS['domain'+str(int(i+1))+'A'],phi=phi,r=r,attach_atm_id=ids,offset=offset,pb_id=pb_id,O_id=O_id)
pb_coors_a.append(sorbate_coors[0])
[O_coors_a.append(sorbate_coors[k]) for k in range(len(sorbate_coors))[1:]]
pb_id_B=VARS['pb_list_domain'+str(int(i+1))+'b'][j]
O_id_B=VARS['HO_list_domain'+str(int(i+1))+'b'][O_index[j]:O_index[j+1]]
#now put on sorbate on the symmetrically related domain
sorbate_ids=[pb_id_B]+O_id_B
sorbate_els=['Pb']+['O']*(len(O_id_B))
add_atom(domain=VARS['domain'+str(int(i+1))+'B'],ref_coor=np.array(pb_coors_a+O_coors_a)*[-1,1,1]-[-1.,0.06955,0.5],ids=sorbate_ids,els=sorbate_els)
elif len(VARS['Pb_ATTACH_ATOM'][i][j])==2:#bidentate case
theta=getattr(VARS['rgh_domain'+str(int(i+1))],'theta')
phi=getattr(VARS['rgh_domain'+str(int(i+1))],'phi')
ids=[VARS['Pb_ATTACH_ATOM'][i][j][0]+'_D'+str(int(i+1))+'A',VARS['Pb_ATTACH_ATOM'][i][j][1]+'_D'+str(int(i+1))+'A']
offset=VARS['Pb_ATTACH_ATOM_OFFSET'][i][j]
pb_id=VARS['pb_list_domain'+str(int(i+1))+'a'][j]
O_index=[0]+[sum(VARS['O_NUMBER'][i][0:ii+1]) for ii in range(len(VARS['O_NUMBER'][i]))]
O_id=VARS['HO_list_domain'+str(int(i+1))+'a'][O_index[j]:O_index[j+1]]
sorbate_coors=VARS['domain_class_'+str(int(i+1))].adding_sorbate_trigonal_bipyramid(domain=VARS['domain'+str(int(i+1))+'A'],theta=theta,phi=phi,flag=VARS['FLAG'][i][j],extend_flag=VARS['ED_FLAG'][i][j],attach_atm_ids=ids,offset=offset,pb_id=pb_id,O_id=O_id,mirror=VARS['MIRROR'])
pb_coors_a.append(sorbate_coors[0])
[O_coors_a.append(sorbate_coors[k]) for k in range(len(sorbate_coors))[1:]]
pb_id_B=VARS['pb_list_domain'+str(int(i+1))+'b'][j]
O_id_B=VARS['HO_list_domain'+str(int(i+1))+'b'][O_index[j]:O_index[j+1]]
#now put on sorbate on the symmetrically related domain
sorbate_ids=[pb_id_B]+O_id_B
sorbate_els=['Pb']+['O']*(len(O_id_B))
add_atom(domain=VARS['domain'+str(int(i+1))+'B'],ref_coor=np.array(pb_coors_a+O_coors_a)*[-1,1,1]-[-1.,0.06955,0.5],ids=sorbate_ids,els=sorbate_els)
elif len(VARS['Pb_ATTACH_ATOM'][i][j])==3:#tridentate case (no oxygen sorbate here considering it is a trigonal pyramid structure)
ids=[VARS['Pb_ATTACH_ATOM'][i][j][0]+'_D'+str(int(i+1))+'A',VARS['Pb_ATTACH_ATOM'][i][j][1]+'_D'+str(int(i+1))+'A',VARS['Pb_ATTACH_ATOM'][i][j][2]+'_D'+str(int(i+1))+'A']
offset=VARS['Pb_ATTACH_ATOM_OFFSET'][i][j]
pb_id=VARS['pb_list_domain'+str(int(i+1))+'a'][j]
O_index=[0]+[sum(VARS['O_NUMBER'][i][0:ii+1]) for ii in range(len(VARS['O_NUMBER'][i]))]
O_id=VARS['HO_list_domain'+str(int(i+1))+'a'][O_index[j]:O_index[j+1]]
sorbate_coors=VARS['domain_class_'+str(int(i+1))].adding_share_triple_trigonal_bipyramid(domain=VARS['domain'+str(int(i+1))+'A'],attach_atm_ids_ref=ids[0:2],attach_atm_id_third=[ids[-1]],offset=offset,sorbate_id=pb_id,sorbate_oxygen_ids=O_id)
pb_coors_a.append(sorbate_coors[0])
[O_coors_a.append(sorbate_coors[k]) for k in range(len(sorbate_coors))[1:]]
pb_id_B=VARS['pb_list_domain'+str(int(i+1))+'b'][j]
O_id_B=VARS['HO_list_domain'+str(int(i+1))+'b'][O_index[j]:O_index[j+1]]
#now put on sorbate on the symmetrically related domain
sorbate_ids=[pb_id_B]+O_id_B
sorbate_els=['Pb']+['O']*(len(O_id_B))
add_atom(domain=VARS['domain'+str(int(i+1))+'B'],ref_coor=np.array(pb_coors_a+O_coors_a)*[-1,1,1]-[-1.,0.06955,0.5],ids=sorbate_ids,els=sorbate_els)
#set up multiple domains
#note for each domain there are two sub domains which symmetrically related to each other, so have equivalent wt
for i in range(DOMAIN_NUMBER):
domain['domain'+str(int(i+1))+'A']={'slab':VARS['domain'+str(int(i+1))+'A'],'wt':0.5*vars()['wt_domain'+str(int(i+1))]/total_wt}
domain['domain'+str(int(i+1))+'B']={'slab':VARS['domain'+str(int(i+1))+'B'],'wt':0.5*vars()['wt_domain'+str(int(i+1))]/total_wt}
#set up sample
sample = model.Sample(inst, bulk, domain, unitcell,coherence=False,surface_parms={'delta1':0.,'delta2':0.1391})
#bond valence won't be integrated as part of data sets, but you can print out to check the bv as one of the post-fitting work
if USE_BV:
bond_valence=[domain_class_1.cal_bond_valence3(domain=VARS['domain'+str(i+1)+'A'],match_lib=vars()['match_lib_fitting_'+str(i+1)+'A']) for i in range(DOMAIN_NUMBER)]
for bv in bond_valence:
for key in bv.keys():
print "%s\t%5.3f\n"%(key,bv[key])
#cal structure factor for each dataset in this for loop
for data_set in data:
h = data_set.extra_data['h']
k = data_set.extra_data['k']
l = data_set.extra_data['l']
LB = data_set.extra_data['LB']
dL = data_set.extra_data['dL']
rough = (1-beta)/((1-beta)**2 + 4*beta*np.sin(np.pi*(l-LB)/dL)**2)**0.5#roughness model, double check LB and dL values are correctly set up in data file
f = rough*sample.calc_f(h, k, l,f1f2,res_el)
F.append(abs(f))
#print_data(N_sorbate=4,N_atm=40,domain=domain1A,z_shift=1,save_file='D://model.xyz')
#export the model results for plotting if PLOT set to true
if PLOT:
plot_data_container_experiment={}
plot_data_container_model={}
for data_set in data:
f=np.array([])
h = data_set.extra_data['h']
k = data_set.extra_data['k']
l = data_set.x
LB = data_set.extra_data['LB']
dL = data_set.extra_data['dL']
I=data_set.y
eI=data_set.error
#make dumy hkl and f to make the plot look smoother
l_dumy=np.arange(l[0],l[-1],0.1)
N=len(l_dumy)
h_dumy=np.array([h[0]]*N)
k_dumy=np.array([k[0]]*N)
LB_dumy=[]
dL_dumy=[]
for i in range(N):
index=list(l-l_dumy[i]).index(min(l-l_dumy[i]))
LB_dumy.append(LB[index])
dL_dumy.append(dL[index])
LB_dumy=np.array(LB_dumy)
dL_dumy=np.array(dL_dumy)
rough_dumy = (1-beta)/((1-beta)**2 + 4*beta*np.sin(np.pi*(l_dumy-LB_dumy)/dL_dumy)**2)**0.5
f_dumy = rough_dumy*sample.calc_f(h_dumy, k_dumy, l_dumy)
label=str(int(h[0]))+str(int(k[0]))+'L'
plot_data_container_experiment[label]=np.concatenate((l[:,np.newaxis],I[:,np.newaxis],eI[:,np.newaxis]),axis=1)
plot_data_container_model[label]=np.concatenate((l_dumy[:,np.newaxis],f_dumy[:,np.newaxis]),axis=1)
hkls=['00L','02L','10L','11L','20L','22L','30L','2-1L','21L']
plot_data_list=[]
for hkl in hkls:
plot_data_list.append([plot_data_container_experiment[hkl],plot_data_container_model[hkl]])
pickle.dump(plot_data_list,open("D:\\Google Drive\\useful codes\\plotting\\temp_plot","wb"))
return F
def Sim(data,VARS=VARS):
VARS=VARS
F =[]
bv=0
beta=rgh.beta
SCALES=[getattr(rgh,scale) for scale in scales]
total_wt=0
domain={}
for i in range(DOMAIN_NUMBER):
#extract the fitting par values in the associated attribute and then do the scaling(initiation+processing, actually update the fitting parameter values)
#VARS['domain_class_'+str(int(i+1))].init_sim_batch(batch_path_head+VARS['sim_batch_file_domain'+str(int(i+1))])
#VARS['domain_class_'+str(int(i+1))].scale_opt_batch(batch_path_head+VARS['scale_operation_file_domain'+str(int(i+1))])
#grap wt for each domain and cal the total wt
vars()['wt_domain'+str(int(i+1))]=VARS['rgh_domain'+str(int(i+1))].wt
total_wt=total_wt+vars()['wt_domain'+str(int(i+1))]
#update sorbates
for j in range(VARS['Pb_NUMBER'][i]):
pb_coors_a=[]
O_coors_a=[]
if len(VARS['Pb_ATTACH_ATOM'][i][j])==1:#monodentate case
top_angle=getattr(VARS['rgh_domain'+str(int(i+1))],'top_angle')
phi=getattr(VARS['rgh_domain'+str(int(i+1))],'phi')
r=getattr(VARS['rgh_domain'+str(int(i+1))],'r')
ids=[VARS['Pb_ATTACH_ATOM'][i][j][0]+'_D'+str(int(i+1))+'A']
offset=VARS['Pb_ATTACH_ATOM_OFFSET'][i][j]
pb_id=VARS['pb_list_domain'+str(int(i+1))+'a'][j]#pb_id is a str NOT list
O_index=[0]+[sum(VARS['O_NUMBER'][i][0:ii+1]) for ii in range(len(VARS['O_NUMBER'][i]))]
#for [1,2,2], which means inside one domain there are 1OH corresponding to pb1, 2 OH's corresponding to pb2 and so son.
#will return [0,1,3,5], O_id extract OH according to O_index
O_id=VARS['HO_list_domain'+str(int(i+1))+'a'][O_index[j]:O_index[j+1]]#O_ide is a list of str
sorbate_coors=VARS['domain_class_'+str(int(i+1))].adding_sorbate_pyramid_monodentate(domain=VARS['domain'+str(int(i+1))+'A'],top_angle=top_angle,phi=phi,r=r,attach_atm_ids=ids,offset=offset,pb_id=pb_id,O_id=O_id,mirror=VARS['MIRROR'])
pb_coors_a.append(sorbate_coors[0])
[O_coors_a.append(sorbate_coors[k]) for k in range(len(sorbate_coors))[1:]]
pb_id_B=VARS['pb_list_domain'+str(int(i+1))+'b'][j]
O_id_B=VARS['HO_list_domain'+str(int(i+1))+'b'][O_index[j]:O_index[j+1]]
#now put on sorbate on the symmetrically related domain
sorbate_ids=[pb_id_B]+O_id_B
sorbate_els=['Pb']+['O']*(len(O_id_B))
add_atom(domain=VARS['domain'+str(int(i+1))+'B'],ref_coor=np.array(pb_coors_a+O_coors_a)*[-1,1,1]-[-1.,0.06955,0.5],ids=sorbate_ids,els=sorbate_els)
elif len(VARS['Pb_ATTACH_ATOM'][i][j])==2:#bidentate case
top_angle=getattr(VARS['rgh_domain'+str(int(i+1))],'top_angle')
phi=getattr(VARS['rgh_domain'+str(int(i+1))],'phi')
ids=[VARS['Pb_ATTACH_ATOM'][i][j][0]+'_D'+str(int(i+1))+'A',VARS['Pb_ATTACH_ATOM'][i][j][1]+'_D'+str(int(i+1))+'A']
offset=VARS['Pb_ATTACH_ATOM_OFFSET'][i][j]
pb_id=VARS['pb_list_domain'+str(int(i+1))+'a'][j]
O_index=[0]+[sum(VARS['O_NUMBER'][i][0:ii+1]) for ii in range(len(VARS['O_NUMBER'][i]))]
O_id=VARS['HO_list_domain'+str(int(i+1))+'a'][O_index[j]:O_index[j+1]]
sorbate_coors=VARS['domain_class_'+str(int(i+1))].adding_sorbate_pyramid_distortion(domain=VARS['domain'+str(int(i+1))+'A'],top_angle=top_angle,phi=phi,edge_offset=[0,0],attach_atm_ids=ids,offset=offset,pb_id=pb_id,O_id=O_id,mirror=VARS['MIRROR'])
pb_coors_a.append(sorbate_coors[0])
[O_coors_a.append(sorbate_coors[k]) for k in range(len(sorbate_coors))[1:]]
pb_id_B=VARS['pb_list_domain'+str(int(i+1))+'b'][j]
O_id_B=VARS['HO_list_domain'+str(int(i+1))+'b'][O_index[j]:O_index[j+1]]
#now put on sorbate on the symmetrically related domain
sorbate_ids=[pb_id_B]+O_id_B
sorbate_els=['Pb']+['O']*(len(O_id_B))
add_atom(domain=VARS['domain'+str(int(i+1))+'B'],ref_coor=np.array(pb_coors_a+O_coors_a)*[-1,1,1]-[-1.,0.06955,0.5],ids=sorbate_ids,els=sorbate_els)
elif len(VARS['Pb_ATTACH_ATOM'][i][j])==3:#tridentate case (no oxygen sorbate here considering it is a trigonal pyramid structure)
r=getattr(VARS['rgh_domain'+str(int(i+1))],'r')
ids=[VARS['Pb_ATTACH_ATOM'][i][j][0]+'_D'+str(int(i+1))+'A',VARS['Pb_ATTACH_ATOM'][i][j][1]+'_D'+str(int(i+1))+'A',VARS['Pb_ATTACH_ATOM'][i][j][2]+'_D'+str(int(i+1))+'A']
offset=VARS['Pb_ATTACH_ATOM_OFFSET'][i][j]
pb_id=VARS['pb_list_domain'+str(int(i+1))+'a'][j]
sorbate_coors=VARS['domain_class_'+str(int(i+1))].adding_pb_share_triple3(domain=VARS['domain'+str(int(i+1))+'A'],r=r,attach_atm_ids=ids,offset=offset,pb_id=pb_id)
pb_coors_a.append(sorbate_coors)
pb_id_B=VARS['pb_list_domain'+str(int(i+1))+'b'][j]
#now put on sorbate on the symmetrically related domain
sorbate_ids=[pb_id_B]
sorbate_els=['Pb']
add_atom(domain=VARS['domain'+str(int(i+1))+'B'],ref_coor=np.array(pb_coors_a)*[-1,1,1]-[-1.,0.06955,0.5],ids=sorbate_ids,els=sorbate_els)
#create matching lib dynamically during fitting
if USE_BV:
N_sorbate=Pb_NUMBER[i]+sum(O_NUMBER[i])
N_water=WATER_NUMBER[i]
domain_class=None
#consider 6 surface atom layers plus the sorbates (not including water if any) to build super cell and remove the first iron layer if considring half layer
#only consdier domainA since domain B is symmetry related to domainA
if DOMAIN[i]==1:
domain_class=VARS['domain_class_'+str(i+1)].build_super_cell2(VARS['domain'+str(i+1)+'A'],[0,1]+range(4,14)+range(-(N_sorbate+N_water),-N_water))
elif DOMAIN[i]==2:
domain_class=VARS['domain_class_'+str(i+1)].build_super_cell2(VARS['domain'+str(i+1)+'A'],range(0,12)+range(-(N_sorbate+N_water),-N_water))
for key in VARS['match_lib_'+str(i+1)+'A'].keys():
#the searching radius is 2.5A considering the bond length of Pb-O or Fe-O is less than 2.5 A
#if the radius is set too high you may force a nonreasonable panalty to scale the bv
temp_bv=domain_class_1.cal_bond_valence1_new2(domain_class,key,2.5,VARS['match_lib_'+str(i+1)+'A'][key],50,False)['total_valence']
if 'O' in key:
#For O you may consider possible binding to proton (+0.8) or hydrogen bond (0.2) and any possible combos among them
#And note the maximum coordination number for O is 4
case_tag=len(VARS['match_lib_'+str(i+1)+'A'][key])
bond_valence_corrected_value=np.array([0.])
if ((case_tag==1.)&(temp_bv<2)):
bond_valence_corrected_value=np.array([1.8,1.6,1.2,1.,0.8,0.6,0.4,0.2,0.])
elif ((case_tag==2.)&(temp_bv<2)):
bond_valence_corrected_value=np.array([1.6,1.,0.8,0.4,0.2,0.])
elif ((case_tag==3.)&(temp_bv<2)):
bond_valence_corrected_value=np.array([0.8,0.2,0.])
else:pass
ref=np.sign(temp_bv+np.array(bond_valence_corrected_value)-2.)*(temp_bv+np.array(bond_valence_corrected_value)-2.)
temp_bv=temp_bv+bond_valence_corrected_value[np.where(ref==np.min(ref))[0][0]]
bv=bv+abs(2-temp_bv)
elif 'Fe' in key:
bv=bv+abs(3-temp_bv)
elif 'Pb' in key:
bv=bv+abs(2-temp_bv)
#set up multiple domains
#note for each domain there are two sub domains which symmetrically related to each other, so have equivalent wt
for i in range(DOMAIN_NUMBER):
domain['domain'+str(int(i+1))+'A']={'slab':VARS['domain'+str(int(i+1))+'A'],'wt':0.5*vars()['wt_domain'+str(int(i+1))]/total_wt}
domain['domain'+str(int(i+1))+'B']={'slab':VARS['domain'+str(int(i+1))+'B'],'wt':0.5*vars()['wt_domain'+str(int(i+1))]/total_wt}
#set up sample
#bond valence won't be integrated as part of data sets, but you can print out to check the bv as one of the post-fitting work
PRINT_BV=False
if USE_BV&PRINT_BV:
bond_valence=[domain_class_1.cal_bond_valence3(domain=VARS['domain'+str(i+1)+'A'],match_lib=vars()['match_lib_fitting_'+str(i+1)+'A']) for i in range(DOMAIN_NUMBER)]
for bv in bond_valence:
for key in bv.keys():
print "%s\t%5.3f\n"%(key,bv[key])
#cal structure factor for each dataset in this for loop
for data_set in data:
f=np.array([])
h = data_set.extra_data['h']
k = data_set.extra_data['k']
x = data_set.x
y = data_set.extra_data['Y']
LB = data_set.extra_data['LB']
dL = data_set.extra_data['dL']
if x[0]>100:#a sign for RAXS dataset(first column is Energy which is in the order of 1000 ev)
sample = model2.Sample(inst, bulk, domain, unitcell,coherence=False,surface_parms={'delta1':0.,'delta2':0.1391})
rough = (1-beta)/((1-beta)**2 + 4*beta*np.sin(np.pi*(y-LB)/dL)**2)**0.5#roughness model, double check LB and dL values are correctly set up in data file
f = SCALES[1]*rough*sample.calc_f(h, k, y,f1f2,res_el)
F.append(abs(f))
else:#First column is l for CTR dataset, l is a relative small number (less than 10 usually)
sample = model.Sample(inst, bulk, domain, unitcell,coherence=False,surface_parms={'delta1':0.,'delta2':0.1391})
rough = (1-beta)/((1-beta)**2 + 4*beta*np.sin(np.pi*(x-LB)/dL)**2)**0.5#roughness model, double check LB and dL values are correctly set up in data file
f = SCALES[0]*rough*sample.calc_f(h, k, x)
F.append(abs(f))
#print_data(N_sorbate=6,N_atm=40,domain=domain1A,z_shift=1,half_layer=True,save_file='D://model2.xyz')
#export the model results for plotting if PLOT set to true
#print domain_class_1.cal_bond_valence1(domain_class_1.build_super_cell2(domain1A,[0,1,4,5]+range(-6,0)),'Pb1_D1A',3,False)
#print domain_class_1.cal_bond_valence1(domain_class_1.build_super_cell(domain1A),'O1_5_0_D1A',2.3,False)
#print domain_class_1.cal_bond_valence1(domain_class_1.build_super_cell2(domain1A,[0,1,4,5]+range(-6,0)),'Pb1_D1A',3,False)
#print domain_class_1.cal_bond_valence1_new2(domain_class_1.build_super_cell2(domain1A,[0,1,4,5]+range(-6,0)),'Pb1_D1A',3,['HO1_D1','O1_1_0','O1_2_0'],10,False)
if PLOT:
plot_data_container_experiment={}
plot_data_container_model={}
for data_set in data:
f=np.array([])
h = data_set.extra_data['h']
k = data_set.extra_data['k']
l = data_set.x
LB = data_set.extra_data['LB']
dL = data_set.extra_data['dL']
I=data_set.y
eI=data_set.error
#make dumy hkl and f to make the plot look smoother
l_dumy=np.arange(l[0],l[-1],0.1)
N=len(l_dumy)
h_dumy=np.array([h[0]]*N)
k_dumy=np.array([k[0]]*N)
LB_dumy=[]
dL_dumy=[]
for i in range(N):
index=list(l-l_dumy[i]).index(min(l-l_dumy[i]))
LB_dumy.append(LB[index])
dL_dumy.append(dL[index])
LB_dumy=np.array(LB_dumy)
dL_dumy=np.array(dL_dumy)
rough_dumy = (1-beta)/((1-beta)**2 + 4*beta*np.sin(np.pi*(l_dumy-LB_dumy)/dL_dumy)**2)**0.5
f_dumy = rough_dumy*sample.calc_f(h_dumy, k_dumy, l_dumy)
label=str(int(h[0]))+str(int(k[0]))+'L'
plot_data_container_experiment[label]=np.concatenate((l[:,np.newaxis],I[:,np.newaxis],eI[:,np.newaxis]),axis=1)
plot_data_container_model[label]=np.concatenate((l_dumy[:,np.newaxis],f_dumy[:,np.newaxis]),axis=1)
hkls=['00L','02L','10L','11L','20L','22L','30L','2-1L','21L']
plot_data_list=[]
for hkl in hkls:
plot_data_list.append([plot_data_container_experiment[hkl],plot_data_container_model[hkl]])
pickle.dump(plot_data_list,open("D:\\Google Drive\\useful codes\\plotting\\temp_plot","wb"))
#you may play with the weighting rule by setting eg 2**bv, 5**bv for the wt factor, that way you are pushing the GenX to find a fit btween
#good fit (low wt factor) and a reasonable fit (high wt factor)
return F,10**bv
ids=Pb_ATTACH_ATOM[i][j][0]+'_D'+str(int(i+1))+'A'
offset=Pb_ATTACH_ATOM_OFFSET[i][j][0]
pb_id=vars()['pb_list_domain'+str(int(i+1))+'a'][j]#pb_id is a str NOT list
O_index=[0]+[sum(O_NUMBER[i][0:ii+1]) for ii in range(len(O_NUMBER[i]))]
#for [1,2,2], which means inside one domain there are 1OH corresponding to pb1, 2 OH's corresponding to pb2 and so son.
#will return [0,1,3,5], O_id extract OH according to O_index
O_id=vars()['HO_list_domain'+str(int(i+1))+'a'][O_index[j]:O_index[j+1]]#O_ide is a list of str
sorbate_coors=vars()['domain_class_'+str(int(i+1))].adding_sorbate_bipyramid_monodentate(domain=vars()['domain'+str(int(i+1))+'A'],phi=PHI[i][j],r=R_S[i][j],attach_atm_id=ids,offset=offset,pb_id=pb_id,O_id=O_id)
pb_coors_a.append(sorbate_coors[0])
[O_coors_a.append(sorbate_coors[k]) for k in range(len(sorbate_coors))[1:]]
pb_id_B=vars()['pb_list_domain'+str(int(i+1))+'b'][j]
O_id_B=vars()['HO_list_domain'+str(int(i+1))+'b'][O_index[j]:O_index[j+1]]
#now put on sorbate on the symmetrically related domain
sorbate_ids=[pb_id_B]+O_id_B
sorbate_els=['Pb']+['O']*(len(O_id_B))
add_atom(domain=vars()['domain'+str(int(i+1))+'B'],ref_coor=np.array(pb_coors_a+O_coors_a)*[-1,1,1]-[-1.,0.06955,0.5],ids=sorbate_ids,els=sorbate_els)
#grouping sorbates (each set of Pb and HO, set the occupancy equivalent during fitting, looks like gp_sorbates_set1_D1)
#also group the oxygen sorbate to set equivalent u during fitting (looks like gp_HO_set1_D1)
sorbate_set_ids=[pb_id]+O_id+[pb_id_B]+O_id_B
HO_set_ids=O_id+O_id_B
N=len(sorbate_set_ids)/2
M=len(O_id)
vars()['gp_sorbates_set'+str(j+1)+'_D'+str(int(i+1))]=vars()['domain_class_'+str(int(i+1))].grouping_discrete_layer(domain=[vars()['domain'+str(int(i+1))+'A']]*N+[vars()['domain'+str(int(i+1))+'B']]*N,atom_ids=sorbate_set_ids)
vars()['gp_HO_set'+str(j+1)+'_D'+str(int(i+1))]=vars()['domain_class_'+str(int(i+1))].grouping_discrete_layer(domain=[vars()['domain'+str(int(i+1))+'A']]*M+[vars()['domain'+str(int(i+1))+'B']]*M,atom_ids=HO_set_ids)
elif len(Pb_ATTACH_ATOM[i][j])==2:#bidentate case
ids=[Pb_ATTACH_ATOM[i][j][0]+'_D'+str(int(i+1))+'A',Pb_ATTACH_ATOM[i][j][1]+'_D'+str(int(i+1))+'A']
offset=Pb_ATTACH_ATOM_OFFSET[i][j]
pb_id=vars()['pb_list_domain'+str(int(i+1))+'a'][j]
O_index=[0]+[sum(O_NUMBER[i][0:ii+1]) for ii in range(len(O_NUMBER[i]))]
O_id=vars()['HO_list_domain'+str(int(i+1))+'a'][O_index[j]:O_index[j+1]]
sorbate_coors=vars()['domain_class_'+str(int(i+1))].adding_sorbate_trigonal_bipyramid(domain=vars()['domain'+str(int(i+1))+'A'],theta=THETA[i][j],phi=PHI[i][j],flag=FLAG[i][j],extend_flag=ED_FLAG[i][j],attach_atm_ids=ids,offset=offset,pb_id=pb_id,O_id=O_id,mirror=MIRROR)
M=len(sorbate_id_a[1:])
vars()['gp_sorbates_set'+str(j+1)+'_D'+str(int(i+1))]=vars()['domain_class_'+str(int(i+1))].grouping_discrete_layer(domain=[vars()['domain'+str(int(i+1))+'A']]*N+[vars()['domain'+str(int(i+1))+'B']]*N,atom_ids=sorbate_set_ids)
vars()['gp_HO_set'+str(j+1)+'_D'+str(int(i+1))]=vars()['domain_class_'+str(int(i+1))].grouping_discrete_layer(domain=[vars()['domain'+str(int(i+1))+'A']]*M+[vars()['domain'+str(int(i+1))+'B']]*M,atom_ids=HO_set_ids)
if WATER_NUMBER[i]!=0:#add water molecules if any
for jj in range(WATER_NUMBER[i]/2):#note will add water pair (two oxygens) each time, and you can't add single water
O_ids_a=vars()['Os_list_domain'+str(int(i+1))+'a'][jj*2:jj*2+2]
O_ids_b=vars()['Os_list_domain'+str(int(i+1))+'b'][jj*2:jj*2+2]
#set the first pb atm to be the ref atm(if you have two layers, same ref point but different height)
H2O_coors_a=[]
try:#anchor the first sorbate
H2O_coors_a=vars()['domain_class_'+str(int(i+1))].add_oxygen_pair2(domain=vars()['domain'+str(int(i+1))+'A'],O_ids=O_ids_a,ref_id=vars()['pb_list_domain'+str(int(i+1))+'a'][0],v_shift=V_SHIFT[i][jj],r=R[i][jj],alpha=ALPHA[i][jj])
except:#anchor O1 if without sorbate
H2O_coors_a=vars()['domain_class_'+str(int(i+1))].add_oxygen_pair2(domain=vars()['domain'+str(int(i+1))+'A'],O_ids=O_ids_a,ref_id='O1_1_0_D'+str(i+1)+'A',v_shift=V_SHIFT[i][jj],r=R[i][jj],alpha=ALPHA[i][jj])
add_atom(domain=vars()['domain'+str(int(i+1))+'B'],ref_coor=H2O_coors_a*[-1,1,1]-[-1.,0.06955,0.5],ids=O_ids_b,els=['O','O'])
#group water molecules at each layer (set equivalent the oc and u during fitting)
M=len(O_ids_a)
vars()['gp_waters_set'+str(jj+1)+'_D'+str(int(i+1))]=vars()['domain_class_'+str(int(i+1))].grouping_discrete_layer(domain=[vars()['domain'+str(int(i+1))+'A']]*M+[vars()['domain'+str(int(i+1))+'B']]*M,atom_ids=O_ids_a+O_ids_b)
#set variables
vars()['domain_class_'+str(int(i+1))].set_new_vars(head_list=['u_o_n','u_Fe_n','oc_n'],N_list=[4,3,7])
vars()['domain_class_'+str(int(i+1))].set_discrete_new_vars_batch(batch_path_head+vars()['discrete_vars_file_domain'+str(int(i+1))])
######################################do grouping###############################################
for i in range(DOMAIN_NUMBER):
#note the grouping here is on a layer basis, ie atoms of same layer are groupped together (4 atms grouped together in sequence grouping)
#you may group in symmetry, then atoms of same layer are not independent (and know the use_sym set to false here)
if DOMAIN[i]==1:
vars()['atm_gp_list_domain'+str(int(i+1))]=vars()['domain_class_'+str(int(i+1))].grouping_sequence_layer(domain=[vars()['domain'+str(int(i+1))+'A'],vars()['domain'+str(int(i+1))+'B']], first_atom_id=['O1_1_0_D'+str(int(i+1))+'A','O1_7_0_D'+str(int(i+1))+'B'],\
sym_file=vars()['sym_file_domain'+str(int(i+1))], id_match_in_sym=vars()['id_match_in_sym_domain'+str(int(i+1))],layers_N=10,use_sym=False)
elif DOMAIN[i]==2:
