计算硼原子的基态能级的java程序

最新推荐文章于 2024-07-19 17:37:28 发布
最新推荐文章于 2024-07-19 17:37:28 发布
阅读量217 收藏
点赞数
分类专栏： 用神经网络模拟原子 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/georgesale/article/details/121144687
版权

这个程序由2个java程序，1个python程序共3部分构成，具体包括

public class eneB：用于计算硼原子的动能，势能，库仑能和相互作用能

public class overlap3：计算Gaunt积分和ck值

cal.py：用python实现积分

积分是由java调用python实现的，java和python通过一个csv文件来传递参数，程序中有两个本地路径需要改，

一个是csv的地址d:/工业/hk/python/表达式.csv，

一个是python程序的地址D:/Download/cal.py

程序初始化有两个地方需要改，是eneB和cal，需要改核电荷数z，轨道半径a0、a1，轨道fx、rj，两个地方内容是同样的。

启动顺序，先启动cal.py，生成cal.py文件，再启动eneB。

1.eneB代码 

	import java.io.DataInputStream;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.io.InputStream;
	import java.text.ParseException;


	public class eneB {
		//overlap3
		
	public static  double calc2( String stra ) throws IOException, ParseException, InterruptedException {
			
			FileWriter fileWriter5 = new FileWriter("d:/工业/hk/python/表达式.csv");
			
			//stra="hin( fx1,fx1)";
			//stra="jin( rj1,rj2)";
			
			stra=stra.replaceAll(",","#");
					
			fileWriter5.write( stra + "\r\n");
			fileWriter5.flush();
			
			String exe = "python";
			String command = "D:/Download/cal.py";	
			
			String[] cmdArr = new String[] {exe ,command  };
			Process process = Runtime.getRuntime().exec(cmdArr);
			InputStream is = process.getInputStream();
			DataInputStream dis = new DataInputStream(is);
			String str = dis.readLine();
			process.waitFor();
			System.out.println(str); 
			
			double df= Double.parseDouble(str.trim());	 
			return df;
		}

	     public static double hin( String str1 ,String str2) throws  IOException, ParseException, InterruptedException {
	    	 
	    	 String str="hin("+str1+","+str2+")";
	    	 
	    	 //System.out.println(  str+" ** "  );
	    	 
	    	 double d=calc2(  str );
	    	 
	    	return d; 
	     }
	     
	    public static double jin( String str1 ,String str2 , int str3) throws  IOException, ParseException, InterruptedException {
	    	 
	    	String str="jin("+str1+","+str2+","+str3+")";
	    	 
	    	 double d=calc2(  str );
	    	 
	    	return d; 
	     }

	    public static double kin( String str1 ,String str2, String str3,String str4,int str5) throws  IOException, ParseException, InterruptedException {
	   	 
	    	String str="kin("+str1+","+str2+","+str3+","+str4+","+str5+")";
	    	 
	    	 double d=calc2(  str );
	    	 
	    	return d; 
	     }
	    
	    
	    
	    //ckLM ( int L1,int L2,int m1 ,int m2 ,int k    )
	    public static double ak( String str1 ,String str2,int L1,int m1 ,int L2,int m2) throws  IOException, ParseException, InterruptedException {
	   	 
	    	int k[]=overlap3.cgk (L1 , L2 );
	    	
	    	double t=0;
	    	for(int a=0 ;a<k.length ;a++){
	    		
	    		if(t<k[a]){
	    			t=k[a];
	    		}
	    		
	    	}
	    	
	    	double d=0.0;
	    	
	    	  double d1=0.0;
			  double d2=0.0; 
			  double d3=0.0; 
	    	
	    	  for(int a=0 ;a<5 ;a++){
	    		  
	    		  //System.out.println( k[a]+  "***" +a+" ** "+L1+" "+m1);
	    		    d1=overlap3.ckLM(L1,L1,m1,m1,a);
	    		    d2=overlap3.ckLM(L2,L2,m2,m2,a);
	    		    
	    		    if( (Math.abs(d1)>1e-6)&&(Math.abs(d2)>1e-6) ){
	    		    d3=jin( str1 ,  str2 ,a);
	    		    }
	    		  
	    		    if( (Math.abs(d1)<1e-6)||(Math.abs(d2)<1e-6) ){
	        		    d3=0.0;
	        		    }
	    		    
	    		d=d+   d1*d2*d3;
	    				
	    		
	    		System.out.println(   "***" +a+" ** "+L1+" "+m1+"  d "+d1+" "+d2+"  "+d3);
	    		  
	    	  }

	    	 
	    	return d; 
	     }

	    
	    //ckLM ( int L1,int L2,int m1 ,int m2 ,int k    )
	    public static double bk( String str1 ,String str2, String str3,String str4,int L1,int m1 ,int L2,int m2) throws  IOException, ParseException, InterruptedException {
	   	 
	    	int k[]=overlap3.cgk (L1 , L2 );
	    	
	    	double t=0;
	    	for(int a=0 ;a<k.length ;a++){
	    		
	    		if(t<k[a]){
	    			t=k[a];
	    		}
	    		
	    	}
	    	
	    	double d=0.0;
	    	
	    	  double d1=0.0;
			
			  double d3=0.0; 
	    	
	    	  for(int a=0 ;a<5 ;a++){
	    		  
	    		  
	    		    d1=overlap3.ckLM(L1,L2,m1,m2,a);
	    		    
	    		    
	    		    if( (Math.abs(d1)>1e-6) ){
	    		    d3=kin( str1 , str2, str3 , str4 ,a);
	    		    }
	    		  
	    		    if( (Math.abs(d1)<1e-6) ){
	        		    d3=0.0;
	        		    }
	    		    
	    		d=d+   d1*d1*d3;
	    		
	    		System.out.println(   "***" +a+" **  d "+d+" "+d1*d1+"  "+d3);
	    				
	    	  }
	    		System.out.println(   "*** ** "+L1+" "+m1+"  d "+d1+"   "+d3);
	    	 
	    	return d; 
	     }
	    
	 
	    
	    public static void eB() throws  IOException, ParseException, InterruptedException {
	    	

	    int z=5;

	    int a0=1;
	    int a1=4;


	    String fx1="(z/a0)**(1.5)*2*sympy.exp(-z*r/a0  )*(4*pi)**(-0.5)";
	    String fx2="(z/( 2*a1))**(1.5)*(2-z*r/a1)*sympy.exp(-z*r/(2*a1)  )*(4*pi)**(-0.5)";
	    String fx3="(z/( 2*a1))**(1.5)*(z*r/(3**0.5*a1) )*sympy.exp(-z*r/(2*a1)  )*(3/(4*pi))**(0.5)* cos(θ)";


	    // 库仑斥力积分
	    //fj1 = (z/a0)**(1.5)*2*sympy.exp(-z*r1/a0  )*(4*pi)**(-0.5)
	    //fj2 = (z/a0)**(1.5)*2*sympy.exp(-z*r2/a0  )*(4*pi)**(-0.5)
	    String rj1 ="(z/a0)**(1.5)*2*sympy.exp(-z*r1/a0  )";
	    String rj2 ="(z/a0)**(1.5)*2*sympy.exp(-z*r2/a0  )";

	   //fj3=(z/( 2*a1))**(1.5)*(2-z*r1/a1)*sympy.exp(-z*r1/(2*a1)  )*(4*pi)**(-0.5)
	   //fj4=(z/( 2*a1))**(1.5)*(2-z*r2/a1)*sympy.exp(-z*r2/(2*a1)  )*(4*pi)**(-0.5)
	   String rj3="(z/( 2*a1))**(1.5)*(2-z*r1/a1)*sympy.exp(-z*r1/(2*a1)  )";
	   String rj4="(z/( 2*a1))**(1.5)*(2-z*r2/a1)*sympy.exp(-z*r2/(2*a1)  )";

	   //fj5=(z/( 2*a1))**(1.5)*(z*r1/(3**0.5*a1) )*sympy.exp(-z*r1/(2*a1)  )*(3/(4*pi))**(0.5)* cos(θ)
	   //fj6=(z/( 2*a1))**(1.5)*(z*r2/(3**0.5*a1) )*sympy.exp(-z*r2/(2*a1)  )*(3/(4*pi))**(0.5)* cos(θ)
	   String rj5="(z/( 2*a1))**(1.5)*(z*r1/(3**0.5*a1) )*sympy.exp(-z*r1/(2*a1)  )";
	   String rj6="(z/( 2*a1))**(1.5)*(z*r2/(3**0.5*a1) )*sympy.exp(-z*r2/(2*a1)  )";

	    // System.out.println(  hin(fx1,fx1)+" ** " +jin(rj1,rj2)+"  "+ kin(rj1,rj4,rj2,rj3,"1"));
	     
	      double fh=hin(fx1,fx1)*2+hin(fx2,fx2)*2+hin(fx3,fx3);
	      double fj=ak( rj1 , rj2 ,0,0,0,0)+ak( rj1 , rj4 ,0,0,0,0)*4+ak( rj1 , rj6 ,0,0,1,0)*2+
	    	 	   ak( rj3 , rj4 ,0,0,0,0)+ak( rj3 , rj6 ,0,0,1,0)*2;
	    double fk=bk( rj1 ,rj4, rj2, rj3,0,0 ,0,0)*4+ bk( rj1 ,rj6, rj2, rj5,0,0 ,1,0)*2+bk( rj3 ,rj6, rj4, rj5,0,0 ,1,0)*2;
	    
	    System.out.println( fh+fj-fk +"  "+fh+"  "+fj+"  "+fk +"  "+(fh+fj-fk)*27.2 );
	   
	     }
        
	    
	public static void main(String[] args) throws IOException, ParseException, InterruptedException {

		   eB();
	
			}

	}

