X-Git-Url: https://hackdaworld.org/gitweb/?a=blobdiff_plain;f=potentials%2Falbe.c;h=1ec3938844aa80bcb0043be78133c0ccfd08751a;hb=8524173a28f2c22a539ef1b0910a1136d9cb254b;hp=c2acf2f3cfe9902a8f781fe7920dad060fa637cc;hpb=a70de3dccbf0a01c39c2643818ec86c0b465caba;p=physik%2Fposic.git

diff --git a/potentials/albe.c b/potentials/albe.c
index c2acf2f..1ec3938 100644
--- a/potentials/albe.c
+++ b/potentials/albe.c
@@ -20,14 +20,93 @@
 #include "albe.h"
 
 /* create mixed terms from parameters and set them */
-int albe_mult_complete_params(t_albe_mult_params *p) {
+int albe_mult_set_params(t_moldyn *moldyn,int element1,int element2) {
 
-	printf("[moldyn] albe parameter completion\n");
+	t_albe_mult_params *p;
+
+	// set cutoff before parameters (actually only necessary for some pots)
+	if(moldyn->cutoff==0.0) {
+		printf("[albe] WARNING: no cutoff!\n");
+		return -1;
+	}
+
+	/* alloc mem for potential parameters */
+	moldyn->pot_params=malloc(sizeof(t_albe_mult_params));
+	if(moldyn->pot_params==NULL) {
+		perror("[albe] pot params alloc");
+		return -1;
+	}
+
+	/* these are now albe parameters */
+	p=moldyn->pot_params;
+
+	// only 1 combination by now :p
+	switch(element1) {
+		case SI:
+			/* type: silicon */
+			p->S[0]=ALBE_S_SI;
+			p->R[0]=ALBE_R_SI;
+			p->A[0]=ALBE_A_SI;
+			p->B[0]=ALBE_B_SI;
+			p->r0[0]=ALBE_R0_SI;
+			p->lambda[0]=ALBE_LAMBDA_SI;
+			p->mu[0]=ALBE_MU_SI;
+			p->gamma[0]=ALBE_GAMMA_SI;
+			p->c[0]=ALBE_C_SI;
+			p->d[0]=ALBE_D_SI;
+			p->h[0]=ALBE_H_SI;
+			switch(element2) {
+				case C:
+					/* type: carbon */
+					p->S[1]=ALBE_S_C;
+					p->R[1]=ALBE_R_C;
+					p->A[1]=ALBE_A_C;
+					p->B[1]=ALBE_B_C;
+					p->r0[1]=ALBE_R0_C;
+					p->lambda[1]=ALBE_LAMBDA_C;
+					p->mu[1]=ALBE_MU_C;
+					p->gamma[1]=ALBE_GAMMA_C;
+					p->c[1]=ALBE_C_C;
+					p->d[1]=ALBE_D_C;
+					p->h[1]=ALBE_H_C;
+					/* mixed type: silicon carbide */
+					p->Smixed=ALBE_S_SIC;
+					p->Rmixed=ALBE_R_SIC;
+					p->Amixed=ALBE_A_SIC;
+					p->Bmixed=ALBE_B_SIC;
+					p->r0_mixed=ALBE_R0_SIC;
+					p->lambda_m=ALBE_LAMBDA_SIC;
+					p->mu_m=ALBE_MU_SIC;
+					p->gamma_m=ALBE_GAMMA_SIC;
+					p->c_mixed=ALBE_C_SIC;
+					p->d_mixed=ALBE_D_SIC;
+					p->h_mixed=ALBE_H_SIC;
+					break;
+				default:
+					printf("[albe] WARNING: element2\n");
+					return -1;
+			}
+			break;
+		default:
+			printf("[albe] WARNING: element1\n");
+			return -1;
+	}
+
+	printf("[albe] parameter completion\n");
 	p->S2[0]=p->S[0]*p->S[0];
 	p->S2[1]=p->S[1]*p->S[1];
 	p->S2mixed=p->Smixed*p->Smixed;
-
-	printf("[moldyn] albe mult parameter info:\n");
+	p->c2[0]=p->c[0]*p->c[0];
+	p->c2[1]=p->c[1]*p->c[1];
+	p->c2_mixed=p->c_mixed*p->c_mixed;
+	p->d2[0]=p->d[0]*p->d[0];
+	p->d2[1]=p->d[1]*p->d[1];
+	p->d2_mixed=p->d_mixed*p->d_mixed;
+	p->c2d2[0]=p->c2[0]/p->d2[0];
+	p->c2d2[1]=p->c2[1]/p->d2[1];
+	p->c2d2_m=p->c2_mixed/p->d2_mixed;
+
+	printf("[albe] mult parameter info:\n");
 	printf("  S (A)  | %f | %f | %f\n",p->S[0],p->S[1],p->Smixed);
 	printf("  R (A)  | %f | %f | %f\n",p->R[0],p->R[1],p->Rmixed);
 	printf("  A (eV) | %f | %f | %f\n",p->A[0]/EV,p->A[1]/EV,p->Amixed/EV);
@@ -43,34 +122,6 @@ int albe_mult_complete_params(t_albe_mult_params *p) {
 	return 0;
 }
 
-/* albe 1 body part */
-int albe_mult_1bp(t_moldyn *moldyn,t_atom *ai) {
-
-	int brand;
-	t_albe_mult_params *params;
-	t_albe_exchange *exchange;
-	
-	brand=ai->brand;
-	params=moldyn->pot_params;
-	exchange=&(params->exchange);
-
-	/*
-	 * simple: point constant parameters only depending on atom i to
-	 *         their right values
-	 */
-
-	exchange->gamma_i=&(params->gamma[brand]);
-	exchange->c_i=&(params->c[brand]);
-	exchange->d_i=&(params->d[brand]);
-	exchange->h_i=&(params->h[brand]);
-
-	exchange->ci2=params->c[brand]*params->c[brand];
-	exchange->di2=params->d[brand]*params->d[brand];
-	exchange->ci2di2=exchange->ci2/exchange->di2;
-
-	return 0;
-}
-	
 /* albe 3 body potential function (first ij loop) */
 int albe_mult_3bp_j1(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 
@@ -92,11 +143,12 @@ int albe_mult_3bp_j1(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 	 */
 
 	brand=ai->brand;
-	
-	if(brand==aj->brand)
+	if(brand==aj->brand) {
 		S2=params->S2[brand];
-	else
+	}
+	else {
 		S2=params->S2mixed;
+	}
 
 	/* dist_ij, d_ij2 */
 	v3_sub(&dist_ij,&(aj->r),&(ai->r));
@@ -125,7 +177,7 @@ int albe_mult_3bp_j1(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 
 /* albe 3 body potential function (first k loop) */
 int albe_mult_3bp_k1(t_moldyn *moldyn,
-                        t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
+                     t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
 
 	t_albe_mult_params *params;
 	t_albe_exchange *exchange;
@@ -152,12 +204,25 @@ int albe_mult_3bp_k1(t_moldyn *moldyn,
 		R=params->R[brand];
 		S=params->S[brand];
 		S2=params->S2[brand];
+		/* albe needs i,k depending c,d,h and gamma values */
+		exchange->gamma_i=&(params->gamma[brand]);
+		exchange->c_i=&(params->c[brand]);
+		exchange->d_i=&(params->d[brand]);
+		exchange->h_i=&(params->h[brand]);
 	}
 	else {
 		R=params->Rmixed;
 		S=params->Smixed;
 		S2=params->S2mixed;
+		/* albe needs i,k depending c,d,h and gamma values */
+		exchange->gamma_i=&(params->gamma_m);
+		exchange->c_i=&(params->c_mixed);
+		exchange->d_i=&(params->d_mixed);
+		exchange->h_i=&(params->h_mixed);
 	}
+	exchange->ci2=*(exchange->c_i)**(exchange->c_i);
+	exchange->di2=*(exchange->d_i)**(exchange->d_i);
+	exchange->ci2di2=exchange->ci2/exchange->di2;
 
 	/* dist_ik, d_ik2 */
 	v3_sub(&dist_ik,&(ak->r),&(ai->r));
@@ -185,11 +250,11 @@ int albe_mult_3bp_k1(t_moldyn *moldyn,
 	cos_theta=v3_scalar_product(&dist_ij,&dist_ik)/(d_ij*d_ik);
 
 	/* g_ijk */
-	h_cos=*(exchange->h_i)-cos_theta;
+	h_cos=*(exchange->h_i)+cos_theta; // + in albe formalism
 	d2_h_cos2=exchange->di2+(h_cos*h_cos);
 	frac=exchange->ci2/d2_h_cos2;
 	g=*(exchange->gamma_i)*(1.0+exchange->ci2di2-frac);
-	dg=-2.0*frac**(exchange->gamma_i)*h_cos/d2_h_cos2;
+	dg=2.0*frac**(exchange->gamma_i)*h_cos/d2_h_cos2; // + in albe f..
 
 	/* zeta sum += f_c_ik * g_ijk */
 	if(d_ik<=R) {
@@ -205,6 +270,11 @@ int albe_mult_3bp_k1(t_moldyn *moldyn,
 		exchange->zeta_ij+=f_c_ik*g;
 	}
 
+#ifdef DEBUG
+	if(ai==&(moldyn->atom[DATOM])) 
+		printf("zeta_ij: %f %f %f %f\n",f_c_ik*g,f_c_ik,g,d_ik);
+#endif
+
 	/* store even more data for second k loop */
 	exchange->g[kcount]=g;
 	exchange->dg[kcount]=dg;
@@ -232,6 +302,7 @@ int albe_mult_3bp_j2(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 	double d_ij,r0;
 	unsigned char brand;
 	double S,R,s_r,arg;
+	double energy;
 
 	params=moldyn->pot_params;
 	exchange=&(params->exchange);
@@ -288,34 +359,39 @@ int albe_mult_3bp_j2(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 		db=-0.5*b/(1.0+exchange->zeta_ij);
 	}
 
-	/* force contribution */
-	scale=-0.5*(f_c*(df_r+b*df_a)+df_c*(f_r+b*df_a));
+	/* force contribution for atom i */
+	scale=-0.5*(f_c*(df_r-b*df_a)+df_c*(f_r-b*f_a)); // - in albe formalism
 	v3_scale(&force,&(exchange->dist_ij),scale);
 	v3_add(&(ai->f),&(ai->f),&force);
-	v3_sub(&(aj->f),&(aj->f),&force); // dri rij = - drj rij
+
+	/* force contribution for atom j */
+	v3_scale(&force,&force,-1.0); // dri rij = - drj rij
+	v3_add(&(aj->f),&(aj->f),&force);
+
+	/* virial */
+	virial_calc(ai,&force,&(exchange->dist_ij));
 
 #ifdef DEBUG
-	if((ai==&(moldyn->atom[0]))|(aj==&(moldyn->atom[0]))) {
+	if((ai==&(moldyn->atom[DATOM]))|(aj==&(moldyn->atom[DATOM]))) {
 		printf("force 3bp (j2): [%d %d sum]\n",ai->tag,aj->tag);
-		printf("adding %f %f %f\n",force.x,force.y,force.z);
-		if(ai==&(moldyn->atom[0]))
-			printf("total i: %f %f %f\n",ai->f.x,ai->f.y,ai->f.z);
-		if(aj==&(moldyn->atom[0]))
-			printf("total j: %f %f %f\n",aj->f.x,aj->f.y,aj->f.z);
-		printf("energy: %f = %f %f %f %f\n",0.5*f_c*(b*f_a+f_r),
+		printf("  adding %f %f %f\n",force.x,force.y,force.z);
+		if(ai==&(moldyn->atom[DATOM]))
+			printf("  total i: %f %f %f\n",ai->f.x,ai->f.y,ai->f.z);
+		if(aj==&(moldyn->atom[DATOM]))
+			printf("  total j: %f %f %f\n",aj->f.x,aj->f.y,aj->f.z);
+		printf("  energy: %f = %f %f %f %f\n",0.5*f_c*(b*f_a+f_r),
 		                                    f_c,b,f_a,f_r);
+		printf("          %f %f %f\n",exchange->zeta_ij,.0,.0);
 	}
 #endif
 
-	/* virial */
-	if(aj<ai)
-		virial_calc(ai,&force,&(exchange->dist_ij));
-
-	/* dzeta prefactor = - 0.5 f_c f_a db */
-	exchange->pre_dzeta=-0.5*f_a*f_c*db;
+	/* dzeta prefactor = - f_c f_a db, (* -0.5 due to force calc) */
+	exchange->pre_dzeta=0.5*f_a*f_c*db;
 
 	/* energy contribution */
-	moldyn->energy+=0.5*f_c*(f_r+b*f_a);
+	energy=0.5*f_c*(f_r-b*f_a); // - in albe formalism
+	moldyn->energy+=energy;
+	ai->e+=energy;
 
 	/* reset k counter for second k loop */
 	exchange->kcount=0;
@@ -325,7 +401,7 @@ int albe_mult_3bp_j2(t_moldyn *moldyn,t_atom *ai,t_atom *aj,u8 bc) {
 
 /* albe 3 body potential function (second k loop) */
 int albe_mult_3bp_k2(t_moldyn *moldyn,
-                        t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
+                     t_atom *ai,t_atom *aj,t_atom *ak,u8 bc) {
 
 	t_albe_mult_params *params;
 	t_albe_exchange *exchange;
@@ -338,7 +414,7 @@ int albe_mult_3bp_k2(t_moldyn *moldyn,
 	double pre_dzeta;
 	double f_c_ik,df_c_ik;
 	double dijdik_inv,fcdg,dfcg;
-	t_3dvec dcosdri,dcosdrj,dcosdrk;
+	t_3dvec dcosdrj,dcosdrk;
 	t_3dvec force,tmp;
 
 	params=moldyn->pot_params;
@@ -384,41 +460,19 @@ int albe_mult_3bp_k2(t_moldyn *moldyn,
 	dg=exchange->dg[kcount];
 	cos_theta=exchange->cos_theta[kcount];
 
-	/* cos_theta derivatives wrt i,j,k */
+	/* cos_theta derivatives wrt j,k */
 	dijdik_inv=1.0/(d_ij*d_ik);
-	v3_scale(&dcosdrj,&dist_ik,dijdik_inv);
+	v3_scale(&dcosdrj,&dist_ik,dijdik_inv);		// j
 	v3_scale(&tmp,&dist_ij,-cos_theta/d_ij2);
 	v3_add(&dcosdrj,&dcosdrj,&tmp);
-	v3_scale(&dcosdrk,&dist_ij,dijdik_inv);
+	v3_scale(&dcosdrk,&dist_ij,dijdik_inv);		// k
 	v3_scale(&tmp,&dist_ik,-cos_theta/d_ik2);
 	v3_add(&dcosdrk,&dcosdrk,&tmp);
-	v3_add(&dcosdri,&dcosdrj,&dcosdrk);
-	v3_scale(&dcosdri,&dcosdri,-1.0);
 
 	/* f_c_ik * dg, df_c_ik * g */
 	fcdg=f_c_ik*dg;
 	dfcg=df_c_ik*g;
 
-	/* derivative wrt i */
-	v3_scale(&force,&dist_ik,dfcg);
-	v3_scale(&tmp,&dcosdri,fcdg);
-	v3_add(&force,&force,&tmp);
-	v3_scale(&force,&force,pre_dzeta);
-
-	/* force contribution */
-	v3_add(&(ai->f),&(ai->f),&force);
-	
-#ifdef DEBUG
-	if(ai==&(moldyn->atom[0])) {
-		printf("force 3bp (k2): [%d %d %d]\n",ai->tag,aj->tag,ak->tag);
-		printf("adding %f %f %f\n",force.x,force.y,force.z);
-		printf("total i: %f %f %f\n",ai->f.x,ai->f.y,ai->f.z);
-	}
-#endif
-
-	/* virial */
-	//virial_calc(ai,&force,&dist_ij);
-
 	/* derivative wrt j */
 	v3_scale(&force,&dcosdrj,fcdg*pre_dzeta);
 
@@ -426,17 +480,21 @@ int albe_mult_3bp_k2(t_moldyn *moldyn,
 	v3_add(&(aj->f),&(aj->f),&force);
 
 #ifdef DEBUG
-	if(aj==&(moldyn->atom[0])) {
+	if(aj==&(moldyn->atom[DATOM])) {
 		printf("force 3bp (k2): [%d %d %d]\n",ai->tag,aj->tag,ak->tag);
-		printf("adding %f %f %f\n",force.x,force.y,force.z);
-		printf("total j: %f %f %f\n",aj->f.x,aj->f.y,aj->f.z);
+		printf("  adding %f %f %f\n",force.x,force.y,force.z);
+		printf("  total j: %f %f %f\n",aj->f.x,aj->f.y,aj->f.z);
+		printf("  angle: %f\n",acos(cos_theta)*360.0/(2*M_PI));
+		printf("    d ij ik = %f %f\n",d_ij,d_ik);
 	}
 #endif
 
 	/* virial */
-	//v3_scale(&force,&force,-1.0);
-	if(aj<ai)
-		virial_calc(ai,&force,&dist_ij);
+	virial_calc(ai,&force,&dist_ij);
+
+	/* force contribution to atom i */
+	v3_scale(&force,&force,-1.0);
+	v3_add(&(ai->f),&(ai->f),&force);
 
 	/* derivative wrt k */
 	v3_scale(&force,&dist_ik,-1.0*dfcg); // dri rik = - drk rik
@@ -448,21 +506,51 @@ int albe_mult_3bp_k2(t_moldyn *moldyn,
 	v3_add(&(ak->f),&(ak->f),&force);
 
 #ifdef DEBUG
-	if(ak==&(moldyn->atom[0])) {
+	if(ak==&(moldyn->atom[DATOM])) {
 		printf("force 3bp (k2): [%d %d %d]\n",ai->tag,aj->tag,ak->tag);
-		printf("adding %f %f %f\n",force.x,force.y,force.z);
-		printf("total k: %f %f %f\n",ak->f.x,ak->f.y,ak->f.z);
+		printf("  adding %f %f %f\n",force.x,force.y,force.z);
+		printf("  total k: %f %f %f\n",ak->f.x,ak->f.y,ak->f.z);
+		printf("  angle: %f\n",acos(cos_theta)*360.0/(2*M_PI));
+		printf("    d ij ik = %f %f\n",d_ij,d_ik);
 	}
 #endif
 
 	/* virial */
-	//v3_scale(&force,&force,-1.0);
-	if(aj<ai)
-		virial_calc(ai,&force,&dist_ik);
+	virial_calc(ai,&force,&dist_ik);
 	
+	/* force contribution to atom i */
+	v3_scale(&force,&force,-1.0);
+	v3_add(&(ai->f),&(ai->f),&force);
+
 	/* increase k counter */
 	exchange->kcount++;	
 
 	return 0;
 
 }
+
+int albe_mult_check_2b_bond(t_moldyn *moldyn,t_atom *itom,t_atom *jtom,u8 bc) {
+
+	t_albe_mult_params *params;
+	t_3dvec dist;
+	double d;
+	u8 brand;
+
+	v3_sub(&dist,&(jtom->r),&(itom->r));
+	if(bc) check_per_bound(moldyn,&dist);
+	d=v3_absolute_square(&dist);
+
+	params=moldyn->pot_params;
+	brand=itom->brand;
+
+	if(brand==jtom->brand) {
+		if(d<=params->S2[brand])
+			return TRUE;
+	}
+	else {
+		if(d<=params->S2mixed)
+			return TRUE;
+	}
+
+	return FALSE;
+}