Java实现Lagan法射线追踪(lagan.java)

import java.io.*;

class laganRayTracing{

        private float pi = 3.141592653f;

        private int nx,nz,nshot,nray,ngrid;
        private float dx,dz,s,dangle,fangle;

        private float[] v0;

        private String raypath;

        laganRayTracing(){
                
                nx = nz = 301;
                dx = dz = 5f;
                s = 0.5f;
                fangle = 0f;
                dangle = 4f;
                nray = 2;
                ngrid = nx * nz;

                raypath = "raypath.txt";

                v0 = new float [ngrid];
                for(int i=0;i<ngrid;i++){
                        v0[i] = 2000.0f;
                        if(i>150*nz)v0[i] = 3000f;
                    }
          }
        public void makeRay()throws java.io.IOException{

                float p_x,p_z,n_x,n_z,l_x,l_z;
                float p_xend,p_zend;
                float n_xnew,n_znew;

                float p_x0, p_z0, dip;

                int ip_lux,ip_ldx,ip_rux,ip_rdx;
                int ip_luz,ip_ldz,ip_ruz,ip_rdz;
                int irayon,ishot;

                float angle,time,v;

                p_x0 = (nx-1)*dx / 3;
                p_z0 = (nz-1)*dz / 2;

                p_x = p_x0;
                p_z = p_z0;

                Writer rayfp = new FileWriter(raypath);

                for(int iray = 0; iray < nray; iray++){

                        p_x = p_x0;
                        p_z = p_z0;

                        angle = fangle + iray*dangle;
                        angle = angle*pi/180.0f;
        
                        //System.out.println(angle);

                        n_x = (float)Math.cos(angle);
                        n_z = (float)Math.sin(angle);

                        time = 0.0f;


                        do{
                                /* cal_gridpoint */
                                ip_lux = (int)(p_x/dx);
                                ip_luz = (int)(p_z/dz);

                                ip_ldx = ip_lux;
                                ip_ldz = ip_luz+1;

                                ip_rux = ip_lux+1;
                                ip_ruz = ip_luz;

                                ip_rdx = ip_lux+1;
                                ip_rdz = ip_luz+1;


                                /* cal_gridvel */
                                float l_x1 = (v0[ip_rux*nz + ip_ruz]-v0[ip_lux*nz + ip_luz])/dx;
                                float l_x2 = (v0[ip_rdx*nz + ip_rdz]-v0[ip_ldx*nz + ip_ldz])/dx;
                                l_x = ( l_x1+l_x2 ) / 2.0f;

                                float l_z1=(v0[ip_ldx*nz + ip_ldz]-v0[ip_lux*nz + ip_luz])/dz;
                                float l_z2=(v0[ip_rdx*nz + ip_rdz]-v0[ip_rux*nz + ip_ruz])/dz;
                                l_z=(l_z1+l_z2)/2.0f;

                                v=v0[ip_rux*nz + ip_ruz]+v0[ip_lux*nz + ip_luz]+v0[ip_rdx*nz + ip_rdz]
                                        +v0[ip_ldx*nz + ip_ldz];
                                v=v/4.0f;

                                //System.out.println(v);

                                /* cal_path */
                                float dotmult_ln=l_x*n_x+l_z*n_z;
                                float dotmult_ll=l_x*l_x+l_z*l_z;
                                p_xend=p_x+n_x*s*(1f+dotmult_ln*0.5f*s/v)-0.5f*l_x*s*s/v
                                        -n_x*s*s*s*(dotmult_ll-dotmult_ln*dotmult_ln)/(6.0f*v*v);

                                p_zend=p_z+n_z*s*(1f+dotmult_ln*0.5f*s/v)-0.5f*l_z*s*s/v
                                        -n_z*s*s*s*(dotmult_ll-dotmult_ln*dotmult_ln)/(6.0f*v*v);

                                n_xnew=n_x*(1f+dotmult_ln*s/v)-l_x*s/v
                                        -n_x*s*s*(dotmult_ll-dotmult_ln*dotmult_ln)/(2.0f*v*v);

                                n_znew=n_z*(1f+dotmult_ln*s/v)-l_z*s/v
                                        -n_z*s*s*(dotmult_ll-dotmult_ln*dotmult_ln)/(2.0f*v*v);

                                time+=s/v*(1f+s*s*(dotmult_ll+dotmult_ln*dotmult_ln)
                                        /(6f*v*v)-dotmult_ln*s/(2f*v));

                                /* buffer */
                                p_x = p_xend;
                                p_z = p_zend;
                                n_x = n_xnew;
                                n_z = n_znew;

                                rayfp.write(p_x+"         "+p_z+"        \n");
                                //System.out.println(p_x+"         "+p_z+"        ");
                        
                        }while((p_xend>=0.0f)&&(p_xend<((nx-1f)*dx))&&(p_zend>=0.0f)&&(p_zend<(nz-1f)*dz));

                        rayfp.write("-999999.9      -999999.9   \n");
                    }
                rayfp.close();
          }

        public static void main(String[]args)throws java.io.IOException{
        
                laganRayTracing l = new laganRayTracing();
                l.makeRay();
          }
}

已标记关键词 清除标记
相关推荐
课程简介: 历经半个多月的时间,Debug亲自撸的 “企业员工角色权限管理平台” 终于完成了。正如字面意思,本课程讲解的是一个真正意义上的、企业级的项目实战,主要介绍了企业级应用系统中后端应用权限的管理,其中主要涵盖了六大核心业务模块、十几张数据库表。 其中的核心业务模块主要包括用户模块、部门模块、岗位模块、角色模块、菜单模块和系统日志模块;与此同时,Debug还亲自撸了额外的附属模块,包括字典管理模块、商品分类模块以及考勤管理模块等等,主要是为了更好地巩固相应的技术栈以及企业应用系统业务模块的开发流程! 核心技术栈列表: 值得介绍的是,本课程在技术栈层面涵盖了前端和后端的大部分常用技术,包括Spring Boot、Spring MVC、Mybatis、Mybatis-Plus、Shiro(身份认证与资源授权跟会话等等)、Spring AOP、防止XSS攻击、防止SQL注入攻击、过滤器Filter、验证码Kaptcha、热部署插件Devtools、POI、Vue、LayUI、ElementUI、JQuery、HTML、Bootstrap、Freemarker、一键打包部署运行工具Wagon等等,如下图所示: 课程内容与收益: 总的来说,本课程是一门具有很强实践性质的“项目实战”课程,即“企业应用员工角色权限管理平台”,主要介绍了当前企业级应用系统中员工、部门、岗位、角色、权限、菜单以及其他实体模块的管理;其中,还重点讲解了如何基于Shiro的资源授权实现员工-角色-操作权限、员工-角色-数据权限的管理;在课程的最后,还介绍了如何实现一键打包上传部署运行项目等等。如下图所示为本权限管理平台的数据库设计图: 以下为项目整体的运行效果截图: 值得一提的是,在本课程中,Debug也向各位小伙伴介绍了如何在企业级应用系统业务模块的开发中,前端到后端再到数据库,最后再到服务器的上线部署运行等流程,如下图所示:
©️2020 CSDN 皮肤主题: 酷酷鲨 设计师:CSDN官方博客 返回首页