2. overlap3代码

    import java.io.FileWriter;
	import java.io.IOException;
	import java.text.ParseException;
	import java.util.regex.Pattern;

	 
		public class overlap3 {
			 	 
				        //只能得到合法数值
			            //实现Gaunt积分 L<=2
					
					static int dx=1;
					
					public static  double FACT( double n ) throws IOException, ParseException {
												
						double prodt=1.0;
						for(int a=1 ;a<n+1 ;a++)
						{
							prodt=prodt*a;
						}
						
						if(n<0){
							//   System.out.println( prodt+   "  负数阶乘 "  );
							   dx=0;
						   }
						  
						return prodt;
						
					}

					// (m1*m2<0)&&m1<0  	
					public static  double gauntb ( int L1,int L2,int m1 ,int m2 ,int k   ) throws IOException, ParseException{
						 

						int s= (int) (0.5*(L1+k+L2));
						
						double f1=0.0;
						
						f1=FACT(k+Math.abs(m1-m2)  )*FACT(L2+Math.abs(m2))*FACT(2*s-2*L2)*FACT(s);
				        
				       // System.out.println( " b "+ L1+"   "+L2+"  "+m1+"  "+m2 ); 
						 
				        double f2=FACT(k-Math.abs(m1-m2)  )*FACT(s-L1)*FACT(s-k)*FACT(s-L2)*FACT(2*s+1);
						
						int t[]=choosetb ( L1, L2,m1 , m2 , k   );
				
						
						double b=0.0;
						double f3=0.0;
						double f4=0.0;
						
						for(int a=0 ;a<t.length;a++){
							
				        f3=FACT(L1+Math.abs(m1)+ t[a] )*FACT(k+L2-Math.abs(m1)-t[a]);		

				        f4=FACT(t[a])*FACT(L1-Math.abs(m1)- t[a] )*FACT(k-L2+Math.abs(m1)+t[a])*FACT(L2+m2-t[a]);
				  
					    b=b+Math.pow( (-1), t[a] )*f3/f4;
							 
						}
						
						double g=2*Math.pow( (-1),s-k-Math.abs(m2) )*(f1/f2)*b;
							
					//  System.out.println(  g +" gaunt  "+b +"  b  "+s+"  "+k );
						
					  
					return g;			
					}
					
					//(m1*m2<0)&&m2<0 
					public static  double gauntc ( int L1,int L2,int m1 ,int m2 ,int k   ) throws IOException, ParseException{
						 

						int s= (int) (0.5*(L1+k+L2));
						
						double f1=0.0;
						
						f1=FACT(k+Math.abs(m1-m2)  )*FACT(L2+Math.abs(m2))*FACT(2*s-2*L2)*FACT(s);
				      
				      //  System.out.println( " c "+ L1+"   "+L2+"  "+m1+"  "+m2 +"  "+k+"  "); 
						 	
				        double f2=FACT(k-Math.abs(m1-m2)  )*FACT(s-L1)*FACT(s-k)*FACT(s-L2)*FACT(2*s+1);
						
						int t[]=choosetc ( L1, L2,m1 , m2 , k   );
						
						
						double b=0.0;
						double f3=0.0;
						double f4=0.0;
						
						for(int a=0 ;a<t.length;a++){
							
				         f3=FACT(L1+Math.abs(m1)+ t[a] )*FACT(k+L2-Math.abs(m1)-t[a]);		

				         f4=FACT(t[a])*FACT(L1-Math.abs(m1)- t[a] )*FACT(k-L2+Math.abs(m1)+t[a])*FACT(L2-m2-t[a]);
				         
					     b=b+Math.pow( (-1), t[a] )*f3/f4;
							 
							//  System.out.println(   b +"  b  "  );
						}
						
						double g=2*Math.pow( (-1),s-k-Math.abs(m2) )*(f1/f2)*b;
							
					 //   System.out.println(  g +" gaunt  "+b +"  b  "+s+ " "+k );
						
					 // System.out.println(FACT(0)+" "+FACT(L1-Math.abs(m1)- 0 )+" "+ FACT(k-L2+Math.abs(m1)+0)+" "+ FACT(L2-Math.abs(m2)-0)  );
						
					  
					return g;			
					}
					
				 	
					public static  double gaunta ( int L1,int L2,int m1 ,int m2 ,int k   ) throws IOException, ParseException{
						 

						int s= (int) (0.5*(L1+k+L2));
						
						double f1=0.0;
						
					 
						f1=FACT(k+Math.abs(m1-m2)  )*FACT(L2+Math.abs(m2))*FACT(2*s-2*L2)*FACT(s);
						 
				        double f2=FACT(k-Math.abs(m1-m2)  )*FACT(s-L1)*FACT(s-k)*FACT(s-L2)*FACT(2*s+1);
			
						int t[]=chooset ( L1, L2,m1 , m2 , k   );
						
						
						double b=0.0;
						double f3=0.0;
						double f4=0.0;
						
						for(int a=0 ;a<t.length;a++){
							
				        f3=FACT(L1+Math.abs(m1)+ t[a] )*FACT(k+L2-Math.abs(m1)-t[a]);		
				
				        f4=FACT(t[a])*FACT(L1-Math.abs(m1)- t[a] )*FACT(k-L2+Math.abs(m1)+t[a])*FACT(L2-Math.abs(m2)-t[a]);

			
							 b=b+Math.pow( (-1), t[a] )*f3/f4;
							 
							//  System.out.println(   b +"  b  "  );
						}
						
						double g=2*Math.pow( (-1),s-k-Math.abs(m2) )*(f1/f2)*b;
						
					//	System.out.println( " a "+ L1+"   "+L2+"  "+m1+"  "+m2 +"  s k "+s+"  "+k ); 
							
					//  System.out.println(  g +" gaunt  "+b +"  b  "+FACT(k+L2-Math.abs(m1)-0) );
						
					
					  
					return g;			
					}
					

					//算Gaunt 的K
					public static  int[] cgk ( int L1,int L2 ) throws IOException, ParseException{
						
						
						String str="";
						int cou=0;
						for(int a=0 ;a<7 ;a++){
							
							//System.out.println(a+" **  " );
							
							if( a<=L1+L2 && a>=Math.abs(L1-L2)){
								
								if((L1+L2+a)%2==0){
									
									//System.out.println(a+" ** * " );
									str=str+a+",";
									cou++;
								}
							}
							
						}
						
						
						int k[]=new int[cou];
						
						int cou1=0;
						
				        for(int a=0 ;a<7 ;a++){
							
							//System.out.println(a+" **  " );
							
							if( a<=L1+L2 && a>=Math.abs(L1-L2)){
								
								if((L1+L2+a)%2==0){
									
									 System.out.println(a+" ** * k" );
									k[cou1]=a;
									cou1++;
								}
							}
							
						}
						
						
						return k;	
					}
					
					//判断k是否合法
					public static  int ckk ( int []tem ,int k ) throws IOException, ParseException{
						
						int cou=0;
						
						  for(int a=0 ;a<tem.length ;a++){
								
								//System.out.println(a+" **  " );
								
								if(  tem[a]==k ){
									
									 cou=1;
									 break;
								}
								
							}
						
						return cou;
					}
					
					
					//考虑 L1=L2<=3   t [-6,9]
					public static  void cgt (   ) throws IOException, ParseException{
						
						double a1=0.0;
						double a2=0.0;
						double a3=0.0;
						double a4=0.0;
						double a5=0.0;
						
						for(int L1=0 ;L1<4 ;L1++){
							for(int L2=0 ;L2<4 ;L2++){
								
								for(int m1=-L1 ;m1<L1+1 ;m1++){
									for(int m2=-L2 ;m2<L2+1 ;m2++){
										
										// System.out.println( L1+" "+L2+"  "+m1+"  "+m2+" **  " );		
										
										int k[]=cgk (  L1,L2 );
										
										for(int a=0 ;a<k.length ;a++){
											
											  a1=L1+Math.abs(m1);  //0  6        //+t -6  oo
											  a2=k[a]+L2-Math.abs(m1);	//0  9   //-t  9  -oo	 		 
												 
											  a3=L1-Math.abs(m1); //0   3        //-t  3  -oo
											  a4=k[a]-L2+Math.abs(m1);  // -3  6 //+t  -6  oo 
											  a5=L2-Math.abs(m2);  //0  3        //-t   3  -oo
													
										//	  System.out.println( a1+ " "+a2+"  "+a3+" "+a4+" "+a5 );		
											
										}
										
										
									}
								}
								
								
							}
						}
						
						
						
					}
					
					//在0到9范围内选择t 但t不能是负数       给出t数组
					public static  int[] chooset ( int L1,int L2,int m1 ,int m2 ,int k   ) throws IOException, ParseException{
						
						int a1=0;
						int a2=0;
						int a3=0;
						int a4=0;
						int a5=0;
						
						String str="";
						
						
						for(int a=0 ;a<10 ;a++){

							
							  a1=L1+Math.abs(m1)+a;  //0  -6
							  a2=k+L2-Math.abs(m1)-a;	//0 -9			
								
							  a3=L1-Math.abs(m1)-a; //0  -3
							  a4=k-L2+Math.abs(m1)+a;  //-6  3
							  a5=L2-Math.abs(m2)-a;  //0 -3
							  
							  if(a1>=0&&a2>=0&&a3>=0&&a4>=0&&a5>=0){
								  
								  str=str+a+",";
								  
							  }
							
							
						}
						
						 //System.out.println(  str+ " **  t" );

							str=str.trim();
							String[] w=Pattern.compile(",").split(str);
							
							int []t=new int[w.length];
						
						 	 for (int b = 0; b < w.length ; b++)  {
						 		 
						 		 t[b]=Integer.parseInt(w[b].trim());
						 		 
						 	//	System.out.println(  t[b]+" **  t" );
						 		 
					}
						
						return t;
					}
						
				    public static  int[] choosetb ( int L1,int L2,int m1 ,int m2 ,int k   ) throws IOException, ParseException{
						
						int a1=0;
						int a2=0;
						int a3=0;
						int a4=0;
						int a5=0;
						
						String str="";
						
						
						for(int a=0 ;a<10 ;a++){

							
							  a1=L1+Math.abs(m1)+a;  //0  -6
							  a2=k+L2-Math.abs(m1)-a;	//0 -9			
								
							  a3=L1-Math.abs(m1)-a; //0  -3
							  a4=k-L2+Math.abs(m1)+a;  //-6  3
							  //a5=L2-Math.abs(m2)-a;  //0 -3
							  a5=L2+m2-a;
							  if(a1>=0&&a2>=0&&a3>=0&&a4>=0&&a5>=0){
								  
								  str=str+a+",";
								  
							  }
							
							
						}
						
						 //System.out.println(  str+ " **  t" );

							str=str.trim();
							String[] w=Pattern.compile(",").split(str);
							
							int []t=new int[w.length];
						
						 	 for (int b = 0; b < w.length ; b++)  {
						 		 
						 		 t[b]=Integer.parseInt(w[b].trim());
						 		 
						 	//	System.out.println(  t[b]+" **  t" );
						 		 
					}
						
						return t;
					}
					
				    public static  int[] choosetc ( int L1,int L2,int m1 ,int m2 ,int k   ) throws IOException, ParseException{
						
						int a1=0;
						int a2=0;
						int a3=0;
						int a4=0;
						int a5=0;
						
						String str="";
						
						for(int a=0 ;a<10 ;a++){

							
							  a1=L1+Math.abs(m1)+a;  //0  -6
							  a2=k+L2-Math.abs(m1)-a;	//0 -9			
								
							  a3=L1-Math.abs(m1)-a; //0  -3
							  a4=k-L2+Math.abs(m1)+a;  //-6  3
							  //a5=L2-Math.abs(m2)-a;  //0 -3
							  a5=L2-m2-a;
							  
							  if(a1>=0&&a2>=0&&a3>=0&&a4>=0&&a5>=0){
								  
								  str=str+a+",";
								  
							  }
							
							
						}
						
						 //System.out.println(  str+ " **  t" );

							str=str.trim();
							String[] w=Pattern.compile(",").split(str);
							
							int []t=new int[w.length];
						
						 	 for (int b = 0; b < w.length ; b++)  {
						 		 
						 		 t[b]=Integer.parseInt(w[b].trim());
						 		 
						 	//	System.out.println(  t[b]+" **  t" );
						 		 
					}
						
						return t;
					}
					
					
					public static  double ckLM ( int L1,int L2,int m1 ,int m2 ,int k    ) throws IOException, ParseException{
						
						int t1=L1;
						int t2=L2;
						int t3=m1;
						int t4=m2;
						
						dx=1;
							 
					//	System.out.println(  " a4 *****  "+ L1+"   "+L2+"  "+m1+"  "+m2 ); 
						
						int []tem= cgk(L1,L2);
						 
						int cou= ckk ( tem , k );
						
						double a4=0;
						if(cou==1)
						{
						int a=0;	
						a=(int) ((m1+Math.abs(m1)+m2+Math.abs(m2) +(m1-m2)+Math.abs(m1-m2))*0.5);
						
						double a1=Math.pow( FACT(k-Math.abs(m1-m2) ) / FACT(k+Math.abs(m1-m2))  ,0.5   );
						
						double a2=Math.pow( FACT(L1-Math.abs(m1))*(2*L1+1) / (FACT(L1+Math.abs(m1))*2 )  ,0.5   );
						
						double a3=Math.pow( FACT(L2-Math.abs(m2))*(2*L2+1) /(FACT(L2+Math.abs(m2))*2 )  ,0.5   );
						
						// System.out.println( a+" *** * *"+ a1+" "+a2+" "+a3  );
						 
						 double a5=0.0;
						 
						    if ( (Math.abs(m1)>=Math.abs(m2))&& (m1*m2>=0    )  )   	
							{	
								 a5=gaunta ( L1, L2, m1 ,m2 , k   );
								 
							}
						 
						 
							if ( (Math.abs(m1)<Math.abs(m2))&& (m1*m2>=0    ) )
							{
									
								 a5=gaunta ( t2, t1, t4 ,t3 , k   );	 
							}
							
							
				            
							 if ( (m1*m2<0)&&m1<0   ) {
								 
								 a5=gauntb ( L1, L2, m1 ,m2 , k   );
								 
								 a=(int) ((m1+m1+m2+Math.abs(m2) +(m1-m2)+Math.abs(m1-m2))*0.5);
								 
								 if(L1==1&&L2==2&&m1==-1&&m2==2&&k==3)
								 {
									 a=(int) ((m1+Math.abs(m1)+m2-Math.abs(m2) +(m1-m2)+Math.abs(m1-m2))*0.5);
								 }
								 
								 if(L1==2&&L2==2&&m1==-2&&m2==1&&k==4)
								 {
									 a=(int) ((m1+Math.abs(m1)+m2-Math.abs(m2) +(m1-m2)+Math.abs(m1-m2))*0.5);
								 }
								 
								 if(L1==2&&L2==1&&m1==-2&&m2==1&&k==3)
								 {
									 a=(int) ((m1+Math.abs(m1)+m2-Math.abs(m2) +(m1-m2)+Math.abs(m1-m2))*0.5);
								
								 }	
								 
								 if(L1==2&&L2==2&&m1==-1&&m2==2&&k==4)
								 {
									 a=(int) ((m1+Math.abs(m1)+m2-Math.abs(m2) +(m1-m2)+Math.abs(m1-m2))*0.5);
								
								 }
								 
							 }
							 
							 
				             if ( (m1*m2<0)&&m2<0   ) {
								 
								 a5=gauntc ( L1, L2, m1 ,m2 , k   );
								 
								 a=(int) ((m1+Math.abs(m1)+m2+m2 +(m1-m2)+Math.abs(m1-m2))*0.5);
								 
							 }
					
						
					  a4=Math.pow(  (-1),a)*a1*a2*a3*a5;
					  
					  double a6=Math.pow(  (-1),a)*a1*a2*a3;
								
						 
					if(dx==0){
					//	System.out.println( " dx *** * *" +dx );
						a4=0;
					}
					
					}
						
						if(cou==0){
						//	System.out.println( " cou *** * *"  );
							a4=0;
						}
						
					System.out.println( a4+" a4 "+ L1+"   "+L2+"  "+m1+"  "+m2 ); 
					
					return a4;
					}
					
					
					public static void main(String[] args) throws IOException, ParseException {

						 ckLM (   1  ,  0 ,   1  ,  0 ,  1  );  
						//ckLM (   0  ,  1 ,   0  ,  1 ,  1  );  
						
							}
				}

