black-hole-accretion.py

    # Angle with normal to disc 10 degrees
    Angle = numpy.pi / 180.0 * (90.0 - 10.0)
    # Radiation of disc : BlackBody or Monochromatic
    BlackBody = False
    # Size of image
    Size = 1024
    # Variable Type
    VariableType = "FP32"
    # ?
    q = -2
    # Method of resolution
    Method = "TrajectoPixel"
    # Colors for output image
    Colors = "Greyscale"
    # Physics
    Physics = "Einstein"
    # No output as image
    NoImage = False
    # Threads in CUDA
    Threads = 32
    # Trackpoints of trajectories
    TrackPoints = 2048
    # Tracksave of trajectories
    TrackSave = False

    HowToUse = "%s -h [Help] -b [BlackBodyEmission] -j [TrackSave] -n [NoImage] -p <Einstein/Newton> -s <SizeInPixels> -m <Mass> -i <DiscInternalRadius> -x <DiscExternalRadius> -a <AngleAboveDisc> -d <DeviceId> -c <Greyscale/Red2Yellow> -g <CUDA/OpenCL> -o <EachPixel/TrajectoCircle/TrajectoPixel/EachCircle/Original> -t <ThreadsInCuda> -v <FP32/FP64> -k <TrackPoints>"  # noqa: E501

    try:
        opts, args = getopt.getopt(
            sys.argv[1:],
            "hbnjs:m:i:x:a:d:g:v:o:t:c:p:k:",
            [
                "tracksave",
                "blackbody",
                "noimage",
                "camera",
                "size=",
                "mass=",
                "internal=",
                "external=",
                "angle=",
                "device=",
                "gpustyle=",
                "variabletype=",
                "method=",
                "threads=",
                "colors=",
                "physics=",
                "trackpoints=",
            ],
        )
    except getopt.GetoptError:
        print(HowToUse % sys.argv[0])
        sys.exit(2)

    # List of Devices
    Devices = []
    Alu = {}

    for opt, arg in opts:
        if opt == "-h":
            print(HowToUse % sys.argv[0])

            print("\nInformations about devices detected under OpenCL API:")
            # For PyOpenCL import
            try:
                Id = 0
                for platform in cl.get_platforms():
                    for device in platform.get_devices():
                        # deviceType=cl.device_type.to_string(device.type)
                        deviceType = "xPU"
                        print(
                            "Device #%i from %s of type %s : %s"
                            % (
                                Id,
                                platform.vendor.lstrip(),
                                deviceType,
                                device.name.lstrip(),
                            )
                        )
                        Id = Id + 1

            except Exception:
                print("Your platform does not seem to support OpenCL")

            print("\nInformations about devices detected under CUDA API:")
            # For PyCUDA import
            try:
                import pycuda.driver as cuda

                cuda.init()
                for Id in range(cuda.Device.count()):
                    device = cuda.Device(Id)
                    print("Device #%i of type GPU : %s" % (Id, device.name()))
                print
            except Exception:
                print("Your platform does not seem to support CUDA")

            sys.exit()

        elif opt in ("-d", "--device"):
            #            Devices.append(int(arg))
            Device = int(arg)
        elif opt in ("-g", "--gpustyle"):
            GpuStyle = arg
        elif opt in ("-v", "--variabletype"):
            VariableType = arg
        elif opt in ("-s", "--size"):
            Size = int(arg)
        elif opt in ("-k", "--trackpoints"):
            TrackPoints = int(arg)
        elif opt in ("-m", "--mass"):
            Mass = float(arg)
        elif opt in ("-i", "--internal"):
            InternalRadius = float(arg)
        elif opt in ("-e", "--external"):
            ExternalRadius = float(arg)
        elif opt in ("-a", "--angle"):
            Angle = numpy.pi / 180.0 * (90.0 - float(arg))
        elif opt in ("-b", "--blackbody"):
            BlackBody = True
        elif opt in ("-j", "--tracksave"):
            TrackSave = True
        elif opt in ("-n", "--noimage"):
            NoImage = True
        elif opt in ("-o", "--method"):
            Method = arg
        elif opt in ("-t", "--threads"):
            Threads = int(arg)
        elif opt in ("-c", "--colors"):
            Colors = arg
        elif opt in ("-p", "--physics"):
            Physics = arg

    print("Device Identification selected : %s" % Device)
    print("GpuStyle used : %s" % GpuStyle)
    print("VariableType : %s" % VariableType)
    print("Size : %i" % Size)
    print("Mass : %f" % Mass)
    print("Internal Radius : %f" % InternalRadius)
    print("External Radius : %f" % ExternalRadius)
    print("Angle with normal of (in radians) : %f" % Angle)
    print("Black Body Disc Emission (monochromatic instead) : %s" % BlackBody)
    print("Method of resolution : %s" % Method)
    print("Colors for output images : %s" % Colors)
    print("Physics used for Trajectories : %s" % Physics)
    print("Trackpoints of Trajectories : %i" % TrackPoints)
    print("Tracksave of Trajectories : %i" % TrackSave)

    if GpuStyle == "CUDA":
        print("\nSelection of CUDA device")
        try:
            # For PyCUDA import
            import pycuda.driver as cuda

            cuda.init()
            for Id in range(cuda.Device.count()):
                device = cuda.Device(Id)
                print("Device #%i of type GPU : %s" % (Id, device.name()))
                if Id in Devices:
                    Alu[Id] = "GPU"

        except ImportError:
            print("Platform does not seem to support CUDA")

    if GpuStyle == "OpenCL":
        print("\nSelection of OpenCL device")
        try:
            # For PyOpenCL import
            import pyopencl as cl

            Id = 0
            for platform in cl.get_platforms():
                for device in platform.get_devices():
                    # deviceType=cl.device_type.to_string(device.type)
                    deviceType = "xPU"
                    print(
                        "Device #%i from %s of type %s : %s"
                        % (
                            Id,
                            platform.vendor.lstrip().rstrip(),
                            deviceType,
                            device.name.lstrip().rstrip(),
                        )
                    )

                    if Id in Devices:
                        # Set the Alu as detected Device Type
                        Alu[Id] = deviceType
                    Id = Id + 1
        except ImportError:
            print("Platform does not seem to support OpenCL")

    zImage = numpy.zeros((Size, Size), dtype=numpy.float32)
    fImage = numpy.zeros((Size, Size), dtype=numpy.float32)

    InputCL = {}
    InputCL["Device"] = Device
    InputCL["GpuStyle"] = GpuStyle
    InputCL["VariableType"] = VariableType
    InputCL["Size"] = Size
    InputCL["Mass"] = Mass
    InputCL["InternalRadius"] = InternalRadius
    InputCL["ExternalRadius"] = ExternalRadius
    InputCL["Angle"] = Angle
    InputCL["BlackBody"] = BlackBody
    InputCL["Method"] = Method
    InputCL["TrackPoints"] = TrackPoints
    InputCL["Physics"] = Physics
    InputCL["Threads"] = Threads
    InputCL["NoImage"] = NoImage
    InputCL["TrackSave"] = TrackSave

    if GpuStyle == "OpenCL":
        duration = BlackHoleCL(zImage, fImage, InputCL)
    else:
        duration = BlackHoleCUDA(zImage, fImage, InputCL)

    Hostname = gethostname()
    Date = time.strftime("%Y%m%d_%H%M%S")
    ImageInfo = "%s_Device%i_%s_%s" % (Method, Device, Hostname, Date)

    if not NoImage:
        ImageOutput(zImage, "TrouNoirZ_%s" % ImageInfo, Colors)
        ImageOutput(fImage, "TrouNoirF_%s" % ImageInfo, Colors)