Révision 224 TrouNoir/TrouNoir.py
| TrouNoir.py (revision 224) | ||
|---|---|---|
| 46 | 46 |
#define EINSTEIN 0 |
| 47 | 47 |
#define NEWTON 1 |
| 48 | 48 |
|
| 49 |
#ifdef SETTRACKPOINTS |
|
| 50 |
#define TRACKPOINTS SETTRACKPOINTS |
|
| 51 |
#else |
|
| 49 | 52 |
#define TRACKPOINTS 2048 |
| 53 |
#endif |
|
| 50 | 54 |
|
| 51 | 55 |
float atanp(float x,float y) |
| 52 | 56 |
{
|
| ... | ... | |
| 297 | 301 |
|
| 298 | 302 |
__kernel void Pixel(__global float *zImage,__global float *fImage, |
| 299 | 303 |
__global float *Trajectories,__global int *IdLast, |
| 300 |
uint ImpactParameter,uint TrackPoints,
|
|
| 304 |
uint ImpactParameter, |
|
| 301 | 305 |
float Mass,float InternalRadius, |
| 302 | 306 |
float ExternalRadius,float Angle, |
| 303 | 307 |
int Line) |
| ... | ... | |
| 329 | 333 |
bmx=1.25*re; |
| 330 | 334 |
|
| 331 | 335 |
// Angular step of integration |
| 332 |
h=4.e0f*PI/(float)TrackPoints;
|
|
| 336 |
h=4.e0f*PI/(float)TRACKPOINTS;
|
|
| 333 | 337 |
|
| 334 | 338 |
// Step of Impact Parameter |
| 335 | 339 |
db=bmx/(2.e0*(float)ImpactParameter); |
| ... | ... | |
| 360 | 364 |
|
| 361 | 365 |
if (ni<IdLast[bi]) |
| 362 | 366 |
{
|
| 363 |
r=(Trajectories[bi*TrackPoints+ni+1]-Trajectories[bi*TrackPoints+ni])*(nr-ni*1.)+Trajectories[bi*TrackPoints+ni];
|
|
| 367 |
r=(Trajectories[bi*TRACKPOINTS+ni+1]-Trajectories[bi*TRACKPOINTS+ni])*(nr-ni*1.)+Trajectories[bi*TRACKPOINTS+ni];
|
|
| 364 | 368 |
} |
| 365 | 369 |
else |
| 366 | 370 |
{
|
| 367 |
r=Trajectories[bi*TrackPoints+ni];
|
|
| 371 |
r=Trajectories[bi*TRACKPOINTS+ni];
|
|
| 368 | 372 |
} |
| 369 | 373 |
|
| 370 | 374 |
if ((r<=re)&&(r>=ri)) |
| ... | ... | |
| 386 | 390 |
|
| 387 | 391 |
__kernel void Circle(__global float *Trajectories,__global int *IdLast, |
| 388 | 392 |
__global float *zImage,__global float *fImage, |
| 389 |
int TrackPoints, |
|
| 390 | 393 |
float Mass,float InternalRadius, |
| 391 | 394 |
float ExternalRadius,float Angle, |
| 392 | 395 |
int Line) |
| ... | ... | |
| 421 | 424 |
bmx=1.25*re; |
| 422 | 425 |
|
| 423 | 426 |
// Angular step of integration |
| 424 |
h=4.e0f*PI/(float)TrackPoints;
|
|
| 427 |
h=4.e0f*PI/(float)TRACKPOINTS;
|
|
| 425 | 428 |
|
| 426 | 429 |
// impact parameter |
| 427 | 430 |
b=(float)bi/(float)bmaxi*bmx; |
| 428 |
db=bmx/(2.e0*(float)bmaxi); |
|
| 431 |
db=bmx/(2.e0f*(float)bmaxi);
|
|
| 429 | 432 |
|
| 430 | 433 |
phi=2.*PI/(float)imx*(float)i; |
| 431 | 434 |
phd=atanp(cos(phi)*sin(tho),cos(tho)); |
| ... | ... | |
| 443 | 446 |
|
| 444 | 447 |
if (ni<IdLast[bi]) |
| 445 | 448 |
{
|
| 446 |
r=(Trajectories[bi*TrackPoints+ni+1]-Trajectories[bi*TrackPoints+ni])*(nr-ni*1.)+Trajectories[bi*TrackPoints+ni];
|
|
| 449 |
r=(Trajectories[bi*TRACKPOINTS+ni+1]-Trajectories[bi*TRACKPOINTS+ni])*(nr-ni*1.)+Trajectories[bi*TRACKPOINTS+ni];
|
|
| 447 | 450 |
} |
| 448 | 451 |
else |
| 449 | 452 |
{
|
| 450 |
r=Trajectories[bi*TrackPoints+ni];
|
|
| 453 |
r=Trajectories[bi*TRACKPOINTS+ni];
|
|
| 451 | 454 |
} |
| 452 | 455 |
|
| 453 | 456 |
if ((r<=re)&&(r>=ri)) |
| ... | ... | |
| 466 | 469 |
|
| 467 | 470 |
} |
| 468 | 471 |
|
| 469 |
__kernel void Trajectory(__global float *Trajectories, |
|
| 470 |
__global int *IdLast,int TrackPoints, |
|
| 472 |
__kernel void Trajectory(__global float *Trajectories,__global int *IdLast, |
|
| 471 | 473 |
float Mass,float InternalRadius, |
| 472 | 474 |
float ExternalRadius,float Angle, |
| 473 | 475 |
int Line) |
| ... | ... | |
| 479 | 481 |
|
| 480 | 482 |
// Perform trajectory for each pixel |
| 481 | 483 |
|
| 484 |
float m,rs,re; |
|
| 485 |
|
|
| 486 |
m=Mass; |
|
| 487 |
rs=2.*m; |
|
| 488 |
re=ExternalRadius; |
|
| 489 |
|
|
| 490 |
float bmx,b,h; |
|
| 491 |
int nh; |
|
| 492 |
|
|
| 493 |
// Autosize for image |
|
| 494 |
bmx=1.25*re; |
|
| 495 |
|
|
| 496 |
// Angular step of integration |
|
| 497 |
h=4.e0f*PI/(float)TRACKPOINTS; |
|
| 498 |
|
|
| 499 |
// impact parameter |
|
| 500 |
b=(float)bi/(float)bmaxi*bmx; |
|
| 501 |
|
|
| 502 |
float up,vp,pp,us,vs,ps; |
|
| 503 |
|
|
| 504 |
up=0.; |
|
| 505 |
vp=1.; |
|
| 506 |
|
|
| 507 |
pp=0.; |
|
| 508 |
nh=0; |
|
| 509 |
|
|
| 510 |
rungekutta(&ps,&us,&vs,pp,up,vp,h,m,b); |
|
| 511 |
|
|
| 512 |
// b versus us |
|
| 513 |
float bvus=fabs(b/us); |
|
| 514 |
float bvus0=bvus; |
|
| 515 |
Trajectories[bi*TRACKPOINTS+nh]=bvus; |
|
| 516 |
|
|
| 517 |
do |
|
| 518 |
{
|
|
| 519 |
nh++; |
|
| 520 |
pp=ps; |
|
| 521 |
up=us; |
|
| 522 |
vp=vs; |
|
| 523 |
rungekutta(&ps,&us,&vs,pp,up,vp,h,m,b); |
|
| 524 |
bvus=fabs(b/us); |
|
| 525 |
Trajectories[bi*TRACKPOINTS+nh]=bvus; |
|
| 526 |
|
|
| 527 |
} while ((bvus>=rs)&&(bvus<=bvus0)); |
|
| 528 |
|
|
| 529 |
IdLast[bi]=nh; |
|
| 530 |
|
|
| 531 |
barrier(CLK_GLOBAL_MEM_FENCE); |
|
| 532 |
|
|
| 533 |
} |
|
| 534 |
|
|
| 535 |
__kernel void Original(__global float *zImage,__global float *fImage, |
|
| 536 |
float Mass,float InternalRadius, |
|
| 537 |
float ExternalRadius,float Angle, |
|
| 538 |
int Line) |
|
| 539 |
{
|
|
| 540 |
// Integer Impact Parameter ID |
|
| 541 |
int bi=get_global_id(0); |
|
| 542 |
// Integer Impact Parameter Size (half of image) |
|
| 543 |
int bmaxi=get_global_size(0); |
|
| 544 |
|
|
| 545 |
float Trajectories[2048]; |
|
| 546 |
|
|
| 547 |
// Perform trajectory for each pixel |
|
| 548 |
|
|
| 482 | 549 |
float m,rs,ri,re,tho; |
| 483 | 550 |
int raie,q; |
| 484 | 551 |
|
| ... | ... | |
| 490 | 557 |
q=-2; |
| 491 | 558 |
raie=Line; |
| 492 | 559 |
|
| 493 |
float d,bmx,db,b,h; |
|
| 494 |
float phi,thi,phd,php,nr,r; |
|
| 560 |
float bmx,db,b,h; |
|
| 495 | 561 |
int nh; |
| 496 |
float zp,fp; |
|
| 497 | 562 |
|
| 498 | 563 |
// Autosize for image |
| 499 |
bmx=1.25*re; |
|
| 564 |
bmx=1.25e0f*re;
|
|
| 500 | 565 |
|
| 501 | 566 |
// Angular step of integration |
| 502 |
h=4.e0f*PI/(float)TrackPoints;
|
|
| 567 |
h=4.e0f*PI/(float)TRACKPOINTS;
|
|
| 503 | 568 |
|
| 504 | 569 |
// impact parameter |
| 505 | 570 |
b=(float)bi/(float)bmaxi*bmx; |
| 571 |
db=bmx/(2.e0f*(float)bmaxi); |
|
| 506 | 572 |
|
| 507 | 573 |
float up,vp,pp,us,vs,ps; |
| 508 | 574 |
|
| ... | ... | |
| 517 | 583 |
// b versus us |
| 518 | 584 |
float bvus=fabs(b/us); |
| 519 | 585 |
float bvus0=bvus; |
| 520 |
Trajectories[bi*TrackPoints+nh]=bvus;
|
|
| 586 |
Trajectories[nh]=bvus; |
|
| 521 | 587 |
|
| 522 | 588 |
do |
| 523 | 589 |
{
|
| ... | ... | |
| 527 | 593 |
vp=vs; |
| 528 | 594 |
rungekutta(&ps,&us,&vs,pp,up,vp,h,m,b); |
| 529 | 595 |
bvus=fabs(b/us); |
| 530 |
Trajectories[bi*TrackPoints+nh]=bvus;
|
|
| 596 |
Trajectories[nh]=bvus; |
|
| 531 | 597 |
|
| 532 | 598 |
} while ((bvus>=rs)&&(bvus<=bvus0)); |
| 533 | 599 |
|
| 534 |
IdLast[bi]=nh;
|
|
| 600 |
int imx=(int)(16*bi);
|
|
| 535 | 601 |
|
| 602 |
for (int i=0;i<imx;i++) |
|
| 603 |
{
|
|
| 604 |
float zp=0,fp=0; |
|
| 605 |
float phi=2.*PI/(float)imx*(float)i; |
|
| 606 |
float phd=atanp(cos(phi)*sin(tho),cos(tho)); |
|
| 607 |
uint yi=(uint)((float)bi*sin(phi)+bmaxi); |
|
| 608 |
uint xi=(uint)((float)bi*cos(phi)+bmaxi); |
|
| 609 |
|
|
| 610 |
int HalfLap=0,ExitOnImpact=0,ni; |
|
| 611 |
float php,nr,r; |
|
| 612 |
|
|
| 613 |
do |
|
| 614 |
{
|
|
| 615 |
php=phd+(float)HalfLap*PI; |
|
| 616 |
nr=php/h; |
|
| 617 |
ni=(int)nr; |
|
| 618 |
|
|
| 619 |
if (ni<nh) |
|
| 620 |
{
|
|
| 621 |
r=(Trajectories[ni+1]-Trajectories[ni])*(nr-ni*1.)+Trajectories[ni]; |
|
| 622 |
} |
|
| 623 |
else |
|
| 624 |
{
|
|
| 625 |
r=Trajectories[ni]; |
|
| 626 |
} |
|
| 627 |
|
|
| 628 |
if ((r<=re)&&(r>=ri)) |
|
| 629 |
{
|
|
| 630 |
ExitOnImpact=1; |
|
| 631 |
impact(phi,r,b,tho,m,&zp,&fp,q,db,h,raie); |
|
| 632 |
} |
|
| 633 |
|
|
| 634 |
HalfLap++; |
|
| 635 |
|
|
| 636 |
} while ((HalfLap<=2)&&(ExitOnImpact==0)); |
|
| 637 |
|
|
| 638 |
zImage[yi+2*bmaxi*xi]=zp; |
|
| 639 |
fImage[yi+2*bmaxi*xi]=fp; |
|
| 640 |
|
|
| 641 |
} |
|
| 642 |
|
|
| 536 | 643 |
barrier(CLK_GLOBAL_MEM_FENCE); |
| 537 | 644 |
|
| 538 | 645 |
} |
| ... | ... | |
| 547 | 654 |
#define EINSTEIN 0 |
| 548 | 655 |
#define NEWTON 1 |
| 549 | 656 |
|
| 550 |
#define TRACKPOINTS 2048 |
|
| 657 |
#ifdef SETTRACKPOINTS |
|
| 658 |
#define TRACKPOINTS SETTRACKPOINTS |
|
| 659 |
#else |
|
| 660 |
#define TRACKPOINTS |
|
| 661 |
#endif |
|
| 551 | 662 |
|
| 552 | 663 |
__device__ float nothing(float x) |
| 553 | 664 |
{
|
| ... | ... | |
| 804 | 915 |
|
| 805 | 916 |
__global__ void Pixel(float *zImage,float *fImage, |
| 806 | 917 |
float *Trajectories,int *IdLast, |
| 807 |
uint ImpactParameter,uint TrackPoints,
|
|
| 918 |
uint ImpactParameter, |
|
| 808 | 919 |
float Mass,float InternalRadius, |
| 809 | 920 |
float ExternalRadius,float Angle, |
| 810 | 921 |
int Line) |
| ... | ... | |
| 835 | 946 |
bmx=1.25*re; |
| 836 | 947 |
|
| 837 | 948 |
// Angular step of integration |
| 838 |
h=4.e0f*PI/(float)TrackPoints;
|
|
| 949 |
h=4.e0f*PI/(float)TRACKPOINTS;
|
|
| 839 | 950 |
|
| 840 | 951 |
// Step of Impact Parameter |
| 841 | 952 |
db=bmx/(2.e0*(float)ImpactParameter); |
| ... | ... | |
| 865 | 976 |
|
| 866 | 977 |
if (ni<IdLast[bi]) |
| 867 | 978 |
{
|
| 868 |
r=(Trajectories[bi*TrackPoints+ni+1]-Trajectories[bi*TrackPoints+ni])*(nr-ni*1.)+Trajectories[bi*TrackPoints+ni];
|
|
| 979 |
r=(Trajectories[bi*TRACKPOINTS+ni+1]-Trajectories[bi*TRACKPOINTS+ni])*(nr-ni*1.)+Trajectories[bi*TRACKPOINTS+ni];
|
|
| 869 | 980 |
} |
| 870 | 981 |
else |
| 871 | 982 |
{
|
| 872 |
r=Trajectories[bi*TrackPoints+ni];
|
|
| 983 |
r=Trajectories[bi*TRACKPOINTS+ni];
|
|
| 873 | 984 |
} |
| 874 | 985 |
|
| 875 | 986 |
if ((r<=re)&&(r>=ri)) |
| ... | ... | |
| 889 | 1000 |
|
| 890 | 1001 |
__global__ void Circle(float *Trajectories,int *IdLast, |
| 891 | 1002 |
float *zImage,float *fImage, |
| 892 |
int TrackPoints, |
|
| 893 | 1003 |
float Mass,float InternalRadius, |
| 894 | 1004 |
float ExternalRadius,float Angle, |
| 895 | 1005 |
int Line) |
| ... | ... | |
| 924 | 1034 |
bmx=1.25*re; |
| 925 | 1035 |
|
| 926 | 1036 |
// Angular step of integration |
| 927 |
h=4.e0f*PI/(float)TrackPoints;
|
|
| 1037 |
h=4.e0f*PI/(float)TRACKPOINTS;
|
|
| 928 | 1038 |
|
| 929 | 1039 |
// impact parameter |
| 930 | 1040 |
b=(float)bi/(float)bmaxi*bmx; |
| ... | ... | |
| 946 | 1056 |
|
| 947 | 1057 |
if (ni<IdLast[bi]) |
| 948 | 1058 |
{
|
| 949 |
r=(Trajectories[bi*TrackPoints+ni+1]-Trajectories[bi*TrackPoints+ni])*(nr-ni*1.)+Trajectories[bi*TrackPoints+ni];
|
|
| 1059 |
r=(Trajectories[bi*TRACKPOINTS+ni+1]-Trajectories[bi*TRACKPOINTS+ni])*(nr-ni*1.)+Trajectories[bi*TRACKPOINTS+ni];
|
|
| 950 | 1060 |
} |
| 951 | 1061 |
else |
| 952 | 1062 |
{
|
| 953 |
r=Trajectories[bi*TrackPoints+ni];
|
|
| 1063 |
r=Trajectories[bi*TRACKPOINTS+ni];
|
|
| 954 | 1064 |
} |
| 955 | 1065 |
|
| 956 | 1066 |
if ((r<=re)&&(r>=ri)) |
| ... | ... | |
| 967 | 1077 |
|
| 968 | 1078 |
} |
| 969 | 1079 |
|
| 970 |
__global__ void Trajectory(float *Trajectories, |
|
| 971 |
int *IdLast,int TrackPoints, |
|
| 1080 |
__global__ void Trajectory(float *Trajectories,int *IdLast, |
|
| 972 | 1081 |
float Mass,float InternalRadius, |
| 973 | 1082 |
float ExternalRadius,float Angle, |
| 974 | 1083 |
int Line) |
| ... | ... | |
| 1000 | 1109 |
bmx=1.25*re; |
| 1001 | 1110 |
|
| 1002 | 1111 |
// Angular step of integration |
| 1003 |
h=4.e0f*PI/(float)TrackPoints;
|
|
| 1112 |
h=4.e0f*PI/(float)TRACKPOINTS;
|
|
| 1004 | 1113 |
|
| 1005 | 1114 |
// impact parameter |
| 1006 | 1115 |
b=(float)bi/(float)bmaxi*bmx; |
| ... | ... | |
| 1018 | 1127 |
// b versus us |
| 1019 | 1128 |
float bvus=fabs(b/us); |
| 1020 | 1129 |
float bvus0=bvus; |
| 1021 |
Trajectories[bi*TrackPoints+nh]=bvus;
|
|
| 1130 |
Trajectories[bi*TRACKPOINTS+nh]=bvus;
|
|
| 1022 | 1131 |
|
| 1023 | 1132 |
do |
| 1024 | 1133 |
{
|
| ... | ... | |
| 1028 | 1137 |
vp=vs; |
| 1029 | 1138 |
rungekutta(&ps,&us,&vs,pp,up,vp,h,m,b); |
| 1030 | 1139 |
bvus=fabs(b/us); |
| 1031 |
Trajectories[bi*TrackPoints+nh]=bvus;
|
|
| 1140 |
Trajectories[bi*TRACKPOINTS+nh]=bvus;
|
|
| 1032 | 1141 |
|
| 1033 | 1142 |
} while ((bvus>=rs)&&(bvus<=bvus0)); |
| 1034 | 1143 |
|
| 1035 | 1144 |
IdLast[bi]=nh; |
| 1036 | 1145 |
|
| 1037 | 1146 |
} |
| 1147 |
|
|
| 1148 |
__global__ void Original(float *zImage,float *fImage, |
|
| 1149 |
float Mass,float InternalRadius, |
|
| 1150 |
float ExternalRadius,float Angle, |
|
| 1151 |
int Line) |
|
| 1152 |
{
|
|
| 1153 |
// Integer Impact Parameter ID |
|
| 1154 |
int bi=blockIdx.x*blockDim.x+threadIdx.x; |
|
| 1155 |
|
|
| 1156 |
// Integer Impact Parameter Size (half of image) |
|
| 1157 |
int bmaxi=gridDim.x*blockDim.x; |
|
| 1158 |
|
|
| 1159 |
float Trajectories[2048]; |
|
| 1160 |
|
|
| 1161 |
// Perform trajectory for each pixel |
|
| 1162 |
|
|
| 1163 |
float m,rs,ri,re,tho; |
|
| 1164 |
int raie,q; |
|
| 1165 |
|
|
| 1166 |
m=Mass; |
|
| 1167 |
rs=2.*m; |
|
| 1168 |
ri=InternalRadius; |
|
| 1169 |
re=ExternalRadius; |
|
| 1170 |
tho=Angle; |
|
| 1171 |
q=-2; |
|
| 1172 |
raie=Line; |
|
| 1173 |
|
|
| 1174 |
float bmx,db,b,h; |
|
| 1175 |
int nh; |
|
| 1176 |
|
|
| 1177 |
// Autosize for image |
|
| 1178 |
bmx=1.25e0f*re; |
|
| 1179 |
|
|
| 1180 |
// Angular step of integration |
|
| 1181 |
h=4.e0f*PI/(float)TRACKPOINTS; |
|
| 1182 |
|
|
| 1183 |
// impact parameter |
|
| 1184 |
b=(float)bi/(float)bmaxi*bmx; |
|
| 1185 |
db=bmx/(2.e0f*(float)bmaxi); |
|
| 1186 |
|
|
| 1187 |
float up,vp,pp,us,vs,ps; |
|
| 1188 |
|
|
| 1189 |
up=0.; |
|
| 1190 |
vp=1.; |
|
| 1191 |
|
|
| 1192 |
pp=0.; |
|
| 1193 |
nh=0; |
|
| 1194 |
|
|
| 1195 |
rungekutta(&ps,&us,&vs,pp,up,vp,h,m,b); |
|
| 1196 |
|
|
| 1197 |
// b versus us |
|
| 1198 |
float bvus=fabs(b/us); |
|
| 1199 |
float bvus0=bvus; |
|
| 1200 |
Trajectories[nh]=bvus; |
|
| 1201 |
|
|
| 1202 |
do |
|
| 1203 |
{
|
|
| 1204 |
nh++; |
|
| 1205 |
pp=ps; |
|
| 1206 |
up=us; |
|
| 1207 |
vp=vs; |
|
| 1208 |
rungekutta(&ps,&us,&vs,pp,up,vp,h,m,b); |
|
| 1209 |
bvus=fabs(b/us); |
|
| 1210 |
Trajectories[nh]=bvus; |
|
| 1211 |
|
|
| 1212 |
} while ((bvus>=rs)&&(bvus<=bvus0)); |
|
| 1213 |
|
|
| 1214 |
int imx=(int)(16*bi); |
|
| 1215 |
|
|
| 1216 |
for (int i=0;i<imx;i++) |
|
| 1217 |
{
|
|
| 1218 |
float zp=0,fp=0; |
|
| 1219 |
float phi=2.*PI/(float)imx*(float)i; |
|
| 1220 |
float phd=atanp(cos(phi)*sin(tho),cos(tho)); |
|
| 1221 |
uint yi=(uint)((float)bi*sin(phi)+bmaxi); |
|
| 1222 |
uint xi=(uint)((float)bi*cos(phi)+bmaxi); |
|
| 1223 |
|
|
| 1224 |
int HalfLap=0,ExitOnImpact=0,ni; |
|
| 1225 |
float php,nr,r; |
|
| 1226 |
|
|
| 1227 |
do |
|
| 1228 |
{
|
|
| 1229 |
php=phd+(float)HalfLap*PI; |
|
| 1230 |
nr=php/h; |
|
| 1231 |
ni=(int)nr; |
|
| 1232 |
|
|
| 1233 |
if (ni<nh) |
|
| 1234 |
{
|
|
| 1235 |
r=(Trajectories[ni+1]-Trajectories[ni])*(nr-ni*1.)+Trajectories[ni]; |
|
| 1236 |
} |
|
| 1237 |
else |
|
| 1238 |
{
|
|
| 1239 |
r=Trajectories[ni]; |
|
| 1240 |
} |
|
| 1241 |
|
|
| 1242 |
if ((r<=re)&&(r>=ri)) |
|
| 1243 |
{
|
|
| 1244 |
ExitOnImpact=1; |
|
| 1245 |
impact(phi,r,b,tho,m,&zp,&fp,q,db,h,raie); |
|
| 1246 |
} |
|
| 1247 |
|
|
| 1248 |
HalfLap++; |
|
| 1249 |
|
|
| 1250 |
} while ((HalfLap<=2)&&(ExitOnImpact==0)); |
|
| 1251 |
|
|
| 1252 |
__syncthreads(); |
|
| 1253 |
|
|
| 1254 |
zImage[yi+2*bmaxi*xi]=zp; |
|
| 1255 |
fImage[yi+2*bmaxi*xi]=fp; |
|
| 1256 |
|
|
| 1257 |
} |
|
| 1258 |
|
|
| 1259 |
} |
|
| 1038 | 1260 |
""" |
| 1039 | 1261 |
return(BlobCUDA) |
| 1040 | 1262 |
|
| ... | ... | |
| 1110 | 1332 |
|
| 1111 | 1333 |
# BlackHoleCL = cl.Program(ctx,KERNEL_CODE.substitute(kernel_params)).build() |
| 1112 | 1334 |
|
| 1113 |
BuildOptions="-cl-mad-enable -DPHYSICS=%i " % (PhysicsList[Physics])
|
|
| 1335 |
BuildOptions="-cl-mad-enable -DPHYSICS=%i -DSETTRACKPOINTS=%i " % (PhysicsList[Physics],InputCL['TrackPoints'])
|
|
| 1114 | 1336 |
|
| 1115 | 1337 |
BlackHoleCL = cl.Program(ctx,BlobOpenCL).build(options = BuildOptions) |
| 1116 | 1338 |
|
| ... | ... | |
| 1133 | 1355 |
numpy.float32(Angle), |
| 1134 | 1356 |
numpy.int32(Line)) |
| 1135 | 1357 |
CLLaunch.wait() |
| 1358 |
elif Method=='Original': |
|
| 1359 |
CLLaunch=BlackHoleCL.Original(queue,(zImage.shape[0]/2,), |
|
| 1360 |
None,zImageCL,fImageCL, |
|
| 1361 |
numpy.float32(Mass), |
|
| 1362 |
numpy.float32(InternalRadius), |
|
| 1363 |
numpy.float32(ExternalRadius), |
|
| 1364 |
numpy.float32(Angle), |
|
| 1365 |
numpy.int32(Line)) |
|
| 1366 |
CLLaunch.wait() |
|
| 1136 | 1367 |
elif Method=='TrajectoCircle': |
| 1137 | 1368 |
CLLaunch=BlackHoleCL.Trajectory(queue,(Trajectories.shape[0],), |
| 1138 | 1369 |
None,TrajectoriesCL,IdLastCL, |
| 1139 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1140 | 1370 |
numpy.float32(Mass), |
| 1141 | 1371 |
numpy.float32(InternalRadius), |
| 1142 | 1372 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1147 | 1377 |
zImage.shape[0]*4),None, |
| 1148 | 1378 |
TrajectoriesCL,IdLastCL, |
| 1149 | 1379 |
zImageCL,fImageCL, |
| 1150 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1151 | 1380 |
numpy.float32(Mass), |
| 1152 | 1381 |
numpy.float32(InternalRadius), |
| 1153 | 1382 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1157 | 1386 |
else: |
| 1158 | 1387 |
CLLaunch=BlackHoleCL.Trajectory(queue,(Trajectories.shape[0],), |
| 1159 | 1388 |
None,TrajectoriesCL,IdLastCL, |
| 1160 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1161 | 1389 |
numpy.float32(Mass), |
| 1162 | 1390 |
numpy.float32(InternalRadius), |
| 1163 | 1391 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1168 | 1396 |
zImage.shape[1]),None, |
| 1169 | 1397 |
zImageCL,fImageCL,TrajectoriesCL,IdLastCL, |
| 1170 | 1398 |
numpy.uint32(Trajectories.shape[0]), |
| 1171 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1172 | 1399 |
numpy.float32(Mass), |
| 1173 | 1400 |
numpy.float32(InternalRadius), |
| 1174 | 1401 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1246 | 1473 |
Context=XPU.make_context() |
| 1247 | 1474 |
|
| 1248 | 1475 |
try: |
| 1249 |
mod = SourceModule(KernelCodeCuda(),options=['--compiler-options','-DPHYSICS=%i' % (PhysicsList[Physics])])
|
|
| 1476 |
mod = SourceModule(KernelCodeCuda(),options=['--compiler-options','-DPHYSICS=%i -DSETTRACKPOINTS=%i' % (PhysicsList[Physics],TrackPoints)])
|
|
| 1250 | 1477 |
print("Compilation seems to be OK")
|
| 1251 | 1478 |
except: |
| 1252 | 1479 |
print("Compilation seems to break")
|
| 1253 | 1480 |
|
| 1254 | 1481 |
EachPixelCU=mod.get_function("EachPixel")
|
| 1482 |
OriginalCU=mod.get_function("Original")
|
|
| 1255 | 1483 |
TrajectoryCU=mod.get_function("Trajectory")
|
| 1256 | 1484 |
PixelCU=mod.get_function("Pixel")
|
| 1257 | 1485 |
CircleCU=mod.get_function("Circle")
|
| ... | ... | |
| 1276 | 1504 |
numpy.int32(Line), |
| 1277 | 1505 |
grid=(zImage.shape[0]/32,zImage.shape[1]/32), |
| 1278 | 1506 |
block=(32,32,1)) |
| 1507 |
elif Method=='Original': |
|
| 1508 |
OriginalCU(zImageCU,fImageCU, |
|
| 1509 |
numpy.float32(Mass), |
|
| 1510 |
numpy.float32(InternalRadius), |
|
| 1511 |
numpy.float32(ExternalRadius), |
|
| 1512 |
numpy.float32(Angle), |
|
| 1513 |
numpy.int32(Line), |
|
| 1514 |
grid=(zImage.shape[0]/32/2,1), |
|
| 1515 |
block=(32,1,1)) |
|
| 1279 | 1516 |
elif Method=='TrajectoCircle': |
| 1280 | 1517 |
TrajectoryCU(TrajectoriesCU,IdLastCU, |
| 1281 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1282 | 1518 |
numpy.float32(Mass), |
| 1283 | 1519 |
numpy.float32(InternalRadius), |
| 1284 | 1520 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1288 | 1524 |
block=(32,1,1)) |
| 1289 | 1525 |
|
| 1290 | 1526 |
CircleCU(TrajectoriesCU,IdLastCU,zImageCU,fImageCU, |
| 1291 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1292 | 1527 |
numpy.float32(Mass), |
| 1293 | 1528 |
numpy.float32(InternalRadius), |
| 1294 | 1529 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1298 | 1533 |
block=(32,32,1)) |
| 1299 | 1534 |
else: |
| 1300 | 1535 |
TrajectoryCU(TrajectoriesCU,IdLastCU, |
| 1301 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1302 | 1536 |
numpy.float32(Mass), |
| 1303 | 1537 |
numpy.float32(InternalRadius), |
| 1304 | 1538 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1309 | 1543 |
|
| 1310 | 1544 |
PixelCU(zImageCU,fImageCU,TrajectoriesCU,IdLastCU, |
| 1311 | 1545 |
numpy.uint32(Trajectories.shape[0]), |
| 1312 |
numpy.uint32(Trajectories.shape[1]), |
|
| 1313 | 1546 |
numpy.float32(Mass), |
| 1314 | 1547 |
numpy.float32(InternalRadius), |
| 1315 | 1548 |
numpy.float32(ExternalRadius), |
| ... | ... | |
| 1368 | 1601 |
# No output as image |
| 1369 | 1602 |
NoImage = False |
| 1370 | 1603 |
|
| 1371 |
HowToUse='%s -h [Help] -b [BlackBodyEmission] -n [NoImage] -p <Einstein/Newton> -s <SizeInPixels> -m <Mass> -i <DiscInternalRadius> -x <DiscExternalRadius> -a <AngleAboveDisc> -d <DeviceId> -c <Greyscale/Red2Yellow> -g <CUDA/OpenCL> -t <EachPixel/TrajectoCircle/TrajectoPixel> -v <FP32/FP64>' |
|
| 1604 |
HowToUse='%s -h [Help] -b [BlackBodyEmission] -n [NoImage] -p <Einstein/Newton> -s <SizeInPixels> -m <Mass> -i <DiscInternalRadius> -x <DiscExternalRadius> -a <AngleAboveDisc> -d <DeviceId> -c <Greyscale/Red2Yellow> -g <CUDA/OpenCL> -t <EachPixel/TrajectoCircle/TrajectoPixel/Original> -v <FP32/FP64>'
|
|
| 1372 | 1605 |
|
| 1373 | 1606 |
try: |
| 1374 | 1607 |
opts, args = getopt.getopt(sys.argv[1:],"hbns:m:i:x:a:d:g:v:t:c:p:",["blackbody","noimage","camera","size=","mass=","internal=","external=","angle=","device=","gpustyle=","variabletype=","method=","colors=","physics="]) |
Formats disponibles : Unified diff