3.cal代码

import sympy
import math
from sympy import symbols, cancel
import csv

a = sympy.Symbol('a')
e = sympy.Symbol('e')
m = sympy.Symbol('m')
h = sympy.Symbol('h')
l = sympy.Symbol('l')
lp = sympy.Symbol('lp')
r = sympy.Symbol('r')
EE = sympy.Symbol('EE')
R = sympy.Symbol('R')
r1 = sympy.Symbol('r1')
r2 = sympy.Symbol('r2')
r3 = sympy.Symbol('r3')

c1 = sympy.Symbol('c1')
c2 = sympy.Symbol('c2')
c3 = sympy.Symbol('c3')

μ = sympy.Symbol('μ')
v = sympy.Symbol('v')

α = sympy.Symbol('α')
β = sympy.Symbol('β')



x = sympy.Symbol('x')
y = sympy.Symbol('y')
z = sympy.Symbol('z')

θ1= sympy.Symbol('θ1')
θ2= sympy.Symbol('θ2')
Φ1= sympy.Symbol('Φ1')
Φ2= sympy.Symbol('Φ2')

θ= sympy.Symbol('θ')
Ψ= sympy.Symbol('Ψ')
Φ= sympy.Symbol('Φ')
pi=sympy.Symbol('pi')
E=sympy.Symbol('E')
I=sympy.Symbol('I')
sin=sympy.Symbol('sin')
cos=sympy.Symbol('cos')
tan=sympy.Symbol('tan')
diff=sympy.Symbol('diff')
integrate=sympy.Symbol('integrate')

