diff --git a/.DS_Store b/.DS_Store index 9dc52557bb76c24a97b496d26e68a5106643d02f..358dfa7b4d4e6a1e2ffca50fc59d94e0df8e52dd 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/.gitattributes b/.gitattributes index 0b3c8a2edaa6a7e411d154d82f537a463e14fe7d..0b76c06d2b9529a41f684321fd7241727d2bea37 100644 --- a/.gitattributes +++ b/.gitattributes @@ -9,5 +9,6 @@ *.glb filter=lfs diff=lfs merge=lfs -text *.vtr filter=lfs diff=lfs merge=lfs -text *.vtu filter=lfs diff=lfs merge=lfs -text +*.vti filter=lfs diff=lfs merge=lfs -text *.cif filter=lfs diff=lfs merge=lfs -text *.nc filter=lfs diff=lfs merge=lfs -text diff --git a/eval_cases/paraview/main_cases.yaml b/eval_cases/paraview/main_cases.yaml index 7ea9642ba129a0785e6e72be63fe9c27ceaa00bc..00cc91d8c6be1eac41e2c55620b06853674b1b17 100644 --- a/eval_cases/paraview/main_cases.yaml +++ b/eval_cases/paraview/main_cases.yaml @@ -419,6 +419,7 @@ 8) Save the visualization image as a png file "chameleon_isosurface/results/{agent_mode}/chameleon_isosurface.png" 9) (Option 1) Save the paraview state as "chameleon_isosurface/results/{agent_mode}/chameleon_isosurface.pvsm" if you are using ParaView as the visualization tool 10) (Option 2) Save the cxx code script as "chameleon_isosurface/results/{agent_mode}/chameleon_isosurface.cxx" if you are using VTK as the visualization tool + You should only choose one of Option 1 or Option 2 to save your work. Do not save any other files, and always save the visualization image. assert: - type: llm-rubric subtype: vision @@ -447,6 +448,7 @@ 6) Save the visualization image as a png file "argon-bubble/results/{agent_mode}/argon-bubble.png" 7) (Option 1) Save the paraview state as "argon-bubble/results/{agent_mode}/argon-bubble.pvsm" if you are using ParaView as the visualization tool 8) (Option 2) Save the cxx code script as "argon-bubble/results/{agent_mode}/argon-bubble.cxx" if you are using VTK as the visualization tool + You should only choose one of Option 1 or Option 2 to save your work. Do not save any other files, and always save the visualization image. assert: - type: llm-rubric subtype: vision @@ -475,6 +477,7 @@ 8) Save the visualization image as a png file "richtmyer/results/{agent_mode}/richtmyer.png" 9) (Option 1) Save the paraview state as "richtmyer/results/{agent_mode}/richtmyer.pvsm" if you are using ParaView as the visualization tool 10) (Option 2) Save the cxx code script as "richtmyer/results/{agent_mode}/richtmyer.cxx" if you are using VTK as the visualization tool + You should only choose one of Option 1 or Option 2 to save your work. Do not save any other files, and always save the visualization image. assert: - type: llm-rubric subtype: vision @@ -503,6 +506,7 @@ 8) Save the visualization image as a png file "miranda/results/{agent_mode}/miranda.png" 9) (Option 1) Save the paraview state as "miranda/results/{agent_mode}/miranda.pvsm" if you are using ParaView as the visualization tool 10) (Option 2) Save the cxx code script as "miranda/results/{agent_mode}/miranda.cxx" if you are using VTK as the visualization tool + You should only choose one of Option 1 or Option 2 to save your work. Do not save any other files, and always save the visualization image. assert: - type: llm-rubric subtype: vision @@ -531,6 +535,7 @@ 8) Save the visualization image as a png file "rotstrat/results/{agent_mode}/rotstrat.png" 9) (Option 1) Save the paraview state as "rotstrat/results/{agent_mode}/rotstrat.pvsm" if you are using ParaView as the visualization tool 10) (Option 2) Save the cxx code script as "rotstrat/results/{agent_mode}/rotstrat.cxx" if you are using VTK as the visualization tool + You should only choose one of Option 1 or Option 2 to save your work. Do not save any other files, and always save the visualization image. assert: - type: llm-rubric subtype: vision @@ -539,4 +544,448 @@ 2. Does the blueish region show areas with low opacity? - 3. Does the reddish region show areas with high opacity? \ No newline at end of file + 3. Does the reddish region show areas with high opacity? + + +# Vector Field Cases +# 17. MHD Turbulence Velocity Field (t=10) (mhd-turbulence_glyph) +# Isothermal magnetohydrodynamic (MHD) simulations capturing compressible turbulence phenomena relevant to astrophysical systems. +# MHD turbulence is an essential component of the solar wind, galaxy formation, and interstellar medium (ISM) dynamics. +# The simulations model fluid dynamics governed by conservation equations for mass, momentum, and magnetic fields, exploring MHD flows across multiple regimes—subsonic and supersonic velocities, as well as sub-Alfvénic and super-Alfvénic magnetic conditions. +# Three field types are captured: density (scalar), velocity (vector), and magnetic field (vector). Data source: The Well (Polymathic AI). +- vars: + question: | + Load the MHD turbulence velocity field dataset from "mhd-turbulence_glyph/data/mhd-turbulence_glyph.vti" (VTI format, 128x128x128 grid). + Create a slice at z=64 through the volume. On this slice, place arrow glyphs oriented by the velocity vector field and scaled by velocity magnitude. + Color the arrows using the 'Cool to Warm' colormap mapped to velocity magnitude. + Use a sampling stride of 4 to avoid overcrowding. Set the glyph scale factor to 5.0. + Add a color bar labeled 'Velocity Magnitude'. + Use a dark background (RGB: 0.1, 0.1, 0.15). + Set the camera to a top-down view looking along the negative z-axis. Render at 1024x1024 resolution. + Save the paraview state as "mhd-turbulence_glyph/results/{agent_mode}/mhd-turbulence_glyph.pvsm". + Save the visualization image as "mhd-turbulence_glyph/results/{agent_mode}/mhd-turbulence_glyph.png". + (Optional, if use python script) Save the python script as "mhd-turbulence_glyph/results/{agent_mode}/mhd-turbulence_glyph.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Arrow glyphs oriented by velocity vector + 2) Glyphs scaled by velocity magnitude + 3) Color mapping using Cool to Warm colormap on magnitude + 4) Color bar present with label 'Velocity Magnitude' + 5) Dark background color, Top-down camera view, and Output resolution 1024x1024 + + +# 18. Rayleigh-Taylor Instability Velocity Field (t=50) (rti-velocity_glyph) +# Rayleigh-Taylor instability simulations examining how varying spectral characteristics and random phase components influence the development of turbulent mixing. +# The simulations investigate three key physical aspects: the impact of coherence on randomized initial conditions, how initial energy spectrum shapes affect resulting flow structures, and the transition from Boussinesq to non-Boussinesq regimes where mixing becomes asymmetric. +# The dataset captures the self-similar growth of the turbulent mixing zone, enabling validation of the dimensionless mixing parameter and observation of the characteristic energy cascade. +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the Rayleigh-Taylor instability velocity field dataset from "rti-velocity_glyph/data/rti-velocity_glyph.vti" (VTI format, 128x128x128 grid). + Create a slice at y=64 through the volume. + Place arrow glyphs on the slice, oriented by the velocity vector. Use uniform arrow size (no magnitude scaling, scale factor 3.0). + Color the arrows by velocity magnitude using the 'Viridis (matplotlib)' colormap. Use a sampling stride of 3. + Add a color bar labeled 'Velocity Magnitude'. + Use a black background. + Set the camera to view along the negative y-axis. Render at 1024x1024. + Save the paraview state as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.pvsm". + Save the visualization image as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.png". + (Optional, if use python script) Save the python script as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Arrow glyphs oriented by velocity vector + 2) Uniform arrow size (no magnitude scaling) + 3) Color by velocity magnitude with Viridis colormap + 4) Color bar present labeled 'Velocity Magnitude' + 5) Black background, Camera along negative y-axis, and Output resolution 1024x1024 + + +# 19. MHD Magnetic Field (t=10) (mhd-magfield_glyph) +# Isothermal magnetohydrodynamic (MHD) simulations capturing compressible turbulence phenomena relevant to astrophysical systems. +# MHD turbulence is an essential component of the solar wind, galaxy formation, and interstellar medium (ISM) dynamics. +# The simulations model fluid dynamics governed by conservation equations for mass, momentum, and magnetic fields, exploring MHD flows across multiple regimes—subsonic and supersonic velocities, as well as sub-Alfvénic and super-Alfvénic magnetic conditions. +# Three field types are captured: density (scalar), velocity (vector), and magnetic field (vector). +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the MHD magnetic field dataset from "mhd-magfield_glyph/data/mhd-magfield_glyph.vti" (VTI format, 128x128x128 grid with components bx, by, bz). + Create a slice at x=64 through the volume. + Place arrow glyphs oriented by the magnetic field vector and scaled by field magnitude (scale factor 5.0). + Color the arrows using the 'Plasma (matplotlib)' colormap mapped to magnitude. Use stride of 4. + Add a color bar labeled 'Magnetic Field Magnitude'. + Use a dark navy background (RGB: 0.0, 0.0, 0.15). Set camera to view along the negative x-axis. Render at 1024x1024. + Save the paraview state as "mhd-magfield_glyph/results/{agent_mode}/mhd-magfield_glyph.pvsm". + Save the visualization image as "mhd-magfield_glyph/results/{agent_mode}/mhd-magfield_glyph.png". + (Optional, if use python script) Save the python script as "mhd-magfield_glyph/results/{agent_mode}/mhd-magfield_glyph.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Arrow glyphs oriented by magnetic field vector + 2) Glyphs scaled by field magnitude + 3) Plasma colormap applied to magnitude + 4) Color bar present labeled 'Magnetic Field Magnitude + 5) Dark navy background, Camera along negative x-axis, Output resolution 1024x1024 + + +# 20. MHD Turbulence Velocity Field (t=30) (mhd-turbulence_streamline) +# Isothermal magnetohydrodynamic (MHD) simulations capturing compressible turbulence phenomena relevant to astrophysical systems. +# MHD turbulence is an essential component of the solar wind, galaxy formation, and interstellar medium (ISM) dynamics. +# The simulations model fluid dynamics governed by conservation equations for mass, momentum, and magnetic fields, exploring MHD flows across multiple regimes—subsonic and supersonic velocities, as well as sub-Alfvénic and super-Alfvénic magnetic conditions. +# Three field types are captured: density (scalar), velocity (vector), and magnetic field (vector). +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the MHD turbulence velocity field dataset "mhd-turbulence_streamline/data/mhd-turbulence_streamline.vti" (VTI format, 128x128x128 grid). + Generate 3D streamlines seeded from a line source along the z-axis at x=64, y=64 (from z=0 to z=127), with 50 seed points. + Color the streamlines by velocity magnitude using the 'Turbo' colormap. Set streamline tube radius to 0.3 using the Tube filter. + Add a color bar labeled 'Velocity Magnitude'. Use a dark background (RGB: 0.05, 0.05, 0.1). Set an isometric camera view. Render at 1024x1024. + Save the paraview state as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.pvsm". + Save the visualization image as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.png". + (Optional, if use python script) Save the python script as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Streamlines generated from line seed along z-axis, with similar pattern compared to groundtruth + 2) Streamlines rendered as tubes + 3) Color by velocity magnitude with Turbo colormap + 4) Color bar labeled 'Velocity Magnitude' + 5) Dark background, Isometric camera view, Output resolution 1024x1024 + + +# 21. Rayleigh-Taylor Instability Velocity Field (t=70) (rti-velocity_streamline) +# Rayleigh-Taylor instability simulations examining how varying spectral characteristics and random phase components influence the development of turbulent mixing. +# The simulations investigate three key physical aspects: the impact of coherence on randomized initial conditions, how initial energy spectrum shapes affect resulting flow structures, and the transition from Boussinesq to non-Boussinesq regimes where mixing becomes asymmetric. +# The dataset captures the self-similar growth of the turbulent mixing zone, enabling validation of the dimensionless mixing parameter and observation of the characteristic energy cascade. +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the Rayleigh-Taylor instability velocity field dataset from "rti-velocity_streamline/data/rti-velocity_streamline.vti" (VTI format, 128x128x128 grid). + Generate streamlines seeded from a plane at y=64 (using a Point Cloud seed with 200 points distributed on the xz-plane at y=64). + Color the streamlines by the vz component using a 'Cool to Warm (Extended)' diverging colormap. Render streamlines as tubes with radius 0.4. + Add a color bar labeled 'Vz Component'. + Dark background (RGB: 0.02, 0.02, 0.05). Use an isometric camera view. Render at 1024x1024. + Save the paraview state as "rti-velocity_streamline/results/{agent_mode}/rti-velocity_streamline.pvsm". + Save the visualization image as "rti-velocity_streamline/results/{agent_mode}/rti-velocity_streamline.png". + (Optional, if use python script) Save the python script as "rti-velocity_streamline/results/{agent_mode}/rti-velocity_streamline.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Streamlines seeded from y=64 plane region, with similar pattern compared to groundtruth + 2) Streamlines rendered as tubes + 3) Color by vz with Cool to Warm diverging colormap + 4) Color bar labeled 'Vz Component' + 5) Dark background, Isometric camera view, Output resolution 1024x1024 + + +# 22. Turbulent Radiative Layer Velocity Field (tcool=0.10, t=50) (trl-velocity_streamline) +# Turbulent Radiative Layer simulations of astrophysical mixing processes where cold, dense gas interfaces with hot, dilute gas moving at subsonic velocities. +# The cold dense gas on the bottom and hot dilute gas on the top becomes unstable to the Kelvin-Helmholtz instability. +# When turbulence causes mixing, intermediate-temperature gas forms and rapidly cools, creating a net mass transfer from the hot phase to the cold phase—a process relevant to interstellar and circumgalactic environments. +# Generated using Athena++. Data source: The Well (Polymathic AI) +- vars: + question: | + Load the turbulent radiative layer velocity field dataset from "trl-velocity_streamline/data/trl-velocity_streamline.vti" (VTI format, 256x128x128 grid). + Generate streamlines seeded from a line along the x-axis at y=64, z=64 (from x=0 to x=255), with 100 seed points. + Color streamlines by velocity magnitude using the 'Inferno (matplotlib)' colormap. Render as tubes with radius 0.5. + Add a color bar labeled 'Velocity Magnitude'. + Dark background (RGB: 0.0, 0.0, 0.0). Set an isometric camera view. Render at 1024x1024." + Save the paraview state as "trl-velocity_streamline/results/{agent_mode}/trl-velocity_streamline.pvsm". + Save the visualization image as "trl-velocity_streamline/results/{agent_mode}/trl-velocity_streamline.png". + (Optional, if use python script) Save the python script as "trl-velocity_streamline/results/{agent_mode}/trl-velocity_streamline.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Streamlines seeded along x-axis line, with similar pattern compared to groundtruth + 2) Streamlines rendered as tubes + 3) Color by magnitude with Inferno colormap + 4) Color bar labeled 'Velocity Magnitude' + 5) Black background, Isometric camera view, Output resolution 1024x1024 + + +# 23. MHD Magnetic Field (t=40) (mhd-magfield_volvis) +# Isothermal magnetohydrodynamic (MHD) simulations capturing compressible turbulence phenomena relevant to astrophysical systems. +# MHD turbulence is an essential component of the solar wind, galaxy formation, and interstellar medium (ISM) dynamics. +# The simulations model fluid dynamics governed by conservation equations for mass, momentum, and magnetic fields, exploring MHD flows across multiple regimes—subsonic and supersonic velocities, as well as sub-Alfvénic and super-Alfvénic magnetic conditions. +# Three field types are captured: density (scalar), velocity (vector), and magnetic field (vector). +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the MHD magnetic field dataset from "mhd-magfield_volvis/data/mhd-magfield_volvis.vti" (VTI format, 128x128x128 grid). + Compute the magnetic field magnitude from components (bx, by, bz). Perform volume rendering of the magnitude field. + Use the 'Cool to Warm' colormap with an opacity transfer function that makes low-magnitude regions transparent and high-magnitude regions opaque. + Add a color bar labeled 'B Magnitude'. + Use a dark background (RGB: 0.0, 0.0, 0.05). Set an isometric camera view. Render at 1024x1024. + Save the paraview state as "mhd-magfield_volvis/results/{agent_mode}/mhd-magfield_volvis.pvsm". + Save the visualization image as "mhd-magfield_volvis/results/{agent_mode}/mhd-magfield_volvis.png". + (Optional, if use python script) Save the python script as "mhd-magfield_volvis/results/{agent_mode}/mhd-magfield_volvis.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Volume rendering representation applied based on magnitude field, generally similar to groundtruth + 2) Cool to Warm colormap + 3) Opacity transfer function correctly set: low=transparent, high=opaque + 4) Color bar labeled 'B Magnitude' + 5) Dark background, Isometric camera, Output resolution 1024x1024 + + +# 24. Turbulence Gravity Cooling Velocity (temp=1000K, dens=4.45, metal=0.1Z, t=20) (tgc-velocity_volvis) +# Turbulence-gravity-cooling simulations modeling turbulent fluid with gravity representing the interstellar medium in galaxies. +# These simulations capture the formation of dense filaments that seed star formation, with filament frequency and timescales varying based on cooling strength. +# The dataset encompasses three density regimes with systematically varied initial temperatures and metallicity levels representing different cosmic epochs, +# governed by coupled equations for pressure, density, momentum, and internal energy incorporating gravitational forces, viscosity, and radiative heating/cooling. +# Data source: The Well (Polymathic AI). +- vars: + question: | + Load the turbulence-gravity-cooling velocity field dataset from "tgc-velocity_volvis/data/tgc-velocity_volvis.vti" (VTI format, 64x64x64 grid). + Perform volume rendering of velocity magnitude. Use the 'Viridis (matplotlib)' colormap. + Set opacity transfer function to gradually increase from 0 at minimum to 0.8 at maximum. + Add a color bar labeled 'Velocity Magnitude'. + Dark gray background (RGB: 0.1, 0.1, 0.1). Isometric camera view. Render at 1024x1024. + Save the paraview state as "tgc-velocity_volvis/results/{agent_mode}/tgc-velocity_volvis.pvsm". + Save the visualization image as "tgc-velocity_volvis/results/{agent_mode}/tgc-velocity_volvis.png". + (Optional, if use python script) Save the python script as "tgc-velocity_volvis/results/{agent_mode}/tgc-velocity_volvis.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Volume rendering applied, generally similar to groundtruth + 2) Viridis colormap + 3) Gradual opacity transfer function + 4) Color bar labeled 'Velocity Magnitude' + 5) Dark gray background, Isometric camera, Output resolution 1024x1024 + + +# 25. Rayleigh-Taylor Instability Velocity Field (t=40) (rti-velocity_divergence) +# Rayleigh-Taylor instability simulations examining how varying spectral characteristics and random phase components influence the development of turbulent mixing. +# The simulations investigate three key physical aspects: the impact of coherence on randomized initial conditions, how initial energy spectrum shapes affect resulting flow structures, and the transition from Boussinesq to non-Boussinesq regimes where mixing becomes asymmetric. +# The dataset captures the self-similar growth of the turbulent mixing zone, enabling validation of the dimensionless mixing parameter and observation of the characteristic energy cascade. +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the Rayleigh-Taylor instability velocity field from "rti-velocity_divergence/data/rti-velocity_divergence.vti" (VTI format, 128x128x128). + Compute the divergence of the velocity field using the Gradient filter with 'Compute Divergence' enabled. + Extract a slice at z=64 and color it by divergence using the 'Cool to Warm' diverging colormap (centered at 0). + Add a color bar labeled 'Velocity Divergence'. + White background. Top-down camera view along negative z-axis. Render at 1024x1024. + Save the paraview state as "rti-velocity_divergence/results/{agent_mode}/rti-velocity_divergence.pvsm". + Save the visualization image as "rti-velocity_divergence/results/{agent_mode}/rti-velocity_divergence.png". + (Optional, if use python script) Save the python script as "rti-velocity_divergence/results/{agent_mode}/rti-velocity_divergence.py". + Do not save any other files, and always save the visualization image + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Divergence computation from velocity field, with similar pattern compared to groundtruth + 2) Cool to Warm diverging colormap centered at 0 + 3) Color bar labeled 'Velocity Divergence' + 4) White background, Top-down camera along negative z, Output resolution 1024x1024 + + +# 26. Turbulent Radiative Layer Velocity Field (tcool=1.00, t=30) (trl-velocity_isosurface) +# Turbulent Radiative Layer simulations of astrophysical mixing processes where cold, dense gas interfaces with hot, dilute gas moving at subsonic velocities. +# The cold dense gas on the bottom and hot dilute gas on the top becomes unstable to the Kelvin-Helmholtz instability. +# When turbulence causes mixing, intermediate-temperature gas forms and rapidly cools, creating a net mass transfer from the hot phase to the cold phase—a process relevant to interstellar and circumgalactic environments. +# Generated using Athena++. Data source: The Well (Polymathic AI) +- vars: + question: | + Load the turbulent radiative layer velocity field dataset from "trl-velocity_isosurface/data/trl-velocity_isosurface.vti" (VTI format, 256x128x128). + Extract an isosurface of velocity magnitude at the value 0.8. Color the isosurface by the vx component using the 'Cool to Warm' colormap. + Add a color bar labeled 'Vx Component'. + Dark background (RGB: 0.05, 0.05, 0.1). Isometric camera view. Render at 1024x1024. + Save the paraview state as "trl-velocity_isosurface/results/{agent_mode}/trl-velocity_isosurface.pvsm". + Save the visualization image as "trl-velocity_isosurface/results/{agent_mode}/trl-velocity_isosurface.png". + (Optional, if use python script) Save the python script as "trl-velocity_isosurface/results/{agent_mode}/trl-velocity_isosurface.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Isosurface extraction at magnitude=0.8, with similar pattern compared to groundtruth + 2) Isosurface colored by vx component + 3) Cool to Warm colormap + 4) Color bar labeled 'Vx Component' + 5) Dark background, Isometric camera, Output resolution 1024x1024 + + +# 27. Supernova Explosion Velocity Field (t=30) (supernova-velocity_streamline) +# Supernova explosion simulations capturing the physical dynamics of a stellar explosion propagating through a dense interstellar medium. +# The simulations inject thermal energy of 10^51 ergs at the center of a computational domain, generating a blastwave that sweeps through ambient gas and creates supernova feedback structures—an explosion inside a compression of a monatomic ideal gas modeling conditions in the Milky Way Galaxy interstellar medium. +# The simulations employ sophisticated physics including radiative cooling and heating. +# Data source: The Well (Polymathic AI). +- vars: + question: | + Load the supernova explosion velocity field dataset from "supernova-velocity_streamline/data/supernova-velocity_streamline.vti" (VTI format, 128x128x128 grid). + Generate streamlines seeded from a line source along the diagonal from (20,20,20) to (108,108,108) with 80 seed points. + Color streamlines by velocity magnitude using the 'Magma (matplotlib)' colormap. + Render as tubes with radius 0.4. + Add a color bar labeled 'Velocity Magnitude'. + Dark background (RGB: 0.02, 0.0, 0.05). Isometric camera view. Render at 1024x1024. + Save the paraview state as "supernova-velocity_streamline/results/{agent_mode}/supernova-velocity_streamline.pvsm". + Save the visualization image as "supernova-velocity_streamline/results/{agent_mode}/supernova-velocity_streamline.png". + (Optional, if use python script) Save the python script as "supernova-velocity_streamline/results/{agent_mode}/supernova-velocity_streamline.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Streamlines seeded from diagonal line, with similar pattern compared to groundtruth + 2) Streamlines as tubes + 3) Color by magnitude with Magma colormap + 4) Color bar labeled 'Velocity Magnitude' + 5) Dark background, Isometric camera, Output resolution 1024x1024 + + +# 28. MHD Turbulence Velocity Field (t=50) (mhd-turbulence_vorticity) +# Isothermal magnetohydrodynamic (MHD) simulations capturing compressible turbulence phenomena relevant to astrophysical systems. +# MHD turbulence is an essential component of the solar wind, galaxy formation, and interstellar medium (ISM) dynamics. +# The simulations model fluid dynamics governed by conservation equations for mass, momentum, and magnetic fields, exploring MHD flows across multiple regimes—subsonic and supersonic velocities, as well as sub-Alfvénic and super-Alfvénic magnetic conditions. +# Three field types are captured: density (scalar), velocity (vector), and magnetic field (vector). +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the MHD turbulence velocity field dataset "mhd-turbulence_vorticity/data/mhd-turbulence_vorticity.vti" (VTI format, 128x128x128 grid). + Compute the vorticity field (curl of velocity) using the Gradient filter with 'Compute Vorticity' enabled. + Then compute vorticity magnitude. Perform volume rendering of vorticity magnitude using the 'Plasma (matplotlib)' colormap. + Set opacity to highlight high-vorticity regions. + Add a color bar labeled 'Vorticity Magnitude'. + Black background. Isometric camera. Render at 1024x1024. + Save the paraview state as "mhd-turbulence_vorticity/results/{agent_mode}/mhd-turbulence_vorticity.pvsm". + Save the visualization image as "mhd-turbulence_vorticity/results/{agent_mode}/mhd-turbulence_vorticity.png". + (Optional, if use python script) Save the python script as "mhd-turbulence_vorticity/results/{agent_mode}/mhd-turbulence_vorticity.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Vorticity computation (curl of velocity), similar pattern compared to groundtruth + 2) Volume rendering of vorticity magnitude + 3) Plasma colormap + 4) Opacity highlights high-vorticity regions + 5) Color bar labeled 'Vorticity Magnitude' + 6) Black background, Isometric camera, Output resolution 1024x1024 + + +# 29. Supernova Explosion Velocity Field (t=40) (supernova-velocity_isosurface) +# Supernova explosion simulations capturing the physical dynamics of a stellar explosion propagating through a dense interstellar medium. +# The simulations inject thermal energy of 10^51 ergs at the center of a computational domain, generating a blastwave that sweeps through ambient gas and creates supernova feedback structures—an explosion inside a compression of a monatomic ideal gas modeling conditions in the Milky Way Galaxy interstellar medium. +# The simulations employ sophisticated physics including radiative cooling and heating. +# Data source: The Well (Polymathic AI). +- vars: + question: | + Load the supernova explosion velocity field from "supernova-velocity_isosurface/data/supernova-velocity_isosurface.vti" (VTI format, 128x128x128). + Extract an isosurface of velocity magnitude at threshold 0.7. Color the isosurface by the vz component using 'Blue to Red Rainbow' colormap. + Add a color bar labeled 'Vz Component'. + Dark background (RGB: 0.0, 0.0, 0.0). Isometric camera view. Render at 1024x1024. + Save the paraview state as "supernova-velocity_isosurface/results/{agent_mode}/supernova-velocity_isosurface.pvsm". + Save the visualization image as "supernova-velocity_isosurface/results/{agent_mode}/supernova-velocity_isosurface.png". + (Optional, if use python script) Save the python script as "supernova-velocity_isosurface/results/{agent_mode}/supernova-velocity_isosurface.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Isosurface at magnitude=0.7, similar pattern compared to groundtruth + 2) Colored by vz component + 3) Blue to Red Rainbow colormap + 4) Color bar labeled 'Vz Component' + 5) Black background, Isometric camera, Output resolution 1024x1024 + + +# 30. MHD Magnetic Field (t=60) (mhd-magfield_isosurface) +# Isothermal magnetohydrodynamic (MHD) simulations capturing compressible turbulence phenomena relevant to astrophysical systems. +# MHD turbulence is an essential component of the solar wind, galaxy formation, and interstellar medium (ISM) dynamics. +# The simulations model fluid dynamics governed by conservation equations for mass, momentum, and magnetic fields, exploring MHD flows across multiple regimes—subsonic and supersonic velocities, as well as sub-Alfvénic and super-Alfvénic magnetic conditions. +# Three field types are captured: density (scalar), velocity (vector), and magnetic field (vector). +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the MHD magnetic field dataset from "mhd-magfield_isosurface/data/mhd-magfield_isosurface.vti" (VTI format, 128x128x128). + Extract an isosurface of magnetic field magnitude at threshold 0.8. Color the isosurface by the bx component using 'Turbo' colormap. + Add a color bar labeled 'Bx Component'. + Dark navy background (RGB: 0.0, 0.0, 0.1). Isometric camera view. Render at 1024x1024. + Save the paraview state as "mhd-magfield_isosurface/results/{agent_mode}/mhd-magfield_isosurface.pvsm". + Save the visualization image as "mhd-magfield_isosurface/results/{agent_mode}/mhd-magfield_isosurface.png". + (Optional, if use python script) Save the python script as "mhd-magfield_isosurface/results/{agent_mode}/mhd-magfield_isosurface.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Isosurface at magnitude=0.8, similar pattern compared to groundtruth + 2) Colored by bx component + 3) Turbo colormap + 4) Color bar labeled 'Bx Component' + 5) Dark navy background, Isometric camera, Output resolution 1024x1024 + + +# 31. Turbulence Gravity Cooling Velocity (temp=100K, dens=0.445, metal=Z, t=10) (tgc-velocity_contour) +# Turbulence-gravity-cooling simulations modeling turbulent fluid with gravity representing the interstellar medium in galaxies. +# These simulations capture the formation of dense filaments that seed star formation, with filament frequency and timescales varying based on cooling strength. +# The dataset encompasses three density regimes with systematically varied initial temperatures and metallicity levels representing different cosmic epochs, +# governed by coupled equations for pressure, density, momentum, and internal energy incorporating gravitational forces, viscosity, and radiative heating/cooling. +# Data source: The Well (Polymathic AI). +- vars: + question: | + Load the turbulence-gravity-cooling velocity field dataset from "tgc-velocity_contour/data/tgc-velocity_contour.vti" (VTI format, 64x64x64). + Extract a slice at z=32 and color it by velocity magnitude using 'Viridis (matplotlib)' colormap. + Also add contour lines of velocity magnitude on the same slice at values [0.3, 0.6, 0.9, 1.2] using the Contour filter on the slice output. + Display contour lines in white. Add a color bar labeled 'Velocity Magnitude'. + Light gray background (RGB: 0.9, 0.9, 0.9). Top-down camera. Render at 1024x1024. + Save the paraview state as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.pvsm". + Save the visualization image as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.png". + (Optional, if use python script) Save the python script as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.py". + Do not save any other files, and always save the visualization image. + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Slice at z=32 colored by magnitude, similar pattern compared to groundtruth + 2) Viridis colormap on slice + 3) Contour lines at specified values, similar pattern compared to groundtruth + 4) White contour lines + 5) Color bar labeled 'Velocity Magnitude' + 6) Light gray background, Top-down camera, Output resolution 1024x1024 + + +# 32. Rayleigh-Taylor Instability Velocity Field (t=80) (rti-velocity_slices) +# Rayleigh-Taylor instability simulations examining how varying spectral characteristics and random phase components influence the development of turbulent mixing. +# The simulations investigate three key physical aspects: the impact of coherence on randomized initial conditions, how initial energy spectrum shapes affect resulting flow structures, and the transition from Boussinesq to non-Boussinesq regimes where mixing becomes asymmetric. +# The dataset captures the self-similar growth of the turbulent mixing zone, enabling validation of the dimensionless mixing parameter and observation of the characteristic energy cascade. +# Data source: The Well (Polymathic AI) +- vars: + question: | + Load the Rayleigh-Taylor instability velocity field from "rti-velocity_slices/data/rti-velocity_slices.vti" (VTI format, 128x128x128). + Create three orthogonal slices: at x=64 (YZ-plane), y=64 (XZ-plane), and z=64 (XY-plane). + Color all three slices by velocity magnitude using the 'Turbo' colormap. + Add a color bar labeled 'Velocity Magnitude'. + Dark background (RGB: 0.05, 0.05, 0.05). Set an isometric camera view that shows all three slices. Render at 1024x1024. + Save the paraview state as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.pvsm". + Save the visualization image as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.png". + (Optional, if use python script) Save the python script as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.py". + Do not save any other files, and always save the visualization image + assert: + - type: llm-rubric + subtype: vision + value: | + 1) Three orthogonal slices at x=64, y=64, z=64, similar pattern compared to groundtruth + 2) All slices colored by velocity magnitude + 3) Turbo colormap + 4) Color bar labeled 'Velocity Magnitude' + 5) Dark background, Isometric camera showing all three slices, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.png b/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..d641c3a7bd8808704cb60d72a383d7708db986ef --- /dev/null +++ b/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:154a5f801d0ab8446072f0a73ee6ff425d30f684c504159fc9581ae12b7fcd0d +size 298935 diff --git a/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.pvsm b/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..f1e6b9040889c36835791f1ca88c4735b564a362 --- /dev/null +++ b/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f4b40024a75558c00b6613fd74d9ef154246381d65c943230499de5adf15f970 +size 288472 diff --git a/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.py b/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..0304bd8a78a467761fbf63dae67aff3a904cf348 --- /dev/null +++ b/main/mhd-magfield_glyph/GS/mhd-magfield_glyph_gs.py @@ -0,0 +1,51 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'MHD_magfield_0010.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +sliceFilter = Slice(Input=reader) +sliceFilter.SliceType = 'Plane' +sliceFilter.SliceType.Origin = [64.0, 63.5, 63.5] +sliceFilter.SliceType.Normal = [1.0, 0.0, 0.0] +sliceFilter.UpdatePipeline() + +glyph = Glyph(Input=sliceFilter, GlyphType='Arrow') +glyph.OrientationArray = ['POINTS', 'vector'] +glyph.ScaleArray = ['POINTS', 'magnitude'] +glyph.ScaleFactor = 5.0 +glyph.MaximumNumberOfSamplePoints = 5000 +glyph.GlyphMode = 'Every Nth Point' +glyph.Stride = 4 +glyph.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.0, 0.0, 0.15] + +glyphDisplay = Show(glyph, renderView) +glyphDisplay.Representation = 'Surface' +ColorBy(glyphDisplay, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Plasma (matplotlib)', True) + +glyphDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Magnetic Field Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [250.0, 63.5, 63.5] +renderView.CameraFocalPoint = [64.0, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 04 done: {OUTPUT_IMG}") diff --git a/main/mhd-magfield_glyph/data/mhd-magfield_glyph.vti b/main/mhd-magfield_glyph/data/mhd-magfield_glyph.vti new file mode 100644 index 0000000000000000000000000000000000000000..ef5585ddb3dce6118edec51b09da11995f966965 --- /dev/null +++ b/main/mhd-magfield_glyph/data/mhd-magfield_glyph.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1b891955b70e72bcc6e0e8976a7f587ff08206a1b153e613617251170886d581 +size 78294594 diff --git a/main/mhd-magfield_glyph/task_description.txt b/main/mhd-magfield_glyph/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..de9b72294d3b050fbdbc7d0586bec3e177b40d7e --- /dev/null +++ b/main/mhd-magfield_glyph/task_description.txt @@ -0,0 +1,10 @@ +Load the MHD magnetic field dataset from "mhd-magfield_glyph/data/mhd-magfield_glyph.vti" (VTI format, 128x128x128 grid with components bx, by, bz). +Create a slice at x=64 through the volume. +Place arrow glyphs oriented by the magnetic field vector and scaled by field magnitude (scale factor 5.0). +Color the arrows using the 'Plasma (matplotlib)' colormap mapped to magnitude. Use stride of 4. +Add a color bar labeled 'Magnetic Field Magnitude'. +Use a dark navy background (RGB: 0.0, 0.0, 0.15). Set camera to view along the negative x-axis. Render at 1024x1024. +Save the paraview state as "mhd-magfield_glyph/results/{agent_mode}/mhd-magfield_glyph.pvsm". +Save the visualization image as "mhd-magfield_glyph/results/{agent_mode}/mhd-magfield_glyph.png". +(Optional, if use python script) Save the python script as "mhd-magfield_glyph/results/{agent_mode}/mhd-magfield_glyph.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/mhd-magfield_glyph/visualization_goals.txt b/main/mhd-magfield_glyph/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..ff74a0d42ea77fe9a1237124f27ab289375148a5 --- /dev/null +++ b/main/mhd-magfield_glyph/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Arrow glyphs oriented by magnetic field vector +2) Glyphs scaled by field magnitude +3) Plasma colormap applied to magnitude +4) Color bar present labeled 'Magnetic Field Magnitude +5) Dark navy background, Camera along negative x-axis, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.png b/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..c1bb3512ce32c23bdd0b97cd0cb13615b58f4b78 --- /dev/null +++ b/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:206c8c7fcad3d73b6950e2603539d94f85687f093e50b2acd28e33cef969edd9 +size 405417 diff --git a/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.pvsm b/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..972f169105c9369b338c1f065512cb87f0eddeb1 --- /dev/null +++ b/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3cd46ff898531f2bb3b703a9b81b10b056852632d05531efc5934e907f71c1bf +size 277547 diff --git a/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.py b/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..d5f5a0d0813f2078f0a191ef976bc9ef5b0866a0 --- /dev/null +++ b/main/mhd-magfield_isosurface/GS/mhd-magfield_isosurface_gs.py @@ -0,0 +1,41 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'MHD_magfield_0060.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +contour = Contour(Input=reader) +contour.ContourBy = ['POINTS', 'magnitude'] +contour.Isosurfaces = [0.8] +contour.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.0, 0.0, 0.1] + +contourDisplay = Show(contour, renderView) +contourDisplay.Representation = 'Surface' +ColorBy(contourDisplay, ('POINTS', 'bx')) + +bxLUT = GetColorTransferFunction('bx') +bxLUT.ApplyPreset('Turbo', True) + +contourDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(bxLUT, renderView) +colorBar.Title = 'Bx Component' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 16 done: {OUTPUT_IMG}") diff --git a/main/mhd-magfield_isosurface/data/mhd-magfield_isosurface.vti b/main/mhd-magfield_isosurface/data/mhd-magfield_isosurface.vti new file mode 100644 index 0000000000000000000000000000000000000000..cc228096604193cfcc96e6992dbf1131ec32ecf5 --- /dev/null +++ b/main/mhd-magfield_isosurface/data/mhd-magfield_isosurface.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d155a87cde138ba20a80ac91673e11e90f874504665085b9d34e9ea66c4c489 +size 78294594 diff --git a/main/mhd-magfield_isosurface/task_description.txt b/main/mhd-magfield_isosurface/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..be6b9bbabbacabdd6c8cf48b148aa33914d3ab16 --- /dev/null +++ b/main/mhd-magfield_isosurface/task_description.txt @@ -0,0 +1,8 @@ +Load the MHD magnetic field dataset from "mhd-magfield_isosurface/data/mhd-magfield_isosurface.vti" (VTI format, 128x128x128). +Extract an isosurface of magnetic field magnitude at threshold 0.8. Color the isosurface by the bx component using 'Turbo' colormap. +Add a color bar labeled 'Bx Component'. +Dark navy background (RGB: 0.0, 0.0, 0.1). Isometric camera view. Render at 1024x1024. +Save the paraview state as "mhd-magfield_isosurface/results/{agent_mode}/mhd-magfield_isosurface.pvsm". +Save the visualization image as "mhd-magfield_isosurface/results/{agent_mode}/mhd-magfield_isosurface.png". +(Optional, if use python script) Save the python script as "mhd-magfield_isosurface/results/{agent_mode}/mhd-magfield_isosurface.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/mhd-magfield_isosurface/visualization_goals.txt b/main/mhd-magfield_isosurface/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..4a7826d800a760cb48767ccd3a94dd064dddffe8 --- /dev/null +++ b/main/mhd-magfield_isosurface/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Isosurface at magnitude=0.8, similar pattern compared to groundtruth +2) Colored by bx component +3) Turbo colormap +4) Color bar labeled 'Bx Component' +5) Dark navy background, Isometric camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.png b/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..11fd3d020b89a807888777e2e76ef2e334446b9d --- /dev/null +++ b/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c06688eb79b888cf24ab17c4587ea76951190a853c33bc1fa1152e487ec23f0c +size 491414 diff --git a/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.pvsm b/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..201cd288aea3dfeeaf2d52fb47fdfcf24b432283 --- /dev/null +++ b/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5fa7365acd796e0c92735e2fd76092b6d798342ed140f59c926285e22072c114 +size 218985 diff --git a/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.py b/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..f061271f97479be760b3bf59e23e25a9301931dd --- /dev/null +++ b/main/mhd-magfield_volvis/GS/mhd-magfield_volvis_gs.py @@ -0,0 +1,42 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'MHD_magfield_0040.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.0, 0.0, 0.05] + +display = Show(reader, renderView) +display.Representation = 'Volume' +ColorBy(display, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Cool to Warm', True) + +magPWF = GetOpacityTransferFunction('magnitude') +magPWF.Points = [0.0, 0.0, 0.5, 0.0, + 0.5, 0.05, 0.5, 0.0, + 1.0, 0.4, 0.5, 0.0, + 1.5, 1.0, 0.5, 0.0] + +display.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'B Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 09 done: {OUTPUT_IMG}") diff --git a/main/mhd-magfield_volvis/data/mhd-magfield_volvis.vti b/main/mhd-magfield_volvis/data/mhd-magfield_volvis.vti new file mode 100644 index 0000000000000000000000000000000000000000..804b9c96aa1fbbb3ca779c37cb3c367309fdaf18 --- /dev/null +++ b/main/mhd-magfield_volvis/data/mhd-magfield_volvis.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f5784edd7ad06e6defa543330de8fcc36fa1ac1d2258085322a024f79c9409bb +size 78294594 diff --git a/main/mhd-magfield_volvis/task_description.txt b/main/mhd-magfield_volvis/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..98d8059b24c4be3c4e67e74018b3c436f3bca50a --- /dev/null +++ b/main/mhd-magfield_volvis/task_description.txt @@ -0,0 +1,9 @@ +Load the MHD magnetic field dataset from "mhd-magfield_volvis/data/mhd-magfield_volvis.vti" (VTI format, 128x128x128 grid). +Compute the magnetic field magnitude from components (bx, by, bz). Perform volume rendering of the magnitude field. +Use the 'Cool to Warm' colormap with an opacity transfer function that makes low-magnitude regions transparent and high-magnitude regions opaque. +Add a color bar labeled 'B Magnitude'. +Use a dark background (RGB: 0.0, 0.0, 0.05). Set an isometric camera view. Render at 1024x1024. +Save the paraview state as "mhd-magfield_volvis/results/{agent_mode}/mhd-magfield_volvis.pvsm". +Save the visualization image as "mhd-magfield_volvis/results/{agent_mode}/mhd-magfield_volvis.png". +(Optional, if use python script) Save the python script as "mhd-magfield_volvis/results/{agent_mode}/mhd-magfield_volvis.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/mhd-magfield_volvis/visualization_goals.txt b/main/mhd-magfield_volvis/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..b10714103ef90cdf2df9712fe36ba8b32e0240f8 --- /dev/null +++ b/main/mhd-magfield_volvis/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Volume rendering representation applied based on magnitude field, generally similar to groundtruth +2) Cool to Warm colormap +3) Opacity transfer function correctly set: low=transparent, high=opaque +4) Color bar labeled 'B Magnitude' +5) Dark background, Isometric camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.png b/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..0cc78e54503951c406e2ed522d17c6bdec646e42 --- /dev/null +++ b/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0f1572af40f34c36196c5cb55ed6b9a919d920112f7e879acd0100fe16846953 +size 229090 diff --git a/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.pvsm b/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..dc48601b4b14eff8fd7821a38af2bf68ca1c70fa --- /dev/null +++ b/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:98d7b71a0df23246ea06c9bfec9a520c4838404726b7ac71acc50a84cba88947 +size 237519 diff --git a/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.py b/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..c59374a2c0133b8cb845d9a47c42fe371483cab3 --- /dev/null +++ b/main/mhd-turbulence_glyph/GS/mhd-turbulence_glyph_gs.py @@ -0,0 +1,51 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'MHD_velocity_0010.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +sliceFilter = Slice(Input=reader) +sliceFilter.SliceType = 'Plane' +sliceFilter.SliceType.Origin = [63.5, 63.5, 64.0] +sliceFilter.SliceType.Normal = [0.0, 0.0, 1.0] +sliceFilter.UpdatePipeline() + +glyph = Glyph(Input=sliceFilter, GlyphType='Arrow') +glyph.OrientationArray = ['POINTS', 'vector'] +glyph.ScaleArray = ['POINTS', 'magnitude'] +glyph.ScaleFactor = 5.0 +glyph.MaximumNumberOfSamplePoints = 5000 +glyph.GlyphMode = 'Every Nth Point' +glyph.Stride = 4 +glyph.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.1, 0.1, 0.15] + +glyphDisplay = Show(glyph, renderView) +glyphDisplay.Representation = 'Surface' +ColorBy(glyphDisplay, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Cool to Warm', True) + +glyphDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [63.5, 63.5, 250.0] +renderView.CameraFocalPoint = [63.5, 63.5, 64.0] +renderView.CameraViewUp = [0.0, 1.0, 0.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 01 done: {OUTPUT_IMG}") diff --git a/main/mhd-turbulence_glyph/data/mhd-turbulence_glyph.vti b/main/mhd-turbulence_glyph/data/mhd-turbulence_glyph.vti new file mode 100644 index 0000000000000000000000000000000000000000..b6c44642c2bfaff7f62045f25c9d6d916b44818a --- /dev/null +++ b/main/mhd-turbulence_glyph/data/mhd-turbulence_glyph.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:823282fcbb627582c8d6bac7edc7cb8f87801ba65ff92d65a1d06df7444fd54e +size 78294594 diff --git a/main/mhd-turbulence_glyph/task_description.txt b/main/mhd-turbulence_glyph/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..ced7e02e9655b995a4ffaf9b9e00539c9d838462 --- /dev/null +++ b/main/mhd-turbulence_glyph/task_description.txt @@ -0,0 +1,11 @@ +Load the MHD turbulence velocity field dataset from "mhd-turbulence_glyph/data/mhd-turbulence_glyph.vti" (VTI format, 128x128x128 grid). +Create a slice at z=64 through the volume. On this slice, place arrow glyphs oriented by the velocity vector field and scaled by velocity magnitude. +Color the arrows using the 'Cool to Warm' colormap mapped to velocity magnitude. +Use a sampling stride of 4 to avoid overcrowding. Set the glyph scale factor to 5.0. +Add a color bar labeled 'Velocity Magnitude'. +Use a dark background (RGB: 0.1, 0.1, 0.15). +Set the camera to a top-down view looking along the negative z-axis. Render at 1024x1024 resolution. +Save the paraview state as "mhd-turbulence_glyph/results/{agent_mode}/mhd-turbulence_glyph.pvsm". +Save the visualization image as "mhd-turbulence_glyph/results/{agent_mode}/mhd-turbulence_glyph.png". +(Optional, if use python script) Save the python script as "mhd-turbulence_glyph/results/{agent_mode}/mhd-turbulence_glyph.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/mhd-turbulence_glyph/visualization_goals.txt b/main/mhd-turbulence_glyph/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..e32b961615f30afb8adb5dfd405f085a693b4aa8 --- /dev/null +++ b/main/mhd-turbulence_glyph/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Arrow glyphs oriented by velocity vector +2) Glyphs scaled by velocity magnitude +3) Color mapping using Cool to Warm colormap on magnitude +4) Color bar present with label 'Velocity Magnitude' +5) Dark background color, Top-down camera view, and Output resolution 1024x1024 \ No newline at end of file diff --git a/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.png b/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..aed5da7f36be45b7614b89a29e34cbe5bfe7b490 --- /dev/null +++ b/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c9768d1b72e91f6f5f43648981b7cc7a3f62392af528f501b2bc1a042e04c824 +size 366165 diff --git a/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.pvsm b/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..9a963677ff5a56cc09c7360d88e7e1d01659695d --- /dev/null +++ b/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f63a077c803e9b46078d48623813a1f1640d0cfb30329535c0b520a5870d8d7f +size 274602 diff --git a/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.py b/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..739d68a4c0b99b293153a1205eec9267eced0262 --- /dev/null +++ b/main/mhd-turbulence_streamline/GS/mhd-turbulence_streamline_gs.py @@ -0,0 +1,48 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'MHD_velocity_0030.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +stream = StreamTracer(Input=reader, SeedType='Line') +stream.SeedType.Point1 = [64.0, 64.0, 0.0] +stream.SeedType.Point2 = [64.0, 64.0, 127.0] +stream.SeedType.Resolution = 50 +stream.Vectors = ['POINTS', 'vector'] +stream.MaximumStreamlineLength = 200.0 +stream.UpdatePipeline() + +tube = Tube(Input=stream) +tube.Radius = 0.3 +tube.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.05, 0.05, 0.1] + +tubeDisplay = Show(tube, renderView) +tubeDisplay.Representation = 'Surface' +ColorBy(tubeDisplay, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Turbo', True) + +tubeDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 05 done: {OUTPUT_IMG}") diff --git a/main/mhd-turbulence_streamline/data/mhd-turbulence_streamline.vti b/main/mhd-turbulence_streamline/data/mhd-turbulence_streamline.vti new file mode 100644 index 0000000000000000000000000000000000000000..dce3ae3e4d7fc9354bdf112e66019e1d062e0717 --- /dev/null +++ b/main/mhd-turbulence_streamline/data/mhd-turbulence_streamline.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cea4a3655827fe96fbe3bc1677fb0424602ff179742d84326363712b050f0b8d +size 78294594 diff --git a/main/mhd-turbulence_streamline/task_description.txt b/main/mhd-turbulence_streamline/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..9a30e34ab22444e61e6e1dba8cd04b582df572c3 --- /dev/null +++ b/main/mhd-turbulence_streamline/task_description.txt @@ -0,0 +1,8 @@ +Load the MHD turbulence velocity field dataset "mhd-turbulence_streamline/data/mhd-turbulence_streamline.vti" (VTI format, 128x128x128 grid). +Generate 3D streamlines seeded from a line source along the z-axis at x=64, y=64 (from z=0 to z=127), with 50 seed points. +Color the streamlines by velocity magnitude using the 'Turbo' colormap. Set streamline tube radius to 0.3 using the Tube filter. +Add a color bar labeled 'Velocity Magnitude'. Use a dark background (RGB: 0.05, 0.05, 0.1). Set an isometric camera view. Render at 1024x1024. +Save the paraview state as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.pvsm". +Save the visualization image as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.png". +(Optional, if use python script) Save the python script as "mhd-turbulence_streamline/results/{agent_mode}/mhd-turbulence_streamline.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/mhd-turbulence_streamline/visualization_goals.txt b/main/mhd-turbulence_streamline/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..91f9abbef52ab7ee2b24ee634bb004099af51e80 --- /dev/null +++ b/main/mhd-turbulence_streamline/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Streamlines generated from line seed along z-axis, with similar pattern compared to groundtruth +2) Streamlines rendered as tubes +3) Color by velocity magnitude with Turbo colormap +4) Color bar labeled 'Velocity Magnitude' +5) Dark background, Isometric camera view, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.png b/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..a38893a4d445a15ff0dad9c2ec2bc60a83d1fc52 --- /dev/null +++ b/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dbb532d506a31fe634eb88c8c252b585ed479e94de0fe17baa6cb7a05a986c06 +size 498325 diff --git a/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.pvsm b/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..159f1a27a0facf4780bd31e0d2474ab4c7d9850b --- /dev/null +++ b/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cccdf68dc512311a488ad73f41c63b2ce921728d0de8e54b357da33a739d5c82 +size 278782 diff --git a/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.py b/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..6e5fb81a4180c4cf6baeb9e014aebbdb01f56660 --- /dev/null +++ b/main/mhd-turbulence_vorticity/GS/mhd-turbulence_vorticity_gs.py @@ -0,0 +1,55 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'MHD_velocity_0050.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +gradient = GradientOfUnstructuredDataSet(Input=reader) +gradient.ScalarArray = ['POINTS', 'vector'] +gradient.ComputeVorticity = 1 +gradient.ComputeGradient = 0 +gradient.VorticityArrayName = 'Vorticity' +gradient.UpdatePipeline() + +calc = Calculator(Input=gradient) +calc.Function = 'mag(Vorticity)' +calc.ResultArrayName = 'VorticityMagnitude' +calc.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.0, 0.0, 0.0] + +display = Show(calc, renderView) +display.Representation = 'Volume' +ColorBy(display, ('POINTS', 'VorticityMagnitude')) + +vorLUT = GetColorTransferFunction('VorticityMagnitude') +vorLUT.ApplyPreset('Plasma (matplotlib)', True) + +vorPWF = GetOpacityTransferFunction('VorticityMagnitude') +vorPWF.Points = [0.0, 0.0, 0.5, 0.0, + 0.1, 0.0, 0.5, 0.0, + 0.3, 0.1, 0.5, 0.0, + 0.6, 0.5, 0.5, 0.0, + 1.0, 1.0, 0.5, 0.0] + +display.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(vorLUT, renderView) +colorBar.Title = 'Vorticity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 12 done: {OUTPUT_IMG}") diff --git a/main/mhd-turbulence_vorticity/data/mhd-turbulence_vorticity.vti b/main/mhd-turbulence_vorticity/data/mhd-turbulence_vorticity.vti new file mode 100644 index 0000000000000000000000000000000000000000..cb09aa27a784101edb4bc60e6812c13c04dae893 --- /dev/null +++ b/main/mhd-turbulence_vorticity/data/mhd-turbulence_vorticity.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a4052ecaeecb8d89bfd3559d89873b93847f899018e754083871bbb7d4f82d56 +size 78294594 diff --git a/main/mhd-turbulence_vorticity/task_description.txt b/main/mhd-turbulence_vorticity/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..25d114dc1d97a2939d4ff330c18e1630f72d2e67 --- /dev/null +++ b/main/mhd-turbulence_vorticity/task_description.txt @@ -0,0 +1,10 @@ +Load the MHD turbulence velocity field dataset "mhd-turbulence_vorticity/data/mhd-turbulence_vorticity.vti" (VTI format, 128x128x128 grid). +Compute the vorticity field (curl of velocity) using the Gradient filter with 'Compute Vorticity' enabled. +Then compute vorticity magnitude. Perform volume rendering of vorticity magnitude using the 'Plasma (matplotlib)' colormap. +Set opacity to highlight high-vorticity regions. +Add a color bar labeled 'Vorticity Magnitude'. +Black background. Isometric camera. Render at 1024x1024. +Save the paraview state as "mhd-turbulence_vorticity/results/{agent_mode}/mhd-turbulence_vorticity.pvsm". +Save the visualization image as "mhd-turbulence_vorticity/results/{agent_mode}/mhd-turbulence_vorticity.png". +(Optional, if use python script) Save the python script as "mhd-turbulence_vorticity/results/{agent_mode}/mhd-turbulence_vorticity.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/mhd-turbulence_vorticity/visualization_goals.txt b/main/mhd-turbulence_vorticity/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..bbbecc70109b0330e0f0c85f5ce2fa6a3a2fbf63 --- /dev/null +++ b/main/mhd-turbulence_vorticity/visualization_goals.txt @@ -0,0 +1,6 @@ +1) Vorticity computation (curl of velocity), similar pattern compared to groundtruth +2) Volume rendering of vorticity magnitude +3) Plasma colormap +4) Opacity highlights high-vorticity regions +5) Color bar labeled 'Vorticity Magnitude' +6) Black background, Isometric camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.png b/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..ffe41929a6681ec63f788f0104c6445b6dc43752 --- /dev/null +++ b/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1063aacee544e885d31b7acb383aaca85ee5f39deeb442dbc67ef901494460d9 +size 541926 diff --git a/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.pvsm b/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..882d876ceff08741318c4919a311108d73d15530 --- /dev/null +++ b/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6c44c7ae1f4c43061ef3f1a96da69d20d30f22eaa8d36e438297f323c1fb6175 +size 225407 diff --git a/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.py b/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..0c2dea5bf50e88b5309f202ee21658c3167461d3 --- /dev/null +++ b/main/rti-velocity_divergence/GS/rti-velocity_divergence_gs.py @@ -0,0 +1,49 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'RTI_velocity_0040.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +gradient = GradientOfUnstructuredDataSet(Input=reader) +gradient.ScalarArray = ['POINTS', 'vector'] +gradient.ComputeDivergence = 1 +gradient.ComputeGradient = 0 +gradient.DivergenceArrayName = 'Divergence' +gradient.UpdatePipeline() + +sliceFilter = Slice(Input=gradient) +sliceFilter.SliceType = 'Plane' +sliceFilter.SliceType.Origin = [63.5, 63.5, 64.0] +sliceFilter.SliceType.Normal = [0.0, 0.0, 1.0] +sliceFilter.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [1.0, 1.0, 1.0] + +sliceDisplay = Show(sliceFilter, renderView) +sliceDisplay.Representation = 'Surface' +ColorBy(sliceDisplay, ('POINTS', 'Divergence')) + +divLUT = GetColorTransferFunction('Divergence') +divLUT.ApplyPreset('Cool to Warm', True) + +sliceDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(divLUT, renderView) +colorBar.Title = 'Velocity Divergence' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [63.5, 63.5, 250.0] +renderView.CameraFocalPoint = [63.5, 63.5, 64.0] +renderView.CameraViewUp = [0.0, 1.0, 0.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 13 done: {OUTPUT_IMG}") diff --git a/main/rti-velocity_divergence/data/rti-velocity_divergence.vti b/main/rti-velocity_divergence/data/rti-velocity_divergence.vti new file mode 100644 index 0000000000000000000000000000000000000000..f53a18bb388149a79b4edada9df7f99c07c79f57 --- /dev/null +++ b/main/rti-velocity_divergence/data/rti-velocity_divergence.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d9e278b27f5ee9af8dfa9cc5073d865633ccf7dc9cc6c52d1ebbbf4c751ebec1 +size 78294594 diff --git a/main/rti-velocity_divergence/task_description.txt b/main/rti-velocity_divergence/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..cdbe165c47eead375cd80361526845e2909a0620 --- /dev/null +++ b/main/rti-velocity_divergence/task_description.txt @@ -0,0 +1,9 @@ +Load the Rayleigh-Taylor instability velocity field from "rti-velocity_divergence/data/rti-velocity_divergence.vti" (VTI format, 128x128x128). +Compute the divergence of the velocity field using the Gradient filter with 'Compute Divergence' enabled. +Extract a slice at z=64 and color it by divergence using the 'Cool to Warm' diverging colormap (centered at 0). +Add a color bar labeled 'Velocity Divergence'. +White background. Top-down camera view along negative z-axis. Render at 1024x1024. +Save the paraview state as "rti-velocity_divergence/results/{agent_mode}/rti-velocity_divergence.pvsm". +Save the visualization image as "rti-velocity_divergence/results/{agent_mode}/rti-velocity_divergence.png". +(Optional, if use python script) Save the python script as "rti-velocity_divergence/results/{agent_mode}/rti-velocity_divergence.py". +Do not save any other files, and always save the visualization image \ No newline at end of file diff --git a/main/rti-velocity_divergence/visualization_goals.txt b/main/rti-velocity_divergence/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..e8349585f561f9e566bc5f2b282b8f7d227b9b2d --- /dev/null +++ b/main/rti-velocity_divergence/visualization_goals.txt @@ -0,0 +1,4 @@ +1) Divergence computation from velocity field, with similar pattern compared to groundtruth +2) Cool to Warm diverging colormap centered at 0 +3) Color bar labeled 'Velocity Divergence' +4) White background, Top-down camera along negative z, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.png b/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..56275a64f30f95adb6c7d24a995f78dfe3c49c56 --- /dev/null +++ b/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:665deaadfb475d448b318013bd0bf5bb807c74641ed86bfe67c9d25cb0306b41 +size 516286 diff --git a/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.pvsm b/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..b6f2c8448e8fe901e7d79c9ad03d06b87f64da18 --- /dev/null +++ b/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:96b220a805d0dec6cf8b6a8f9d54e2dc1d484a505e3982cba8202d257d5c68b7 +size 288526 diff --git a/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.py b/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..f1a0060285209723a536ea37a57de0142478dd69 --- /dev/null +++ b/main/rti-velocity_glyph/GS/rti-velocity_glyph_gs.py @@ -0,0 +1,51 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'RTI_velocity_0050.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +sliceFilter = Slice(Input=reader) +sliceFilter.SliceType = 'Plane' +sliceFilter.SliceType.Origin = [63.5, 64.0, 63.5] +sliceFilter.SliceType.Normal = [0.0, 1.0, 0.0] +sliceFilter.UpdatePipeline() + +glyph = Glyph(Input=sliceFilter, GlyphType='Arrow') +glyph.OrientationArray = ['POINTS', 'vector'] +glyph.ScaleArray = ['POINTS', 'No scale array'] +glyph.ScaleFactor = 3.0 +glyph.MaximumNumberOfSamplePoints = 5000 +glyph.GlyphMode = 'Every Nth Point' +glyph.Stride = 3 +glyph.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.0, 0.0, 0.0] + +glyphDisplay = Show(glyph, renderView) +glyphDisplay.Representation = 'Surface' +ColorBy(glyphDisplay, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Viridis (matplotlib)', True) + +glyphDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [63.5, 250.0, 63.5] +renderView.CameraFocalPoint = [63.5, 64.0, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 03 done: {OUTPUT_IMG}") diff --git a/main/rti-velocity_glyph/data/rti-velocity_glyph.vti b/main/rti-velocity_glyph/data/rti-velocity_glyph.vti new file mode 100644 index 0000000000000000000000000000000000000000..1eacafa1843bd7345c2544a3de58068468ac97ba --- /dev/null +++ b/main/rti-velocity_glyph/data/rti-velocity_glyph.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:70a1d6b812b31209bcba9b3ad727e4cded713609975f4ac32cc051319b3ee2be +size 78294594 diff --git a/main/rti-velocity_glyph/task_description.txt b/main/rti-velocity_glyph/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..6ba73cb85cee048ebb64d7f1dda3bb9d561400d5 --- /dev/null +++ b/main/rti-velocity_glyph/task_description.txt @@ -0,0 +1,11 @@ +Load the Rayleigh-Taylor instability velocity field dataset from "rti-velocity_glyph/data/rti-velocity_glyph.vti" (VTI format, 128x128x128 grid). +Create a slice at y=64 through the volume. +Place arrow glyphs on the slice, oriented by the velocity vector. Use uniform arrow size (no magnitude scaling, scale factor 3.0). +Color the arrows by velocity magnitude using the 'Viridis (matplotlib)' colormap. Use a sampling stride of 3. +Add a color bar labeled 'Velocity Magnitude'. +Use a black background. +Set the camera to view along the negative y-axis. Render at 1024x1024. +Save the paraview state as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.pvsm". +Save the visualization image as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.png". +(Optional, if use python script) Save the python script as "rti-velocity_glyph/results/{agent_mode}/rti-velocity_glyph.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/rti-velocity_glyph/visualization_goals.txt b/main/rti-velocity_glyph/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..c75a9596485707e19c2a91a3bc0742f14ab7a0db --- /dev/null +++ b/main/rti-velocity_glyph/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Arrow glyphs oriented by velocity vector +2) Uniform arrow size (no magnitude scaling) +3) Color by velocity magnitude with Viridis colormap +4) Color bar present labeled 'Velocity Magnitude' +5) Black background, Camera along negative y-axis, and Output resolution 1024x1024 \ No newline at end of file diff --git a/main/rti-velocity_slices/GS/rti-velocity_slices_gs.png b/main/rti-velocity_slices/GS/rti-velocity_slices_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..c626bed81581bbc8391c5df4a6e609feb58f38e0 --- /dev/null +++ b/main/rti-velocity_slices/GS/rti-velocity_slices_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6369840b1196712b7b18eacf20e53f0371c4cbee922ef78d12fe1cc5a131c60 +size 353957 diff --git a/main/rti-velocity_slices/GS/rti-velocity_slices_gs.pvsm b/main/rti-velocity_slices/GS/rti-velocity_slices_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..fbbdd42864e7d5f5e27100511373f93ddd3fd85c --- /dev/null +++ b/main/rti-velocity_slices/GS/rti-velocity_slices_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e91e7ad9a7d960469a42a364054287a81c358d64f6a0f22694fc5c31ad8ac2db +size 512614 diff --git a/main/rti-velocity_slices/GS/rti-velocity_slices_gs.py b/main/rti-velocity_slices/GS/rti-velocity_slices_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..6e5205b5f1d19ee52de0493521b8abd9ab3c3054 --- /dev/null +++ b/main/rti-velocity_slices/GS/rti-velocity_slices_gs.py @@ -0,0 +1,59 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'RTI_velocity_0080.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +# Slice X=64 (YZ plane) +sliceX = Slice(Input=reader) +sliceX.SliceType = 'Plane' +sliceX.SliceType.Origin = [64.0, 63.5, 63.5] +sliceX.SliceType.Normal = [1.0, 0.0, 0.0] +sliceX.UpdatePipeline() + +# Slice Y=64 (XZ plane) +sliceY = Slice(Input=reader) +sliceY.SliceType = 'Plane' +sliceY.SliceType.Origin = [63.5, 64.0, 63.5] +sliceY.SliceType.Normal = [0.0, 1.0, 0.0] +sliceY.UpdatePipeline() + +# Slice Z=64 (XY plane) +sliceZ = Slice(Input=reader) +sliceZ.SliceType = 'Plane' +sliceZ.SliceType.Origin = [63.5, 63.5, 64.0] +sliceZ.SliceType.Normal = [0.0, 0.0, 1.0] +sliceZ.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.05, 0.05, 0.05] + +for s in [sliceX, sliceY, sliceZ]: + d = Show(s, renderView) + d.Representation = 'Surface' + ColorBy(d, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Turbo', True) + +# Show color bar on last display +d.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 18 done: {OUTPUT_IMG}") diff --git a/main/rti-velocity_slices/data/rti-velocity_slices.vti b/main/rti-velocity_slices/data/rti-velocity_slices.vti new file mode 100644 index 0000000000000000000000000000000000000000..5c8d751215fbe1760750bacfbd3d62e0494b9045 --- /dev/null +++ b/main/rti-velocity_slices/data/rti-velocity_slices.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6136b152b2e819bfb93a8e679533dcbb89487b8826963c9345eb90e2b562f77 +size 78294594 diff --git a/main/rti-velocity_slices/task_description.txt b/main/rti-velocity_slices/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..85e14b06e3b3132a2c10dd0521d85cd93593352d --- /dev/null +++ b/main/rti-velocity_slices/task_description.txt @@ -0,0 +1,9 @@ +Load the Rayleigh-Taylor instability velocity field from "rti-velocity_slices/data/rti-velocity_slices.vti" (VTI format, 128x128x128). +Create three orthogonal slices: at x=64 (YZ-plane), y=64 (XZ-plane), and z=64 (XY-plane). +Color all three slices by velocity magnitude using the 'Turbo' colormap. +Add a color bar labeled 'Velocity Magnitude'. +Dark background (RGB: 0.05, 0.05, 0.05). Set an isometric camera view that shows all three slices. Render at 1024x1024. +Save the paraview state as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.pvsm". +Save the visualization image as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.png". +(Optional, if use python script) Save the python script as "rti-velocity_slices/results/{agent_mode}/rti-velocity_slices.py". +Do not save any other files, and always save the visualization image \ No newline at end of file diff --git a/main/rti-velocity_slices/visualization_goals.txt b/main/rti-velocity_slices/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..f711067a5eebf2c53143442ebe7fa5288d55528a --- /dev/null +++ b/main/rti-velocity_slices/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Three orthogonal slices at x=64, y=64, z=64, similar pattern compared to groundtruth +2) All slices colored by velocity magnitude +3) Turbo colormap +4) Color bar labeled 'Velocity Magnitude' +5) Dark background, Isometric camera showing all three slices, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.png b/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..a424d3b7fd04c6e36eb3cba556fd4770a63ad88e --- /dev/null +++ b/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c5fcc5a759031344f45fa56da6f6255fbb93bc8af4bccf0a719fb243c9bc7841 +size 382187 diff --git a/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.pvsm b/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..2e0a93606438ff73aa1bcc302cd00b7c6718a417 --- /dev/null +++ b/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:32e8c07f9298d42f9e18c5a3cb490a5dd71ad2990575a9601cf7d390842ad6af +size 230654 diff --git a/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.py b/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..ab34ad6292c5bd5b225d8c9b0d6434c69c21ddf5 --- /dev/null +++ b/main/rti-velocity_streamline/GS/rti-velocity_streamline_gs.py @@ -0,0 +1,48 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'RTI_velocity_0070.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +stream = StreamTracer(Input=reader, SeedType='Line') +stream.SeedType.Point1 = [0.0, 64.0, 0.0] +stream.SeedType.Point2 = [127.0, 64.0, 127.0] +stream.SeedType.Resolution = 200 +stream.Vectors = ['POINTS', 'vector'] +stream.MaximumStreamlineLength = 200.0 +stream.UpdatePipeline() + +tube = Tube(Input=stream) +tube.Radius = 0.4 +tube.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.02, 0.02, 0.05] + +tubeDisplay = Show(tube, renderView) +tubeDisplay.Representation = 'Surface' +ColorBy(tubeDisplay, ('POINTS', 'vz')) + +vzLUT = GetColorTransferFunction('vz') +vzLUT.ApplyPreset('Cool to Warm (Extended)', True) + +tubeDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(vzLUT, renderView) +colorBar.Title = 'Vz Component' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 06 done: {OUTPUT_IMG}") diff --git a/main/rti-velocity_streamline/data/rti-velocity_streamline.vti b/main/rti-velocity_streamline/data/rti-velocity_streamline.vti new file mode 100644 index 0000000000000000000000000000000000000000..ed2f2edf98f4917a4f16965611fdee852e5e82f8 --- /dev/null +++ b/main/rti-velocity_streamline/data/rti-velocity_streamline.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d4e97f14322a56df10aa5bb46156b2f68af485df51513c07264bd0dc48f3d40 +size 78294594 diff --git a/main/rti-velocity_streamline/task_description.txt b/main/rti-velocity_streamline/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..4020c58a4ebd5a4058b2573046b53f68f4db6645 --- /dev/null +++ b/main/rti-velocity_streamline/task_description.txt @@ -0,0 +1,9 @@ +Load the Rayleigh-Taylor instability velocity field dataset from "rti-velocity_streamline/data/rti-velocity_streamline.vti" (VTI format, 128x128x128 grid). +Generate streamlines seeded from a plane at y=64 (using a Point Cloud seed with 200 points distributed on the xz-plane at y=64). +Color the streamlines by the vz component using a 'Cool to Warm (Extended)' diverging colormap. Render streamlines as tubes with radius 0.4. +Add a color bar labeled 'Vz Component'. +Dark background (RGB: 0.02, 0.02, 0.05). Use an isometric camera view. Render at 1024x1024. +Save the paraview state as "rti-velocity_streamline/results/{agent_mode}/rti-velocity_streamline.pvsm". +Save the visualization image as "rti-velocity_streamline/results/{agent_mode}/rti-velocity_streamline.png". +(Optional, if use python script) Save the python script as "rti-velocity_streamline/results/{agent_mode}/rti-velocity_streamline.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/rti-velocity_streamline/visualization_goals.txt b/main/rti-velocity_streamline/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..87bcb65ce3454d3310d53f2fbabf910f632a50d1 --- /dev/null +++ b/main/rti-velocity_streamline/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Streamlines seeded from y=64 plane region, with similar pattern compared to groundtruth +2) Streamlines rendered as tubes +3) Color by vz with Cool to Warm diverging colormap +4) Color bar labeled 'Vz Component' +5) Dark background, Isometric camera view, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.png b/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..cffd6c9a50522163cfaf70dd5eca7e0c63225ed9 --- /dev/null +++ b/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6abe46aa5a1e83af78ff3deca6dd592c2279d6c217f4e751ccfa10835e14388 +size 198786 diff --git a/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.pvsm b/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..fcb26a76674e57a4cb8508d1ede90794c05c18a0 --- /dev/null +++ b/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0e616e2161ed884adb649134e1aa663b88be00f6f7290ce4f7e7ebfeb3fa72f3 +size 227043 diff --git a/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.py b/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..4cf9aa198c26df33113502e72697015dc2397307 --- /dev/null +++ b/main/supernova-velocity_isosurface/GS/supernova-velocity_isosurface_gs.py @@ -0,0 +1,41 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'supernova_velocity_0040.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +contour = Contour(Input=reader) +contour.ContourBy = ['POINTS', 'magnitude'] +contour.Isosurfaces = [0.7] +contour.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.0, 0.0, 0.0] + +contourDisplay = Show(contour, renderView) +contourDisplay.Representation = 'Surface' +ColorBy(contourDisplay, ('POINTS', 'vz')) + +vzLUT = GetColorTransferFunction('vz') +vzLUT.ApplyPreset('Blue to Red Rainbow', True) + +contourDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(vzLUT, renderView) +colorBar.Title = 'Vz Component' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 15 done: {OUTPUT_IMG}") diff --git a/main/supernova-velocity_isosurface/data/supernova-velocity_isosurface.vti b/main/supernova-velocity_isosurface/data/supernova-velocity_isosurface.vti new file mode 100644 index 0000000000000000000000000000000000000000..2f79de44137b18c64ef13376e38a9a49aad3dd53 --- /dev/null +++ b/main/supernova-velocity_isosurface/data/supernova-velocity_isosurface.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c952376969b9dba3515e72c454bec7f81f45b4ec5d542ef30fffe800b860de2 +size 78294594 diff --git a/main/supernova-velocity_isosurface/task_description.txt b/main/supernova-velocity_isosurface/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..4cd677e18abdba784b75bcd5c1eb54be2e8bc6d2 --- /dev/null +++ b/main/supernova-velocity_isosurface/task_description.txt @@ -0,0 +1,8 @@ +Load the supernova explosion velocity field from "supernova-velocity_isosurface/data/supernova-velocity_isosurface.vti" (VTI format, 128x128x128). +Extract an isosurface of velocity magnitude at threshold 0.7. Color the isosurface by the vz component using 'Blue to Red Rainbow' colormap. +Add a color bar labeled 'Vz Component'. +Dark background (RGB: 0.0, 0.0, 0.0). Isometric camera view. Render at 1024x1024. +Save the paraview state as "supernova-velocity_isosurface/results/{agent_mode}/supernova-velocity_isosurface.pvsm". +Save the visualization image as "supernova-velocity_isosurface/results/{agent_mode}/supernova-velocity_isosurface.png". +(Optional, if use python script) Save the python script as "supernova-velocity_isosurface/results/{agent_mode}/supernova-velocity_isosurface.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/supernova-velocity_isosurface/visualization_goals.txt b/main/supernova-velocity_isosurface/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..52959eabb18342d09a487824b406eba6d256330b --- /dev/null +++ b/main/supernova-velocity_isosurface/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Isosurface at magnitude=0.7, similar pattern compared to groundtruth +2) Colored by vz component +3) Blue to Red Rainbow colormap +4) Color bar labeled 'Vz Component' +5) Black background, Isometric camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.png b/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..08fe1312032f805f0b17c3bde90732b51754148d --- /dev/null +++ b/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:42c7ec200fd6f2e7b2e989b0fc3b9c125e38a3aef13a7f6c6f48050f9e8b6ae9 +size 74205 diff --git a/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.pvsm b/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..75047c8647602b29dd7027274feba40d2a7871d5 --- /dev/null +++ b/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a6f11867a665a6e873a97203620a4eaf8a4067b7c060ea323e2530630cbd44b +size 275372 diff --git a/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.py b/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..90f399db80a185437ff44c4abca7fffb1e09438a --- /dev/null +++ b/main/supernova-velocity_streamline/GS/supernova-velocity_streamline_gs.py @@ -0,0 +1,48 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'supernova_velocity_0030.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +stream = StreamTracer(Input=reader, SeedType='Line') +stream.SeedType.Point1 = [20.0, 20.0, 20.0] +stream.SeedType.Point2 = [108.0, 108.0, 108.0] +stream.SeedType.Resolution = 80 +stream.Vectors = ['POINTS', 'vector'] +stream.MaximumStreamlineLength = 200.0 +stream.UpdatePipeline() + +tube = Tube(Input=stream) +tube.Radius = 0.4 +tube.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.02, 0.0, 0.05] + +tubeDisplay = Show(tube, renderView) +tubeDisplay.Representation = 'Surface' +ColorBy(tubeDisplay, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Magma (matplotlib)', True) + +tubeDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [200.0, 200.0, 200.0] +renderView.CameraFocalPoint = [63.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 08 done: {OUTPUT_IMG}") diff --git a/main/supernova-velocity_streamline/data/supernova-velocity_streamline.vti b/main/supernova-velocity_streamline/data/supernova-velocity_streamline.vti new file mode 100644 index 0000000000000000000000000000000000000000..d1665b7076531ac0fdc7df76770ac02ee66df9b7 --- /dev/null +++ b/main/supernova-velocity_streamline/data/supernova-velocity_streamline.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0115c9f15fe8cf008cf35f2bff1393e155c239e48df7548880b830586b09dea1 +size 78294594 diff --git a/main/supernova-velocity_streamline/task_description.txt b/main/supernova-velocity_streamline/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..21c0f9b72b64db0b331d1d941e8b7ed033fce5d4 --- /dev/null +++ b/main/supernova-velocity_streamline/task_description.txt @@ -0,0 +1,10 @@ +Load the supernova explosion velocity field dataset from "supernova-velocity_streamline/data/supernova-velocity_streamline.vti" (VTI format, 128x128x128 grid). +Generate streamlines seeded from a line source along the diagonal from (20,20,20) to (108,108,108) with 80 seed points. +Color streamlines by velocity magnitude using the 'Magma (matplotlib)' colormap. +Render as tubes with radius 0.4. +Add a color bar labeled 'Velocity Magnitude'. +Dark background (RGB: 0.02, 0.0, 0.05). Isometric camera view. Render at 1024x1024. +Save the paraview state as "supernova-velocity_streamline/results/{agent_mode}/supernova-velocity_streamline.pvsm". +Save the visualization image as "supernova-velocity_streamline/results/{agent_mode}/supernova-velocity_streamline.png". +(Optional, if use python script) Save the python script as "supernova-velocity_streamline/results/{agent_mode}/supernova-velocity_streamline.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/supernova-velocity_streamline/visualization_goals.txt b/main/supernova-velocity_streamline/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..78810afe62f3ae1c9427b10faae8577e7cc23917 --- /dev/null +++ b/main/supernova-velocity_streamline/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Streamlines seeded from diagonal line, with similar pattern compared to groundtruth +2) Streamlines as tubes +3) Color by magnitude with Magma colormap +4) Color bar labeled 'Velocity Magnitude' +5) Dark background, Isometric camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.png b/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..2db105dacac186c865accbad307378176ae65541 --- /dev/null +++ b/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fce23c0691a08349f6f430ec3bb8009966d79f4fbc70a70bc79dd22e20ae29d3 +size 311023 diff --git a/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.pvsm b/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..fef1bcdbc9a0dc1519ccb661cc72467a275a6beb --- /dev/null +++ b/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cbff2ef428fae4b6a7e51424eeb6a66d68133c1f1536e31b69c5c43e1980e696 +size 387786 diff --git a/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.py b/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..2df934ab2733a87f2570dc2ccd4eb055a3888a75 --- /dev/null +++ b/main/tgc-velocity_contour/GS/tgc-velocity_contour_gs.py @@ -0,0 +1,54 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'TGC_temp100K_dens0.445_metalZ_velocity_0010.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +sliceFilter = Slice(Input=reader) +sliceFilter.SliceType = 'Plane' +sliceFilter.SliceType.Origin = [31.5, 31.5, 32.0] +sliceFilter.SliceType.Normal = [0.0, 0.0, 1.0] +sliceFilter.UpdatePipeline() + +contour = Contour(Input=sliceFilter) +contour.ContourBy = ['POINTS', 'magnitude'] +contour.Isosurfaces = [0.3, 0.6, 0.9, 1.2] +contour.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.9, 0.9, 0.9] + +sliceDisplay = Show(sliceFilter, renderView) +sliceDisplay.Representation = 'Surface' +ColorBy(sliceDisplay, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Viridis (matplotlib)', True) + +sliceDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +contourDisplay = Show(contour, renderView) +contourDisplay.Representation = 'Surface' +contourDisplay.AmbientColor = [1.0, 1.0, 1.0] +contourDisplay.DiffuseColor = [1.0, 1.0, 1.0] +ColorBy(contourDisplay, None) +contourDisplay.LineWidth = 2.0 + +renderView.CameraPosition = [31.5, 31.5, 100.0] +renderView.CameraFocalPoint = [31.5, 31.5, 32.0] +renderView.CameraViewUp = [0.0, 1.0, 0.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 17 done: {OUTPUT_IMG}") diff --git a/main/tgc-velocity_contour/data/tgc-velocity_contour.vti b/main/tgc-velocity_contour/data/tgc-velocity_contour.vti new file mode 100644 index 0000000000000000000000000000000000000000..af72d494f50af71dcc859e0ba82690c3f7ba4ad4 --- /dev/null +++ b/main/tgc-velocity_contour/data/tgc-velocity_contour.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e6de096f761f712fdad6a5209f78947729649d0c3ccae13e541fe2ea85397e15 +size 9787628 diff --git a/main/tgc-velocity_contour/task_description.txt b/main/tgc-velocity_contour/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..3ec2192ecc28b2b61b351c860732ae831296d7ea --- /dev/null +++ b/main/tgc-velocity_contour/task_description.txt @@ -0,0 +1,9 @@ +Load the turbulence-gravity-cooling velocity field dataset from "tgc-velocity_contour/data/tgc-velocity_contour.vti" (VTI format, 64x64x64). +Extract a slice at z=32 and color it by velocity magnitude using 'Viridis (matplotlib)' colormap. +Also add contour lines of velocity magnitude on the same slice at values [0.3, 0.6, 0.9, 1.2] using the Contour filter on the slice output. +Display contour lines in white. Add a color bar labeled 'Velocity Magnitude'. +Light gray background (RGB: 0.9, 0.9, 0.9). Top-down camera. Render at 1024x1024. +Save the paraview state as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.pvsm". +Save the visualization image as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.png". +(Optional, if use python script) Save the python script as "tgc-velocity_contour/results/{agent_mode}/tgc-velocity_contour.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/tgc-velocity_contour/visualization_goals.txt b/main/tgc-velocity_contour/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..bf5f737af8c2d89172a7be1d5194a3875603449b --- /dev/null +++ b/main/tgc-velocity_contour/visualization_goals.txt @@ -0,0 +1,6 @@ +1) Slice at z=32 colored by magnitude, similar pattern compared to groundtruth +2) Viridis colormap on slice +3) Contour lines at specified values, similar pattern compared to groundtruth +4) White contour lines +5) Color bar labeled 'Velocity Magnitude' +6) Light gray background, Top-down camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.png b/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..cf8e88c7ab6bc979585519205667c35103bdabb2 --- /dev/null +++ b/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:84cabb902be7f566efe271730caf8b4f917d8c917ff7ceb75e5646d301ac0e25 +size 588426 diff --git a/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.pvsm b/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..597dee2db9931e0ce5f9a71040e8d0494cde1431 --- /dev/null +++ b/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:94c26510d85c756110be88e9c9d8882040ad837fc0e9a3ad21a38994e0430bb7 +size 270130 diff --git a/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.py b/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..0feb05b84e257864d4b912ade70cf6ea324e5fdd --- /dev/null +++ b/main/tgc-velocity_volvis/GS/tgc-velocity_volvis_gs.py @@ -0,0 +1,42 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'TGC_temp1000K_dens4.45_metal0.1Z_velocity_0020.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.1, 0.1, 0.1] + +display = Show(reader, renderView) +display.Representation = 'Volume' +ColorBy(display, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Viridis (matplotlib)', True) + +magPWF = GetOpacityTransferFunction('magnitude') +magPWF.Points = [0.0, 0.0, 0.5, 0.0, + 0.5, 0.1, 0.5, 0.0, + 1.0, 0.4, 0.5, 0.0, + 1.7, 0.8, 0.5, 0.0] + +display.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [100.0, 100.0, 100.0] +renderView.CameraFocalPoint = [31.5, 31.5, 31.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 11 done: {OUTPUT_IMG}") diff --git a/main/tgc-velocity_volvis/data/tgc-velocity_volvis.vti b/main/tgc-velocity_volvis/data/tgc-velocity_volvis.vti new file mode 100644 index 0000000000000000000000000000000000000000..a4e6cb86a284fad4c0b714d4cee40b13b44f5f9d --- /dev/null +++ b/main/tgc-velocity_volvis/data/tgc-velocity_volvis.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1003f854e6c40db5420cfef748b77def58d4b19addb44fa06b570bdf89e17851 +size 9787628 diff --git a/main/tgc-velocity_volvis/task_description.txt b/main/tgc-velocity_volvis/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..776941b85e1594548311c6477a55b7314bc5632d --- /dev/null +++ b/main/tgc-velocity_volvis/task_description.txt @@ -0,0 +1,9 @@ +Load the turbulence-gravity-cooling velocity field dataset from "tgc-velocity_volvis/data/tgc-velocity_volvis.vti" (VTI format, 64x64x64 grid). +Perform volume rendering of velocity magnitude. Use the 'Viridis (matplotlib)' colormap. +Set opacity transfer function to gradually increase from 0 at minimum to 0.8 at maximum. +Add a color bar labeled 'Velocity Magnitude'. +Dark gray background (RGB: 0.1, 0.1, 0.1). Isometric camera view. Render at 1024x1024. +Save the paraview state as "tgc-velocity_volvis/results/{agent_mode}/tgc-velocity_volvis.pvsm". +Save the visualization image as "tgc-velocity_volvis/results/{agent_mode}/tgc-velocity_volvis.png". +(Optional, if use python script) Save the python script as "tgc-velocity_volvis/results/{agent_mode}/tgc-velocity_volvis.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/tgc-velocity_volvis/visualization_goals.txt b/main/tgc-velocity_volvis/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..ff97b0f673624ec23ea67ead8a1f21d1cf0ef871 --- /dev/null +++ b/main/tgc-velocity_volvis/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Volume rendering applied, generally similar to groundtruth +2) Viridis colormap +3) Gradual opacity transfer function +4) Color bar labeled 'Velocity Magnitude' +5) Dark gray background, Isometric camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.png b/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..bfa1dc7edb9aaed322bfe59f69d3f2d3b547ba70 --- /dev/null +++ b/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2bc854e9ad667e8ad4a76aef2ff9228c27b8111413372e53ca253421621a4b69 +size 97745 diff --git a/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.pvsm b/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..5003fbf28d6c3f851ce901d5db1f5a60c4e53dd2 --- /dev/null +++ b/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:65d67c4ecd43849be431c6455bb622149090301505e07fd2fdce4374fc42778a +size 227273 diff --git a/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.py b/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..606485d452ccc6bcd742020c0ec70f8e4f41cdd4 --- /dev/null +++ b/main/trl-velocity_isosurface/GS/trl-velocity_isosurface_gs.py @@ -0,0 +1,41 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'TRL_tcool_1.00_velocity_0030.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +contour = Contour(Input=reader) +contour.ContourBy = ['POINTS', 'magnitude'] +contour.Isosurfaces = [0.8] +contour.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.05, 0.05, 0.1] + +contourDisplay = Show(contour, renderView) +contourDisplay.Representation = 'Surface' +ColorBy(contourDisplay, ('POINTS', 'vx')) + +vxLUT = GetColorTransferFunction('vx') +vxLUT.ApplyPreset('Cool to Warm', True) + +contourDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(vxLUT, renderView) +colorBar.Title = 'Vx Component' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [350.0, 250.0, 250.0] +renderView.CameraFocalPoint = [127.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 14 done: {OUTPUT_IMG}") diff --git a/main/trl-velocity_isosurface/data/trl-velocity_isosurface.vti b/main/trl-velocity_isosurface/data/trl-velocity_isosurface.vti new file mode 100644 index 0000000000000000000000000000000000000000..e32f0d63749eabc6bcba316a85f3994b5816188b --- /dev/null +++ b/main/trl-velocity_isosurface/data/trl-velocity_isosurface.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ba8a7cfebd01ae24ee9dea666dca014d4ac3bd9574cf7f1b8c9080ac7eac3d6e +size 156588274 diff --git a/main/trl-velocity_isosurface/task_description.txt b/main/trl-velocity_isosurface/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..e3ffcb92c77152a4398bd49c536a33b5cb9b923d --- /dev/null +++ b/main/trl-velocity_isosurface/task_description.txt @@ -0,0 +1,8 @@ +Load the turbulent radiative layer velocity field dataset from "trl-velocity_isosurface/data/trl-velocity_isosurface.vti" (VTI format, 256x128x128). +Extract an isosurface of velocity magnitude at the value 0.8. Color the isosurface by the vx component using the 'Cool to Warm' colormap. +Add a color bar labeled 'Vx Component'. +Dark background (RGB: 0.05, 0.05, 0.1). Isometric camera view. Render at 1024x1024. +Save the paraview state as "trl-velocity_isosurface/results/{agent_mode}/trl-velocity_isosurface.pvsm". +Save the visualization image as "trl-velocity_isosurface/results/{agent_mode}/trl-velocity_isosurface.png". +(Optional, if use python script) Save the python script as "trl-velocity_isosurface/results/{agent_mode}/trl-velocity_isosurface.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/trl-velocity_isosurface/visualization_goals.txt b/main/trl-velocity_isosurface/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..e9d2d57c1ba52c82a1e8f40c15b36c643c13b93b --- /dev/null +++ b/main/trl-velocity_isosurface/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Isosurface extraction at magnitude=0.8, with similar pattern compared to groundtruth +2) Isosurface colored by vx component +3) Cool to Warm colormap +4) Color bar labeled 'Vx Component' +5) Dark background, Isometric camera, Output resolution 1024x1024 \ No newline at end of file diff --git a/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.png b/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.png new file mode 100644 index 0000000000000000000000000000000000000000..7ff3562d6538a207463820ec3c599134f2e58ecd --- /dev/null +++ b/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7663059942700f1efa3736892d6e8c3342b3008e2bab8c9be921e1c916b3b271 +size 430552 diff --git a/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.pvsm b/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.pvsm new file mode 100644 index 0000000000000000000000000000000000000000..7206c252e33ee0d16668d457865d22f5841e8fba --- /dev/null +++ b/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.pvsm @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:64b27fa35ae5e99817bba7e9150807555120ee4c6ababd4bb43c96c45c0c3053 +size 275402 diff --git a/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.py b/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.py new file mode 100644 index 0000000000000000000000000000000000000000..a72935347ca1e95e62dc562554e93a1790d8115c --- /dev/null +++ b/main/trl-velocity_streamline/GS/trl-velocity_streamline_gs.py @@ -0,0 +1,48 @@ +import os +from paraview.simple import * + +SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) +VTI_PATH = os.path.join(SCRIPT_DIR, '..', 'vti_data', 'TRL_tcool_0.10_velocity_0050.vti') +OUTPUT_IMG = os.path.join(SCRIPT_DIR, 'gt_image.png') +OUTPUT_STATE = os.path.join(SCRIPT_DIR, 'gt_state.pvsm') + +reader = XMLImageDataReader(FileName=[VTI_PATH]) +reader.UpdatePipeline() + +stream = StreamTracer(Input=reader, SeedType='Line') +stream.SeedType.Point1 = [0.0, 64.0, 64.0] +stream.SeedType.Point2 = [255.0, 64.0, 64.0] +stream.SeedType.Resolution = 100 +stream.Vectors = ['POINTS', 'vector'] +stream.MaximumStreamlineLength = 400.0 +stream.UpdatePipeline() + +tube = Tube(Input=stream) +tube.Radius = 0.5 +tube.UpdatePipeline() + +renderView = GetActiveViewOrCreate('RenderView') +renderView.ViewSize = [1024, 1024] +renderView.Background = [0.0, 0.0, 0.0] + +tubeDisplay = Show(tube, renderView) +tubeDisplay.Representation = 'Surface' +ColorBy(tubeDisplay, ('POINTS', 'magnitude')) + +magLUT = GetColorTransferFunction('magnitude') +magLUT.ApplyPreset('Inferno (matplotlib)', True) + +tubeDisplay.SetScalarBarVisibility(renderView, True) +colorBar = GetScalarBar(magLUT, renderView) +colorBar.Title = 'Velocity Magnitude' +colorBar.ComponentTitle = '' + +renderView.CameraPosition = [300.0, 250.0, 250.0] +renderView.CameraFocalPoint = [127.5, 63.5, 63.5] +renderView.CameraViewUp = [0.0, 0.0, 1.0] +renderView.ResetCamera() +Render() + +SaveScreenshot(OUTPUT_IMG, renderView, ImageResolution=[1024, 1024]) +SaveState(OUTPUT_STATE) +print(f"Task 07 done: {OUTPUT_IMG}") diff --git a/main/trl-velocity_streamline/data/trl-velocity_streamline.vti b/main/trl-velocity_streamline/data/trl-velocity_streamline.vti new file mode 100644 index 0000000000000000000000000000000000000000..abbef6162d479e70f8b7d15fd2d381ae62f62fd2 --- /dev/null +++ b/main/trl-velocity_streamline/data/trl-velocity_streamline.vti @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9376c5aa5393888e4b1239c2b8ba0acb7bc7e39ddb2610bea448edbb07ab0e8f +size 156588274 diff --git a/main/trl-velocity_streamline/task_description.txt b/main/trl-velocity_streamline/task_description.txt new file mode 100644 index 0000000000000000000000000000000000000000..158e6c621f4adc95f53a3df885c247df17fdf943 --- /dev/null +++ b/main/trl-velocity_streamline/task_description.txt @@ -0,0 +1,9 @@ +Load the turbulent radiative layer velocity field dataset from "trl-velocity_streamline/data/trl-velocity_streamline.vti" (VTI format, 256x128x128 grid). +Generate streamlines seeded from a line along the x-axis at y=64, z=64 (from x=0 to x=255), with 100 seed points. +Color streamlines by velocity magnitude using the 'Inferno (matplotlib)' colormap. Render as tubes with radius 0.5. +Add a color bar labeled 'Velocity Magnitude'. +Dark background (RGB: 0.0, 0.0, 0.0). Set an isometric camera view. Render at 1024x1024." +Save the paraview state as "trl-velocity_streamline/results/{agent_mode}/trl-velocity_streamline.pvsm". +Save the visualization image as "trl-velocity_streamline/results/{agent_mode}/trl-velocity_streamline.png". +(Optional, if use python script) Save the python script as "trl-velocity_streamline/results/{agent_mode}/trl-velocity_streamline.py". +Do not save any other files, and always save the visualization image. \ No newline at end of file diff --git a/main/trl-velocity_streamline/visualization_goals.txt b/main/trl-velocity_streamline/visualization_goals.txt new file mode 100644 index 0000000000000000000000000000000000000000..c7b17627390e3c7e13b472c5e5d5b810200823df --- /dev/null +++ b/main/trl-velocity_streamline/visualization_goals.txt @@ -0,0 +1,5 @@ +1) Streamlines seeded along x-axis line, with similar pattern compared to groundtruth +2) Streamlines rendered as tubes +3) Color by magnitude with Inferno colormap +4) Color bar labeled 'Velocity Magnitude' +5) Black background, Isometric camera view, Output resolution 1024x1024 \ No newline at end of file