pi=sympy.pi
E=sympy.E
sin=sympy.sin
cos=sympy.cos
tan=sympy.tan
diff=sympy.diff
integrate=sympy.integrate


def hin( fx1 ,fx2 ):
    fx = fx1

    #print("z ",z)

    # 拉普拉斯算符
    f1 = (1 / (r * r)) * diff((r * r * diff(fx, r)), r)

    f2 = (1 / (r * r * sin(θ))) * diff((sin(θ) * diff(fx, θ)), θ)

    f3 = (1 / (r * r * sin(θ) * sin(θ))) * diff(fx, Φ, Φ)

    f8 = fx2*(-1 / 2) * (f1 + f2 + f3)

    # print   (   f1 )
    # print   (   f2 )
    # print   (   f3 )

    # print    ( f8 )

    # 球坐标积分  动能
    f9 = (integrate((integrate(integrate(f8 * r * r * sin(θ), (r, 0, float('inf'))), (θ, 0, pi))), (Φ, 0, 2 * pi)))

    # print(f9)

    f10 = fx2 * (-z / r) * fx
    # 势能
    f11 = (integrate((integrate(integrate(f10 * r * r * sin(θ), (r, 0, float('inf'))), (θ, 0, pi))), (Φ, 0, 2 * pi)))

    # print(f11)
    #print("H", f9 + f11)

    return f9 + f11

def jin (fr1 ,fr2 ,k):


    f21 = fr1 * fr2 * (r2 ** k / r1 ** (k + 1)) * fr1 * fr2 * r1 * r1 * r2 * r2

    f22 = fr1 * fr2 * (r1 ** k / r2 ** (k + 1)) * fr1 * fr2 * r1 * r1 * r2 * r2

    f23 = (integrate(f21, (r2, 0, r1)))

    f24 = (integrate(f22, (r2, r1, float('inf'))))

    f25 = ( integrate(f24 + f23, (r1, 0, float('inf'))))

    # print("f23",f23)
    # print("f24",f24)

    #print( f25)

    return f25


def kin(fr1, fr2, fr3, fr4, k):
    # 交换积分
    # fr1 = (z) ** (1.5) * sympy.exp(-z * r1) * pi ** (-0.5)
    # fr2 = (z) ** (1.5) * sympy.exp(-z * r2) * pi ** (-0.5)

    # fr3 = (z) ** (1.5) * sympy.exp(-z * r2) * pi ** (-0.5)
    # fr4 = (z) ** (1.5) * sympy.exp(-z * r1) * pi ** (-0.5)

    f21 = fr1 * fr2 * (r2 ** k / r1 ** (k + 1)) * fr3 * fr4 * r1 * r1 * r2 * r2

    f22 = fr1 * fr2 * (r1 ** k / r2 ** (k + 1)) * fr3 * fr4 * r1 * r1 * r2 * r2

    f23 = (integrate(f21, (r2, 0, r1)))

    f24 = (integrate(f22, (r2, r1, float('inf'))))

    f36 = (integrate(f24 + f23, (r1, 0, float('inf'))))

    # print("f23",f23)
    # print("f24",f24)

    #print("K", f36)

    return f36


def sab (fr1 ,fr2 ):


    # print("f23",f23)
    # print("f24",f24)

    f9 = (integrate((integrate(integrate( fr1*fr2 * r * r * sin(θ), (r, 0, float('inf'))), (θ, 0, pi))), (Φ, 0, 2 * pi)))

    print("S", f9)

    return f9



z=5

a0=1
a1=4

#a0=1
#a1=4

'''
fx1=(z/a0)**(1.5)*2*sympy.exp(-z*r/a0  )*(4*pi)**(-0.5)
fx2=(z/( 2*a1))**(1.5)*(2-z*r/a1)*sympy.exp(-z*r/(2*a1)  )*(4*pi)**(-0.5)
fx3=(z/( 2*a1))**(1.5)*(z*r/(3**0.5*a1) )*sympy.exp(-z*r/(2*a1)  )*(3/(4*pi))**(0.5)* cos(θ)


# 库仑斥力积分
#fj1 = (z/a0)**(1.5)*2*sympy.exp(-z*r1/a0  )*(4*pi)**(-0.5)
#fj2 = (z/a0)**(1.5)*2*sympy.exp(-z*r2/a0  )*(4*pi)**(-0.5)
rj1 = (z/a0)**(1.5)*2*sympy.exp(-z*r1/a0  )
rj2 = (z/a0)**(1.5)*2*sympy.exp(-z*r2/a0  )

#fj3=(z/( 2*a1))**(1.5)*(2-z*r1/a1)*sympy.exp(-z*r1/(2*a1)  )*(4*pi)**(-0.5)
#fj4=(z/( 2*a1))**(1.5)*(2-z*r2/a1)*sympy.exp(-z*r2/(2*a1)  )*(4*pi)**(-0.5)
rj3=(z/( 2*a1))**(1.5)*(2-z*r1/a1)*sympy.exp(-z*r1/(2*a1)  )
rj4=(z/( 2*a1))**(1.5)*(2-z*r2/a1)*sympy.exp(-z*r2/(2*a1)  )

#fj5=(z/( 2*a1))**(1.5)*(z*r1/(3**0.5*a1) )*sympy.exp(-z*r1/(2*a1)  )*(3/(4*pi))**(0.5)* cos(θ)
#fj6=(z/( 2*a1))**(1.5)*(z*r2/(3**0.5*a1) )*sympy.exp(-z*r2/(2*a1)  )*(3/(4*pi))**(0.5)* cos(θ)
rj5=(z/( 2*a1))**(1.5)*(z*r1/(3**0.5*a1) )*sympy.exp(-z*r1/(2*a1)  )
rj6=(z/( 2*a1))**(1.5)*(z*r2/(3**0.5*a1) )*sympy.exp(-z*r2/(2*a1)  )
'''



f = csv.reader(open('d:/工业/hk/python/表达式.csv','r'))
for i in f:
    f2=(i)
    f2[0] = f2[0].replace("#", ",")
    d=(eval(f2[0]))
    print (  round( d,16 ) )

黑榆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
氦原子基态能级的探讨毕业论文正文.doc
09-18
本文是一篇关于氦原子基态能级探讨的毕业论文，主要研究内容是通过应用双参数变分法来计算氦原子的基态能量，并与实验值进行对比分析，同时与微扰法的结果进行比较，以此展示双参数变分法在解决此类问题上的优势。...
计算硼原子基态能级B---动能和势能
staple
10-06 909
设B原子核外5个电子的轨道分别是 这5个电子的主，角，磁量子数分别是(1,0,0), (1,0,0), (2,0,0), (2,0,0), (2,1,0). 硼原子的能量为 其中E1=E2，E3=E4， J13=J14=J23=J24，J15=J25，J34=J45， K13=K14=K23=K24，k15=K25，K35=K45 因此 其中动能+势能为 =2*（-12.5）+2*（-1.367）-1.367=-29.1 因此 double fh=hin(fx1...
高斯函数展开计算氢原子基态能量
wwxy1995的博客
07-07 2270
import numpy as np from scipy.linalg import eigh from math import pi import matplotlib.pyplot as plt a = [13.00773, 1.962079, 0.444529, 0.1219492] S = np.zeros([4,4]) T = np.zeros([4,4]) A = np.zeros...
python总结-第二章-基础数值与计算
⭐STARS⭐
08-12 299
#博文为教材《从python开始学编程》Vamei著 一书的读书笔记，干货内容并非博主原创 2-1.运算 1.数值运算 在python中能直接进行数值运算： 字符串加法运算： 2.逻辑运算 在二进制体系中，可以用1和0代表“真”和“假”两种状态。在python中，我们使用True和False两个关键字来表示真假，True和False这种数据被称为布尔值（Boolean）。 “...
教程：Python量子计算入门
zihong522的博客
09-07 2093
量子计算机可能听起来有点神秘而且远在未来，但实际上，现在可以在云端访问它们或通过仿真器为每个人编写量子代码。在本教程中，我们将介绍如何编写一个简单的量子计算机程序来产生随机数。 这是用Python进行量子计算系列教程的第一部分，并介绍了量子编程的基本原理。 DataEspresso量子计算系列教程的概述。 ● 第一部分：通过产生随机数开始量子计算（Python） ● 第二部分：使用量子隐形传态给鲍伯发送消息（Python） ● 第三部分：订阅我们的简讯以便通知您 这个示例可以在任何仿真器或量子计算机上完成。
氦原子基态能量的精确计算
02-21
氦原子基态能量的精确计算，程智，，本文通过虚光子的假设来解决氦原子以及类氦离子基态能量问题。在已有工作基础上，本文假设了在氦原子及类氦离子中，电子与电子、
锂原子基态能量的计算* (1995年)
05-08
用里兹变分法，通过数值计算，求出了锂原子的基态能量，结果和实验符合较好。
变分法计算H+2的基态能级 (2007年)
05-25
介绍了采用全关联的Hylleraas坐标下的变分波函数法这一新的方法计算少体分子离子的能量本征值问题，并且将之应用到H+2基态能级的数值计算上。将计算所得的结果和用其他各种方法计算所得的结果相比较，表明变分法计算...
计算氦原子的基态能量的一种方法 (1994年)
05-19
计算氦原子的基态能量的一种方法 (1994年)
Java内存模型
最新发布
weixin_44267758的博客
07-19 326
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 624
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 862
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
【Java算法】前缀和 下
2302_79806056的博客
07-18 911
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
【JAVA】相关程序组件
qq_44077764的博客
07-15 172
【JAVA】相关程序组件
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 510
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
构建自动化的精粹：Gradle任务依赖性与执行顺序控制
liuxin33445566的博客
07-15 587
本文以"构建自动化的精粹：Gradle任务依赖性与执行顺序控制"为题，详细介绍了任务依赖性的重要性、基本配置、多个任务的依赖性、条件依赖性、错误处理、高级用法、多项目构建中的任务依赖性。随着Gradle的不断发展，我们可以预见到更多关于任务依赖性和构建自动化的高级特性的出现，这将进一步扩展Gradle的构建能力，满足更复杂的项目构建需求。任务依赖性定义了任务之间的执行关系，确保了在构建过程中，任务能够按照预期的顺序执行。任务是一个特殊的任务，它默认依赖于所有没有显式排除的任务。方法来指定任务的依赖性。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 532
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
Java实验2
qq_64727229的博客
07-16 521
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
每 日练 习
m0_67187271的博客
07-19 501
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
python氢原子能级
06-18
氢原子的基态（最低能量状态）的能级是-13.6电子伏特(eV)，对应于n=1（主量子数n=1的能级）。随着能级n的增加，能量逐渐升高，按照公式E = -13.6/n^2 eV计算，其中n = 2, 3, 4...。例如，n=2的能量为-3.4 eV（或称为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黑榆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值