Baikal_PreSync.log

/home/runner/simulations/TestJob01_temp_2/output-0000/TEST/sim/Baikal
Preparing:
+ set -e
+ cd output-0000-active
+ echo Checking:
Checking:
+ pwd
/home/runner/simulations/TestJob01_temp_2/output-0000/TEST/sim/Baikal/output-0000-active
+ hostname
fv-az735-601
+ date
Thu Mar 21 03:17:59 UTC 2024
+ echo Environment:
Environment:
+ export CACTUS_NUM_PROCS=2
+ CACTUS_NUM_PROCS=2
+ export CACTUS_NUM_THREADS=1
+ CACTUS_NUM_THREADS=1
+ export GMON_OUT_PREFIX=gmon.out
+ GMON_OUT_PREFIX=gmon.out
+ export OMP_NUM_THREADS=1
+ OMP_NUM_THREADS=1
+ env
+ sort
+ echo Starting:
Starting:
++ date +%s
+ export CACTUS_STARTTIME=1710991079
+ CACTUS_STARTTIME=1710991079
+ '[' 2 = 1 ']'
+ mpirun -np 2 /home/runner/simulations/TestJob01_temp_2/SIMFACTORY/exe/cactus_sim -L 3 /home/runner/simulations/TestJob01_temp_2/output-0000/arrangements/WVUThorns/Baikal/test/Baikal_PreSync.par
INFO (Cactus): Increased logging level from 0 to 3
--------------------------------------------------------------------------------

       10                                  
  1   0101       ************************  
  01  1010 10      The Cactus Code V4.15.0    
 1010 1101 011      www.cactuscode.org     
  1001 100101    ************************  
    00010101                               
     100011     (c) Copyright The Authors  
      0100      GNU Licensed. No Warranty  
      0101                                 
--------------------------------------------------------------------------------

Cactus version:    4.15.0
Compile date:      Mar 21 2024 (03:01:50)
Run date:          Mar 21 2024 (03:18:00+0000)
Run host:          fv-az735-601.3fam5btdjptetor2mdbeum0p5b.dx.internal.cloudapp.net (pid=135447)
Working directory: /home/runner/simulations/TestJob01_temp_2/output-0000/TEST/sim/Baikal
Executable:        /home/runner/simulations/TestJob01_temp_2/SIMFACTORY/exe/cactus_sim
Parameter file:    /home/runner/simulations/TestJob01_temp_2/output-0000/arrangements/WVUThorns/Baikal/test/Baikal_PreSync.par
--------------------------------------------------------------------------------

Activating thorn Cactus...Success -> active implementation Cactus
Activation requested for 
--->Time MoL Coordbase CartGrid3d Boundary StaticConformal SymBase ADMBase TmunuBase HydroBase InitBase ADMMacros IOUtil SpaceMask CoordGauge Constants LocalReduce aeilocalinterp LoopControl Carpet CarpetLib CarpetReduce CarpetRegrid2 CarpetInterp CarpetIOASCII CarpetIOScalar CarpetIOHDF5 CarpetIOBasic IllinoisGRMHD ID_converter_ILGRMHD Convert_to_HydroBase Seed_Magnetic_Fields NaNChecker Baikal NewRad SphericalSurface TOVSolver<---
Thorn Carpet requests automatic activation of MPI
Thorn Carpet requests automatic activation of Timers
Thorn CarpetIOHDF5 requests automatic activation of HDF5
Thorn CarpetLib requests automatic activation of Vectors
Thorn CarpetLib requests automatic activation of CycleClock
Thorn IllinoisGRMHD requests automatic activation of GRHayLib
Thorn LoopControl requests automatic activation of hwloc
Thorn NewRad requests automatic activation of GenericFD
Thorn HDF5 requests automatic activation of zlib
Activating thorn ADMBase...Success -> active implementation ADMBase
Activating thorn ADMMacros...Success -> active implementation ADMMacros
Activating thorn aeilocalinterp...Success -> active implementation AEILocalInterp
Activating thorn Baikal...Success -> active implementation Baikal
Activating thorn Boundary...Success -> active implementation boundary
Activating thorn Carpet...Success -> active implementation Driver
Activating thorn CarpetInterp...Success -> active implementation interp
Activating thorn CarpetIOASCII...Success -> active implementation IOASCII
Activating thorn CarpetIOBasic...Success -> active implementation IOBasic
Activating thorn CarpetIOHDF5...Success -> active implementation IOHDF5
Activating thorn CarpetIOScalar...Success -> active implementation IOScalar
Activating thorn CarpetLib...Success -> active implementation CarpetLib
Activating thorn CarpetReduce...Success -> active implementation reduce
Activating thorn CarpetRegrid2...Success -> active implementation CarpetRegrid2
Activating thorn CartGrid3d...Success -> active implementation grid
Activating thorn Constants...Success -> active implementation Constants
Activating thorn Convert_to_HydroBase...Success -> active implementation Convert_to_HydroBase
Activating thorn Coordbase...Success -> active implementation CoordBase
Activating thorn CoordGauge...Success -> active implementation CoordGauge
Activating thorn CycleClock...Success -> active implementation CycleClock
Activating thorn GenericFD...Success -> active implementation GenericFD
Activating thorn GRHayLib...Success -> active implementation GRHayLib
Activating thorn HDF5...Success -> active implementation HDF5
Activating thorn hwloc...Success -> active implementation hwloc
Activating thorn HydroBase...Success -> active implementation HydroBase
Activating thorn ID_converter_ILGRMHD...Success -> active implementation ID_converter_ILGRMHD
Activating thorn IllinoisGRMHD...Success -> active implementation IllinoisGRMHD
Activating thorn InitBase...Success -> active implementation InitBase
Activating thorn IOUtil...Success -> active implementation IO
Activating thorn LocalReduce...Success -> active implementation LocalReduce
Activating thorn LoopControl...Success -> active implementation LoopControl
Activating thorn MoL...Success -> active implementation MethodOfLines
Activating thorn MPI...Success -> active implementation MPI
Activating thorn NaNChecker...Success -> active implementation NaNChecker
Activating thorn NewRad...Success -> active implementation NewRad
Activating thorn Seed_Magnetic_Fields...Success -> active implementation seed_magnetic_fields
Activating thorn SpaceMask...Success -> active implementation SpaceMask
Activating thorn SphericalSurface...Success -> active implementation SphericalSurface
Activating thorn StaticConformal...Success -> active implementation StaticConformal
Activating thorn SymBase...Success -> active implementation SymBase
Activating thorn Time...Success -> active implementation time
Activating thorn Timers...Success -> active implementation Timers
Activating thorn TmunuBase...Success -> active implementation TmunuBase
Activating thorn TOVSolver...Success -> active implementation TOVSolver
Activating thorn Vectors...Success -> active implementation Vectors
Activating thorn zlib...Success -> active implementation zlib
WARNING[L1,P0] (Seed_Magnetic_Fields): Boolean variable is set with integer: Seed_Magnetic_Fields::enable_IllinoisGRMHD_staggered_A_fields = 1

WARNING[L1,P0] (Seed_Magnetic_Fields): Boolean variable is set with integer: Seed_Magnetic_Fields::enable_IllinoisGRMHD_staggered_A_fields = 1

INFO (IOUtil): Recovery directory 'Baikal_PreSync' doesn't exist
WARNING[L1,P1] (Seed_Magnetic_Fields): Boolean variable is set with integer: Seed_Magnetic_Fields::enable_IllinoisGRMHD_staggered_A_fields = 1

--------------------------------------------------------------------------------
  if (recover initial data)
    Recover parameters
  endif

  Startup routines
    [CCTK_STARTUP]
      Carpet::MultiModel_Startup: Multi-model Startup routine
      Baikal::Banner_Baikal: [meta] Output ASCII art banner
      Baikal::RegisterSlicing_Baikal: [meta] Register 3+1 slicing condition
      CycleClock::CycleClock_Setup: Set up CycleClock
      LoopControl::LC_setup: Set up LoopControl
      Timers::Timer_Startup: Prepare hierarchical timers
      Carpet::Driver_Startup: Startup routine
      IOUtil::IOUtil_Startup: Startup routine
      CarpetIOScalar::CarpetIOScalarStartup: [global] Startup routine
      CarpetInterp::CarpetInterpStartup: Startup routine
      CarpetReduce::CarpetReduceStartup: Startup routine
      CartGrid3D::SymmetryStartup: Register GH Extension for GridSymmetry
      CoordBase::CoordBase_Startup: Register a GH extension to store the coordinate system handles
      AEILocalInterp::AEILocalInterp_U_Startup: register CCTK_InterpLocalUniform() interpolation operators
      HydroBase::HydroBase_StartUp: Startup banner
      CarpetIOASCII::CarpetIOASCIIStartup: [global] Startup routine
      LocalReduce::LocalReduce_Startup: Startup routine
      CarpetIOBasic::CarpetIOBasicStartup: [global] Startup routine
      MoL::MoL_Startup: Startup banner
      SymBase::SymBase_Startup: Register GH Extension for SymBase
      CarpetIOHDF5::CarpetIOHDF5_Startup: Startup routine
      Vectors::Vectors_Startup: Print startup message
      GROUP hwloc_startup: hwloc startup group
        hwloc::hwloc_version: Output hwloc version

  Startup routines which need an existing grid hierarchy
    [CCTK_WRAGH]
      ADMBase::Einstein_InitSymBound: [global] Set up GF symmetries
      Boundary::Boundary_RegisterBCs: [global] Register boundary conditions that this thorn provides
      GROUP Driver_BoundarySelect: Group for functions which select BCs for variables and groups.
        Baikal::specify_Driver_BoundaryConditions_Baikal: [level] Register boundary conditions with PreSync
        IllinoisGRMHD::IllinoisGRMHD_specify_driver_BCs: [meta] Register boundary conditions with PreSync
      CarpetRegrid2::CarpetRegrid2_Initialise: [global] Initialise locations of refined regions
      CartGrid3D::RegisterCartGrid3DCoords: [meta] Register coordinates for the Cartesian grid
      CoordGauge::Einstein_ActivateSlicing: Initialize slicing, setup priorities for mixed slicings
      CoordGauge::Einstein_SetNextSlicing: Identify the slicing for the next iteration
      IllinoisGRMHD::IllinoisGRMHD_backward_compatible_initialize: [global] Set up the GRHayL structs and read the table for tabulated EOS.
      MoL::MoL_SetupIndexArrays: Set up the MoL bookkeeping index arrays
      MoL::MoL_SetScheduleStatus: [global] Set the flag so it is ok to register with MoL
      TmunuBase::TmunuBase_SetStressEnergyState: [global] Set the stress_energy_state variable
      GROUP MoL_Register: The group where physics thorns register variables with MoL
        Baikal::MoL_registration_Baikal: [meta] Register variables for MoL
        IllinoisGRMHD::IllinoisGRMHD_RegisterVars: [meta] Register evolved, rhs variables in IllinoisGRMHD for MoL
      SpaceMask::MaskSym: [global] Set grid symmetries for mask
      SpaceMask::MaskSym_emask: [global] Set grid symmetries for emask (compatibility mode)
      GROUP SymBase_Wrapper: Wrapper group for SymBase
        GROUP SymmetryRegister: Register your symmetries here
          CartGrid3D::CartGrid3D_RegisterSymmetryBoundaries: [meta] Register symmetry boundaries
        SymBase::SymBase_Statistics: Print symmetry boundary face descriptions
      TOVSolver::TOV_C_AllocateMemory: [global] Allocate memory for TOVSolver_C
      MoL::MoL_ReportNumberVariables: [meta] Report how many of each type of variable there are
  Parameter checking routines
    [CCTK_PARAMCHECK]
      ADMBase::ADMBase_ParamCheck: [global] Check consistency of parameters
      Boundary::Boundary_Check: Check dimension of grid variables
      Carpet::CarpetParamCheck: Parameter checking routine
      CarpetLib::CarpetLib_test_prolongate_3d_rf2: [global] Test prolongation operators
      CarpetRegrid2::CarpetRegrid2_ParamCheck: Check parameters
      CartGrid3D::ParamCheck_CartGrid3D: Check coordinates for CartGrid3D
      MoL::MoL_ParamCheck: Basic parameter checking
      Seed_Magnetic_Fields::Seed_Magnetic_Fields_paramcheck: Warn about usage of deprecated parameter options.
      SphericalSurface::SphericalSurface_ParamCheck: [global] Check that all surface names are unique
      TOVSolver::TOV_C_ParamCheck: [global] Check parameters
      TmunuBase::TmunuBase_ParamCheck: [global] Check that no deprecated parameters are used.
      Vectors::Vectors_Test: Run correctness tests.

  Initialisation
    if (NOT (recover initial data AND recovery_mode is 'strict'))
      [CCTK_PREREGRIDINITIAL]
      Set up grid hierarchy
      [CCTK_POSTREGRIDINITIAL]
        CartGrid3D::SpatialCoordinates: Set Coordinates after regridding
        GROUP MaskBase_SetupMask: Set up the weight function
          GROUP MaskBase_SetupMaskAll: Set up the weight function
            CarpetReduce::MaskBase_AllocateMask: [global] Allocate the weight function
            CarpetReduce::MaskBase_InitMask: [global] [loop-local] Initialise the weight function
            GROUP SetupIMaskInternal: Set up the integer weight function (schedule other routines in here)
              CarpetReduce::CoordBase_SetupMask: [global] [loop-local] Set up the outer boundaries of the weight function
              CarpetReduce::CarpetMaskSetup: [global] [loop-singlemap] Set up the weight function for the restriction regions
            GROUP SetupIMask: Set up the integer weight function (schedule other routines in here)
            CarpetReduce::MaskBase_SetMask: [global] [loop-local] Set the weight function
            GROUP SetupMask: Set up the real weight function (schedule other routines in here)
            CarpetReduce::MaskBase_TestMask: [global] Test the weight function
        GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
        SpaceMask::MaskZero: Initialise mask to zero
        SpaceMask::MaskOne: Set mask to one
      [CCTK_BASEGRID]
        ADMBase::ADMBase_SetShiftStateOn: Set the shift_state variable to 1
        ADMBase::ADMBase_SetDtLapseStateOn: Set the dtlapse_state variable to 1
        ADMBase::ADMBase_SetDtShiftStateOn: Set the dtshift_state variable to 1
        ADMMacros::ADMMacros_SetLocalSpatialOrder: Initialize the local_spatial_order
        Baikal::Symmetry_registration_oldCartGrid3D_Baikal: [global] Register symmetries, the CartGrid3D way.
        Baikal::zero_rhss_Baikal: Idea from Lean: set all rhs functions to zero to prevent spurious nans
        CartGrid3D::SpatialSpacings: Set up ranges for spatial 3D Cartesian coordinates (on all grids)
        CartGrid3D::SpatialCoordinates: Set up spatial 3D Cartesian coordinates on the GH
        SphericalSurface::SphericalSurface_SetupRes: [global] [loop-local] Set surface resolution automatically
        IllinoisGRMHD::IllinoisGRMHD_InitSymBound: Schedule symmetries
        NaNChecker::NaNChecker_ResetCounter: [global] Reset the NaNChecker::NaNsFound counter
        SpaceMask::MaskZero: Initialise mask to zero
        SpaceMask::MaskOne: Set old style mask to one
        SphericalSurface::SphericalSurface_Setup: [global] Calculate surface coordinate descriptors
        GROUP MaskBase_SetupMask: Set up the weight function
          GROUP MaskBase_SetupMaskAll: Set up the weight function
            CarpetReduce::MaskBase_AllocateMask: [global] Allocate the weight function
            CarpetReduce::MaskBase_InitMask: [global] [loop-local] Initialise the weight function
            GROUP SetupIMaskInternal: Set up the integer weight function (schedule other routines in here)
              CarpetReduce::CoordBase_SetupMask: [global] [loop-local] Set up the outer boundaries of the weight function
              CarpetReduce::CarpetMaskSetup: [global] [loop-singlemap] Set up the weight function for the restriction regions
            GROUP SetupIMask: Set up the integer weight function (schedule other routines in here)
            CarpetReduce::MaskBase_SetMask: [global] [loop-local] Set the weight function
            GROUP SetupMask: Set up the real weight function (schedule other routines in here)
            CarpetReduce::MaskBase_TestMask: [global] Test the weight function
        SphericalSurface::SphericalSurface_Set: [global] Set surface radii to be used for initial setup in other thorns
        GROUP SphericalSurface_HasBeenSet: Set the spherical surfaces before this group, and use it afterwards
          SphericalSurface::SphericalSurface_CheckState: [global] Test the state of the spherical surfaces
        SymBase::SymBase_Check: Check whether the driver set up the grid consistently
        Time::Time_Initialise: [global] Initialise Time variables
        Time::TemporalSpacings: [singlemap] Set timestep based on Courant condition (courant_static)
      [CCTK_INITIAL]
        StaticConformal::StaticConformal_InitialiseState: Set the conformal_state variable to 0
        GROUP ADMBase_InitialData: Schedule group for calculating ADM initial data
        GROUP ADMBase_InitialGauge: Schedule group for the ADM initial gauge condition
          ADMBase::ADMBase_DtLapseZero: Set the dtlapse to 0 at all points
          ADMBase::ADMBase_DtShiftZero: Set the dtshift to 0 at all points
        GROUP HydroBase_Initial: HydroBase initial data group
          HydroBase::HydroBase_Zero: Set up vacuum hydro initial data
          GROUP TOV_Initial_Data: Group for the TOV initial data
            TOVSolver::TOV_C_Integrate_RHS: [global] Integrate the 1d equations for the TOV star
            TOVSolver::TOV_C_Exact: Set up the 3d quantities for the TOV star
        GROUP ADMBase_PostInitial: Schedule group for modifying the ADM initial data, such as e.g. adding noise
        CarpetIOASCII::CarpetIOASCIIInit: [global] Initialisation routine
        CarpetIOBasic::CarpetIOBasicInit: [global] Initialisation routine
        CarpetIOHDF5::CarpetIOHDF5_Init: [global] Initialisation routine
        CarpetIOScalar::CarpetIOScalarInit: [global] Initialisation routine
        Baikal::ADM_to_BSSN_Baikal: [local] Convert initial data into BSSN variables
        Seed_Magnetic_Fields::Seed_Magnetic_Fields: Set up TOV seed magnetic fields.
        MoL::MoL_StartLoop: [level] Initialise the step size control
        GROUP HydroBase_Prim2ConInitial: Recover the conservative variables from the primitive variables
          GROUP IllinoisGRMHD_Prim2Con2Prim: Convert HydroBase initial data to IllinoisGRMHD variables
            IllinoisGRMHD::convert_HydroBase_to_IllinoisGRMHD: Convert HydroBase initial data (ID) to IllinoisGRMHD variables
            IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A
            GROUP IllinoisGRMHD_prims_to_conservs: Compute conservative variables from primitives
              IllinoisGRMHD::IllinoisGRMHD_hybrid_prims_to_conservs: Hybrid version of IllinoisGRMHD_prims_to_conservs
            GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
              IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
            IllinoisGRMHD::convert_IllinoisGRMHD_to_HydroBase: Convert IllinoisGRMHD-native variables to HydroBase
        GROUP Baikal_ApplyBCs: Apply boundary conditions
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
      [CCTK_POSTINITIAL]
        CarpetIOHDF5::CarpetIOHDF5_CloseFiles: [global] Close all filereader input files
        IllinoisGRMHD::IllinoisGRMHD_backward_compatible_data: Copy data to deprecated variables
        GROUP MoL_PostStepModify: The group for physics thorns to schedule enforcing constraints
        GROUP MoL_PostStep: Ensure that everything is correct after the initial data have been set up
          Baikal::specify_BoundaryConditions_evolved_gfs_Baikal: [level] Apply boundary conditions and perform AMR+interprocessor synchronization
          Baikal::floor_the_lapse_Baikal: Set lapse = max(lapse_floor, lapse)
          Baikal::enforce_detgammahat_constraint_Baikal: Enforce detgammabar = detgammahat (= 1 in Cartesian)
          GROUP Baikal_ApplyBCs: Group for applying boundary conditions
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion. Useful for diagnostics.
          GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
          GROUP HydroBase_PostStep: Post step tasks for hydro thorns
            GROUP HydroBase_Boundaries: HydroBase-internal Boundary conditions group
              GROUP HydroBase_Select_Boundaries: Group to schedule the boundary condition functions
              GROUP HydroBase_ApplyBCs: Apply the boundary conditions of HydroBase
                GROUP BoundaryConditions: Execute all boundary conditions
                  Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                  CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
                Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
            GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
              GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
                IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
                IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
                IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
                GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
                  IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
                GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
                  IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
          GROUP SetTmunu: Group for calculating the stress-energy tensor
            TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
            GROUP AddToTmunu: Add to the stress-energy tensor here
              IllinoisGRMHD::IllinoisGRMHD_compute_Tmunu: Compute stress-energy tensor
        GROUP MoL_PseudoEvolution: Calculate pseudo-evolved quantities
          GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
          Baikal::T4DD_to_T4UU_Baikal: [local] MoL_PseudoEvolution: Compute T4UU from T4DD (provided in eT?? from TmunuBase), needed for BSSN constraints
          Baikal::Baikal_BSSN_constraints: [local] Compute BSSN (Hamiltonian and momentum) constraints, at finite-differencing order: 4
          Baikal::specify_BoundaryConditions_aux_gfs_Baikal: [level] Enforce symmetry BCs in constraint computation
          Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion in MoL_PseudoEvolution. Needed for proper HydroBase integration.
          GROUP Baikal_auxgfs_ApplyBCs: Apply boundary conditions
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
      Initialise finer grids recursively
      Restrict from finer grids
      [CCTK_POSTRESTRICTINITIAL]
        GROUP MoL_PostStep: Ensure that everything is correct after restriction
          Baikal::specify_BoundaryConditions_evolved_gfs_Baikal: [level] Apply boundary conditions and perform AMR+interprocessor synchronization
          Baikal::floor_the_lapse_Baikal: Set lapse = max(lapse_floor, lapse)
          Baikal::enforce_detgammahat_constraint_Baikal: Enforce detgammabar = detgammahat (= 1 in Cartesian)
          GROUP Baikal_ApplyBCs: Group for applying boundary conditions
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion. Useful for diagnostics.
          GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
          GROUP HydroBase_PostStep: Post step tasks for hydro thorns
            GROUP HydroBase_Boundaries: HydroBase-internal Boundary conditions group
              GROUP HydroBase_Select_Boundaries: Group to schedule the boundary condition functions
              GROUP HydroBase_ApplyBCs: Apply the boundary conditions of HydroBase
                GROUP BoundaryConditions: Execute all boundary conditions
                  Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                  CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
                Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
            GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
              GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
                IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
                IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
                IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
                GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
                  IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
                GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
                  IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
          GROUP SetTmunu: Group for calculating the stress-energy tensor
            TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
            GROUP AddToTmunu: Add to the stress-energy tensor here
              IllinoisGRMHD::IllinoisGRMHD_compute_Tmunu: Compute stress-energy tensor
        GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
      [CCTK_POSTPOSTINITIAL]
        GROUP Con2Prim: Convert from conservative to primitive variables (might be redundant)
          GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
            IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
            IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
            IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
            GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
              IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
            GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
              IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
        IllinoisGRMHD::IllinoisGRMHD_set_gz_symmetries: Compute post-initialdata quantities
        TOVSolver::TOV_C_FreeMemory: [global] Free memory from TOVSolver_C
      [CCTK_POSTSTEP]
        GROUP zzz_NaNChecker_NaNCheck: Check for NaNs and count them in NaNChecker::NaNsFound
          NaNChecker::NaNChecker_NaNCheck_Prepare: [level] Prepare data structures to check for NaNs
          NaNChecker::NaNChecker_NaNCheck_Check: [local] Check for NaNs
          NaNChecker::NaNChecker_NaNCheck_Finish: [level] Count NaNs in NaNChecker::NaNsFound
        NaNChecker::NaNChecker_TakeAction: [global] [loop-level] Output NaNChecker::NaNmask and take action according to NaNChecker::action_if_found
        SpaceMask::CheckMask: Ensure that all mask values are legal
        SphericalSurface::SphericalSurface_Set: [global] Set surface radii
        GROUP SphericalSurface_HasBeenSet: Set the spherical surfaces before this group, and use it afterwards
          SphericalSurface::SphericalSurface_CheckState: [global] Test the state of the spherical surfaces
    endif
    if (recover initial data)
      [CCTK_BASEGRID]
        ADMBase::ADMBase_SetShiftStateOn: Set the shift_state variable to 1
        ADMBase::ADMBase_SetDtLapseStateOn: Set the dtlapse_state variable to 1
        ADMBase::ADMBase_SetDtShiftStateOn: Set the dtshift_state variable to 1
        ADMMacros::ADMMacros_SetLocalSpatialOrder: Initialize the local_spatial_order
        Baikal::Symmetry_registration_oldCartGrid3D_Baikal: [global] Register symmetries, the CartGrid3D way.
        Baikal::zero_rhss_Baikal: Idea from Lean: set all rhs functions to zero to prevent spurious nans
        CartGrid3D::SpatialSpacings: Set up ranges for spatial 3D Cartesian coordinates (on all grids)
        CartGrid3D::SpatialCoordinates: Set up spatial 3D Cartesian coordinates on the GH
        SphericalSurface::SphericalSurface_SetupRes: [global] [loop-local] Set surface resolution automatically
        IllinoisGRMHD::IllinoisGRMHD_InitSymBound: Schedule symmetries
        NaNChecker::NaNChecker_ResetCounter: [global] Reset the NaNChecker::NaNsFound counter
        SpaceMask::MaskZero: Initialise mask to zero
        SpaceMask::MaskOne: Set old style mask to one
        SphericalSurface::SphericalSurface_Setup: [global] Calculate surface coordinate descriptors
        GROUP MaskBase_SetupMask: Set up the weight function
          GROUP MaskBase_SetupMaskAll: Set up the weight function
            CarpetReduce::MaskBase_AllocateMask: [global] Allocate the weight function
            CarpetReduce::MaskBase_InitMask: [global] [loop-local] Initialise the weight function
            GROUP SetupIMaskInternal: Set up the integer weight function (schedule other routines in here)
              CarpetReduce::CoordBase_SetupMask: [global] [loop-local] Set up the outer boundaries of the weight function
              CarpetReduce::CarpetMaskSetup: [global] [loop-singlemap] Set up the weight function for the restriction regions
            GROUP SetupIMask: Set up the integer weight function (schedule other routines in here)
            CarpetReduce::MaskBase_SetMask: [global] [loop-local] Set the weight function
            GROUP SetupMask: Set up the real weight function (schedule other routines in here)
            CarpetReduce::MaskBase_TestMask: [global] Test the weight function
        SphericalSurface::SphericalSurface_Set: [global] Set surface radii to be used for initial setup in other thorns
        GROUP SphericalSurface_HasBeenSet: Set the spherical surfaces before this group, and use it afterwards
          SphericalSurface::SphericalSurface_CheckState: [global] Test the state of the spherical surfaces
        SymBase::SymBase_Check: Check whether the driver set up the grid consistently
        Time::Time_Initialise: [global] Initialise Time variables
        Time::TemporalSpacings: [singlemap] Set timestep based on Courant condition (courant_static)
      [CCTK_RECOVER_VARIABLES]
        IOUtil::IOUtil_RecoverGH: [level] Checkpoint recovery routine
      [CCTK_POST_RECOVER_VARIABLES]
        CarpetIOHDF5::CarpetIOHDF5_InitCheckpointingIntervals: [global] Initialisation of checkpointing intervals after recovery
        CarpetIOHDF5::CarpetIOHDF5_CloseFiles: [meta] Close all initial data checkpoint files after recovery
        GROUP MaskBase_SetupMask: Set up the weight function
          GROUP MaskBase_SetupMaskAll: Set up the weight function
            CarpetReduce::MaskBase_AllocateMask: [global] Allocate the weight function
            CarpetReduce::MaskBase_InitMask: [global] [loop-local] Initialise the weight function
            GROUP SetupIMaskInternal: Set up the integer weight function (schedule other routines in here)
              CarpetReduce::CoordBase_SetupMask: [global] [loop-local] Set up the outer boundaries of the weight function
              CarpetReduce::CarpetMaskSetup: [global] [loop-singlemap] Set up the weight function for the restriction regions
            GROUP SetupIMask: Set up the integer weight function (schedule other routines in here)
            CarpetReduce::MaskBase_SetMask: [global] [loop-local] Set the weight function
            GROUP SetupMask: Set up the real weight function (schedule other routines in here)
            CarpetReduce::MaskBase_TestMask: [global] Test the weight function
        GROUP MoL_PostStep: Ensure that everything is correct after recovery
          Baikal::specify_BoundaryConditions_evolved_gfs_Baikal: [level] Apply boundary conditions and perform AMR+interprocessor synchronization
          Baikal::floor_the_lapse_Baikal: Set lapse = max(lapse_floor, lapse)
          Baikal::enforce_detgammahat_constraint_Baikal: Enforce detgammabar = detgammahat (= 1 in Cartesian)
          GROUP Baikal_ApplyBCs: Group for applying boundary conditions
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion. Useful for diagnostics.
          GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
          GROUP HydroBase_PostStep: Post step tasks for hydro thorns
            GROUP HydroBase_Boundaries: HydroBase-internal Boundary conditions group
              GROUP HydroBase_Select_Boundaries: Group to schedule the boundary condition functions
              GROUP HydroBase_ApplyBCs: Apply the boundary conditions of HydroBase
                GROUP BoundaryConditions: Execute all boundary conditions
                  Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                  CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
                Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
            GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
              GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
                IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
                IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
                IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
                GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
                  IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
                GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
                  IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
          GROUP SetTmunu: Group for calculating the stress-energy tensor
            TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
            GROUP AddToTmunu: Add to the stress-energy tensor here
              IllinoisGRMHD::IllinoisGRMHD_compute_Tmunu: Compute stress-energy tensor
        GROUP zzz_NaNChecker_NaNCheck: Check for NaNs and count them in NaNChecker::NaNsFound
          NaNChecker::NaNChecker_NaNCheck_Prepare: [level] Prepare data structures to check for NaNs
          NaNChecker::NaNChecker_NaNCheck_Check: [local] Check for NaNs
          NaNChecker::NaNChecker_NaNCheck_Finish: [level] Count NaNs in NaNChecker::NaNsFound
        NaNChecker::NaNChecker_TakeAction: [global] [loop-level] Output NaNChecker::NaNmask and take action according to NaNChecker::action_if_found
    endif
    if (checkpoint initial data)
      [CCTK_CPINITIAL]
        CarpetIOHDF5::CarpetIOHDF5_InitialDataCheckpoint: [meta] Initial data checkpoint routine
    endif
    if (analysis)
      [CCTK_ANALYSIS]
        CarpetLib::CarpetLib_printtimestats: [global] Print timing statistics if desired
        CarpetLib::CarpetLib_printmemstats: [global] Print memory statistics if desired
        IllinoisGRMHD::convert_IllinoisGRMHD_to_HydroBase: [global] [loop-local] Convert IllinoisGRMHD-native variables to HydroBase
        LoopControl::LC_statistics_analysis: [meta] Output LoopControl statistics
  endif
  Output grid variables

  do loop over timesteps
    [CCTK_PREREGRID]
    Change grid hierarchy
    [CCTK_POSTREGRID]
      CartGrid3D::SpatialCoordinates: Set Coordinates after regridding
      GROUP MaskBase_SetupMask: Set up the weight function
        GROUP MaskBase_SetupMaskAll: Set up the weight function
          CarpetReduce::MaskBase_AllocateMask: [global] Allocate the weight function
          CarpetReduce::MaskBase_InitMask: [global] [loop-local] Initialise the weight function
          GROUP SetupIMaskInternal: Set up the integer weight function (schedule other routines in here)
            CarpetReduce::CoordBase_SetupMask: [global] [loop-local] Set up the outer boundaries of the weight function
            CarpetReduce::CarpetMaskSetup: [global] [loop-singlemap] Set up the weight function for the restriction regions
          GROUP SetupIMask: Set up the integer weight function (schedule other routines in here)
          CarpetReduce::MaskBase_SetMask: [global] [loop-local] Set the weight function
          GROUP SetupMask: Set up the real weight function (schedule other routines in here)
          CarpetReduce::MaskBase_TestMask: [global] Test the weight function
      GROUP MoL_PostStep: Ensure that everything is correct after regridding
        Baikal::specify_BoundaryConditions_evolved_gfs_Baikal: [level] Apply boundary conditions and perform AMR+interprocessor synchronization
        Baikal::floor_the_lapse_Baikal: Set lapse = max(lapse_floor, lapse)
        Baikal::enforce_detgammahat_constraint_Baikal: Enforce detgammabar = detgammahat (= 1 in Cartesian)
        GROUP Baikal_ApplyBCs: Group for applying boundary conditions
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
        Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion. Useful for diagnostics.
        GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
        GROUP HydroBase_PostStep: Post step tasks for hydro thorns
          GROUP HydroBase_Boundaries: HydroBase-internal Boundary conditions group
            GROUP HydroBase_Select_Boundaries: Group to schedule the boundary condition functions
            GROUP HydroBase_ApplyBCs: Apply the boundary conditions of HydroBase
              GROUP BoundaryConditions: Execute all boundary conditions
                Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
            GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
              IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
              IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
              IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
              GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
                IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
              GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
                IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
        GROUP SetTmunu: Group for calculating the stress-energy tensor
          TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
          GROUP AddToTmunu: Add to the stress-energy tensor here
            IllinoisGRMHD::IllinoisGRMHD_compute_Tmunu: Compute stress-energy tensor
      GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
      SpaceMask::MaskZero: Initialise mask to zero
      SpaceMask::MaskOne: Set mask to one
    Rotate timelevels
    iteration = iteration+1
    t = t+dt
    [CCTK_PRESTEP]
      CoordGauge::Einstein_SetNextSlicing: Identify the slicing for the next iteration
      LoopControl::LC_steer: [meta] Update LoopControl algorithm preferences
      NaNChecker::NaNChecker_ResetCounter: [global] Reset the NaNChecker::NaNsFound counter
    [CCTK_EVOL]
      MoL::MoL_StartLoop: [level] Initialise the step size control
      while (MoL::MoL_Stepsize_Bad)
        GROUP MoL_Evolution: A single Cactus evolution step using MoL
          GROUP MoL_StartStep: MoL internal setup for the evolution step
            MoL::MoL_SetCounter: [level] Set the counter for the ODE method to loop over
            MoL::MoL_SetTime: [level] Ensure the correct time and timestep are used
            MoL::MoL_AllocateScratchSpace: [level] Allocate storage for scratch levels
          GROUP MoL_PreStep: Physics thorns can schedule preloop setup routines in here
          MoL::MoL_AllocateScratch: Allocate sufficient space for array scratch variables
          MoL::MoL_InitialCopy: Ensure the data is in the correct timelevel
          MoL::MoL_UpdateValidForInitialCopy: Automatically update valid regions based on MoL
          while (MoL::MoL_Intermediate_Step)
            GROUP MoL_Step: The loop over the intermediate steps for the ODE integrator
              MoL::MoL_InitRHS: Initialise the RHS functions
              GROUP MoL_CalcRHS: Physics thorns schedule the calculation of the discrete spatial operator in here
                Baikal::Baikal_T4UU: MoL: Compute T4UU from T4DD (provided in eT?? from TmunuBase), needed for BSSN RHSs.
                Baikal::Baikal_Ricci: MoL: Compute Ricci tensor, needed for BSSN RHSs, at finite-differencing order: 4
                Baikal::Baikal_RHS: MoL: Evaluate BSSN RHSs, at finite-differencing order: 4
                Baikal::specify_NewRad_BoundaryConditions_parameters_Baikal: NewRad boundary conditions, scheduled right after RHS eval.
                GROUP HydroBase_RHS: Groups for scheduling tasks for calculating RHS of hydro variables
                GROUP IllinoisGRMHD_RHS: Evaluate RHSs GRHD equations
                  GROUP IllinoisGRMHD_evaluate_sources_rhs: Evaluate source terms in GRMHD RHSs
                    IllinoisGRMHD::IllinoisGRMHD_hybrid_evaluate_sources_rhs: Hybrid version of IllinoisGRMHD_evaluate_sources_rhs
                  GROUP IllinoisGRMHD_evaluate_fluxes_rhs: Evaluate flux terms in GRMHD RHSs
                    IllinoisGRMHD::IllinoisGRMHD_hybrid_evaluate_fluxes_rhs: Hybrid version of IllinoisGRMHD_evaluate_fluxes_rhs
                  IllinoisGRMHD::IllinoisGRMHD_evaluate_phitilde_and_A_gauge_rhs: Evaluate phitilde RHS and gauge contributions to A_i RHS
              GROUP MoL_PostRHS: Modify RHS functions
                IllinoisGRMHD::IllinoisGRMHD_backward_compatible_data: Copy data to deprecated variables
              GROUP MoL_RHSBoundaries: Any 'final' modifications to the RHS functions (boundaries etc.)
              MoL::MoL_Add: Updates calculated with the efficient Runge-Kutta 4 method
              MoL::MoL_UpdateValidForAdd: Automatically update valid regions based on MoL
              MoL::MoL_DecrementCounter: [level] Alter the counter number
              MoL::MoL_ResetTime: [level] If necessary, change the time
              GROUP MoL_PostStepModify: The group for physics thorns to schedule enforcing constraints
              GROUP MoL_PostStep: The group for physics thorns to schedule boundary calls etc.
                Baikal::specify_BoundaryConditions_evolved_gfs_Baikal: [level] Apply boundary conditions and perform AMR+interprocessor synchronization
                Baikal::floor_the_lapse_Baikal: Set lapse = max(lapse_floor, lapse)
                Baikal::enforce_detgammahat_constraint_Baikal: Enforce detgammabar = detgammahat (= 1 in Cartesian)
                GROUP Baikal_ApplyBCs: Group for applying boundary conditions
                  GROUP BoundaryConditions: Execute all boundary conditions
                    Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                    CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
                  Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
                Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion. Useful for diagnostics.
                GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
                GROUP HydroBase_PostStep: Post step tasks for hydro thorns
                  GROUP HydroBase_Boundaries: HydroBase-internal Boundary conditions group
                    GROUP HydroBase_Select_Boundaries: Group to schedule the boundary condition functions
                    GROUP HydroBase_ApplyBCs: Apply the boundary conditions of HydroBase
                      GROUP BoundaryConditions: Execute all boundary conditions
                        Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                        CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
                      Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
                  GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
                    GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
                      IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
                      IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
                      IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
                      GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
                        IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
                      GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
                        IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
                GROUP SetTmunu: Group for calculating the stress-energy tensor
                  TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
                  GROUP AddToTmunu: Add to the stress-energy tensor here
                    IllinoisGRMHD::IllinoisGRMHD_compute_Tmunu: Compute stress-energy tensor
              MoL::MoL_ResetDeltaTime: [level] If necessary, change the timestep
          end while
          MoL::MoL_FinishLoop: [level] Control the step size
          MoL::MoL_RestoreSandR: Restoring the Save and Restore variables to the original state
          MoL::MoL_FreeScratchSpace: [level] Free storage for scratch levels
      end while
      GROUP MoL_PseudoEvolution: Calculate pseudo-evolved quantities
        GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
        Baikal::T4DD_to_T4UU_Baikal: [local] MoL_PseudoEvolution: Compute T4UU from T4DD (provided in eT?? from TmunuBase), needed for BSSN constraints
        Baikal::Baikal_BSSN_constraints: [local] Compute BSSN (Hamiltonian and momentum) constraints, at finite-differencing order: 4
        Baikal::specify_BoundaryConditions_aux_gfs_Baikal: [level] Enforce symmetry BCs in constraint computation
        Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion in MoL_PseudoEvolution. Needed for proper HydroBase integration.
        GROUP Baikal_auxgfs_ApplyBCs: Apply boundary conditions
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
    Evolve finer grids recursively
    Restrict from finer grids
    [CCTK_POSTRESTRICT]
      GROUP MoL_PostStep: Ensure that everything is correct after restriction
        Baikal::specify_BoundaryConditions_evolved_gfs_Baikal: [level] Apply boundary conditions and perform AMR+interprocessor synchronization
        Baikal::floor_the_lapse_Baikal: Set lapse = max(lapse_floor, lapse)
        Baikal::enforce_detgammahat_constraint_Baikal: Enforce detgammabar = detgammahat (= 1 in Cartesian)
        GROUP Baikal_ApplyBCs: Group for applying boundary conditions
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
        Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion. Useful for diagnostics.
        GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
        GROUP HydroBase_PostStep: Post step tasks for hydro thorns
          GROUP HydroBase_Boundaries: HydroBase-internal Boundary conditions group
            GROUP HydroBase_Select_Boundaries: Group to schedule the boundary condition functions
            GROUP HydroBase_ApplyBCs: Apply the boundary conditions of HydroBase
              GROUP BoundaryConditions: Execute all boundary conditions
                Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
            GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
              IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
              IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
              IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
              GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
                IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
              GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
                IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
        GROUP SetTmunu: Group for calculating the stress-energy tensor
          TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
          GROUP AddToTmunu: Add to the stress-energy tensor here
            IllinoisGRMHD::IllinoisGRMHD_compute_Tmunu: Compute stress-energy tensor
      GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
    [CCTK_POSTSTEP]
      GROUP zzz_NaNChecker_NaNCheck: Check for NaNs and count them in NaNChecker::NaNsFound
        NaNChecker::NaNChecker_NaNCheck_Prepare: [level] Prepare data structures to check for NaNs
        NaNChecker::NaNChecker_NaNCheck_Check: [local] Check for NaNs
        NaNChecker::NaNChecker_NaNCheck_Finish: [level] Count NaNs in NaNChecker::NaNsFound
      NaNChecker::NaNChecker_TakeAction: [global] [loop-level] Output NaNChecker::NaNmask and take action according to NaNChecker::action_if_found
      SpaceMask::CheckMask: Ensure that all mask values are legal
      SphericalSurface::SphericalSurface_Set: [global] Set surface radii
      GROUP SphericalSurface_HasBeenSet: Set the spherical surfaces before this group, and use it afterwards
        SphericalSurface::SphericalSurface_CheckState: [global] Test the state of the spherical surfaces
    if (checkpoint)
      [CCTK_CHECKPOINT]
      CarpetIOHDF5::CarpetIOHDF5_EvolutionCheckpoint: [meta] Evolution checkpoint routine
    endif
    if (analysis)
      [CCTK_ANALYSIS]
      CarpetLib::CarpetLib_printtimestats: [global] Print timing statistics if desired
      CarpetLib::CarpetLib_printmemstats: [global] Print memory statistics if desired
      IllinoisGRMHD::convert_IllinoisGRMHD_to_HydroBase: [global] [loop-local] Convert IllinoisGRMHD-native variables to HydroBase
      LoopControl::LC_statistics_analysis: [meta] Output LoopControl statistics
    endif
    Output grid variables
    enddo

  Termination routines
    [CCTK_TERMINATE]
      CarpetIOHDF5::CarpetIOHDF5_TerminationCheckpoint: [meta] Termination checkpoint routine
      GRHayLib::GRHayLib_terminate: [global] Free memory allocated for the GRHayL structs.
      LoopControl::LC_statistics_terminate: [meta] Output LoopControl statistics
      MoL::MoL_FreeIndexArrays: Free the MoL bookkeeping index arrays

  Shutdown routines
    [CCTK_SHUTDOWN]
      Timers::Timer_Shutdown: Prepare hierarchical timers

  Routines run after changing the grid hierarchy:
    [CCTK_POSTREGRID]
      CartGrid3D::SpatialCoordinates: Set Coordinates after regridding
      GROUP MaskBase_SetupMask: Set up the weight function
        GROUP MaskBase_SetupMaskAll: Set up the weight function
          CarpetReduce::MaskBase_AllocateMask: [global] Allocate the weight function
          CarpetReduce::MaskBase_InitMask: [global] [loop-local] Initialise the weight function
          GROUP SetupIMaskInternal: Set up the integer weight function (schedule other routines in here)
            CarpetReduce::CoordBase_SetupMask: [global] [loop-local] Set up the outer boundaries of the weight function
            CarpetReduce::CarpetMaskSetup: [global] [loop-singlemap] Set up the weight function for the restriction regions
          GROUP SetupIMask: Set up the integer weight function (schedule other routines in here)
          CarpetReduce::MaskBase_SetMask: [global] [loop-local] Set the weight function
          GROUP SetupMask: Set up the real weight function (schedule other routines in here)
          CarpetReduce::MaskBase_TestMask: [global] Test the weight function
      GROUP MoL_PostStep: Ensure that everything is correct after regridding
        Baikal::specify_BoundaryConditions_evolved_gfs_Baikal: [level] Apply boundary conditions and perform AMR+interprocessor synchronization
        Baikal::floor_the_lapse_Baikal: Set lapse = max(lapse_floor, lapse)
        Baikal::enforce_detgammahat_constraint_Baikal: Enforce detgammabar = detgammahat (= 1 in Cartesian)
        GROUP Baikal_ApplyBCs: Group for applying boundary conditions
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
        Baikal::BSSN_to_ADM_Baikal: [local] Perform BSSN-to-ADM conversion. Useful for diagnostics.
        GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
        GROUP HydroBase_PostStep: Post step tasks for hydro thorns
          GROUP HydroBase_Boundaries: HydroBase-internal Boundary conditions group
            GROUP HydroBase_Select_Boundaries: Group to schedule the boundary condition functions
            GROUP HydroBase_ApplyBCs: Apply the boundary conditions of HydroBase
              GROUP BoundaryConditions: Execute all boundary conditions
                Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
            GROUP IllinoisGRMHD_Con2Prim: Compute primitive variables from conservatives
              IllinoisGRMHD::IllinoisGRMHD_sync_conservatives: Sync conservative variable ghost zones for c2p routine
              IllinoisGRMHD::IllinoisGRMHD_A_i_outer_boundaries: Apply linear extrapolation BCs on A_{mu}, so that BCs are flat on B^i
              IllinoisGRMHD::IllinoisGRMHD_compute_B_and_Bstagger_from_A: Compute B and B_stagger from A SYNC: grmhd_primitives_Bi,grmhd_primitives_Bi_stagger
              GROUP IllinoisGRMHD_conservs_to_prims: Compute primitive variables from conservatives
                IllinoisGRMHD::IllinoisGRMHD_hybrid_conservs_to_prims: Hybrid version of IllinoisGRMHD_conservs_to_prims
              GROUP IllinoisGRMHD_hydro_outer_boundaries: Apply selected boundary conditions to the primitive variables
                IllinoisGRMHD::IllinoisGRMHD_hybrid_hydro_outer_boundaries: Hybrid version of IllinoisGRMHD_outer_boundaries
        GROUP SetTmunu: Group for calculating the stress-energy tensor
          TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
          GROUP AddToTmunu: Add to the stress-energy tensor here
            IllinoisGRMHD::IllinoisGRMHD_compute_Tmunu: Compute stress-energy tensor
      GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
      SpaceMask::MaskZero: Initialise mask to zero
      SpaceMask::MaskOne: Set mask to one
--------------------------------------------------------------------------------
INFO (Carpet): Multi-Model listing:
   model 0: "world"
INFO (Carpet): Multi-Model process distribution:
   processes 0-1: model 0 "world"
INFO (Carpet): Multi-Model: This is process 0, model 0 "world"
INFO (CarpetLib): Process startup time was 1.44 seconds
Current core file size limit: hard=[unlimited], soft=0 MB
Current addres space size limit: hard=[unlimited], soft=[unlimited]
Current data segment size limit: hard=[unlimited], soft=[unlimited]
Current resident set size limit: hard=[unlimited], soft=[unlimited]
Baikal: another Einstein Toolkit thorn generated by

ooooo      ooo ooooooooo.   ooooooooo.                 88
`888b.     `8' `888   `Y88. `888   `Y88.             888888
 8 `88b.    8   888   .d88'  888   .d88' oooo    ooo   88
 8   `88b.  8   888ooo88P'   888ooo88P'   `88.  .8'
 8     `88b.8   888`88b.     888           `88..8'
 8       `888   888  `88b.   888            `888'
o8o        `8  o888o  o888o o888o            .8'
                                         .o..P'
  NRPy+: Python-based Code Generation    `Y8P'
   for Numerical Relativity... and Beyond!
 - homepage: http://blackholesathome.net
 - download: https://github.com/zachetienne/nrpytutorial
INFO (CycleClock): Measuring CycleClock tick via OpenMP...
INFO (CycleClock): Calibrated CycleClock: 0.40892 ns per clock tick (2.44547 GHz)
INFO (Vectors): Using vector size 2 for architecture SSE2 (64-bit precision)
INFO (hwloc): library version 2.7.0, API version 0x20500
--------------------------------------------------------------------------------
AMR driver provided by Carpet
--------------------------------------------------------------------------------
AMR scalar I/O provided by CarpetIOScalar
--------------------------------------------------------------------------------
HydroBase: Let it flow.
--------------------------------------------------------------------------------
AMR 0D ASCII I/O provided by CarpetIOASCII
--------------------------------------------------------------------------------
AMR 1D ASCII I/O provided by CarpetIOASCII
--------------------------------------------------------------------------------
AMR 2D ASCII I/O provided by CarpetIOASCII
--------------------------------------------------------------------------------
AMR 3D ASCII I/O provided by CarpetIOASCII
--------------------------------------------------------------------------------
AMR info I/O provided by CarpetIOBasic
--------------------------------------------------------------------------------
MoL: Generalized time integration.
--------------------------------------------------------------------------------
AMR HDF5 I/O provided by CarpetIOHDF5
--------------------------------------------------------------------------------
AMR 0D HDF5 I/O provided by CarpetIOHDF5
--------------------------------------------------------------------------------
AMR 1D HDF5 I/O provided by CarpetIOHDF5
--------------------------------------------------------------------------------
AMR 2D HDF5 I/O provided by CarpetIOHDF5
--------------------------------------------------------------------------------
AMR 3D HDF5 I/O provided by CarpetIOHDF5
--------------------------------------------------------------------------------

INFO (Carpet): MPI is enabled
INFO (Carpet): Carpet is running on 2 processes
INFO (Carpet): This is process 0
INFO (Carpet): OpenMP is enabled
INFO (Carpet): This process contains 1 threads, this is thread 0
INFO (Carpet): There are 2 threads in total
INFO (Carpet): There are 1 threads per process
INFO (Carpet): This process runs on host fv-az735-601, pid=135447
INFO (Carpet): This process runs on 2 cores: 0-1
INFO (Carpet): Thread 0 runs on 2 cores: 0-1
INFO (Carpet): This simulation is running in 3 dimensions
INFO (Carpet): Boundary specification for map 0:
   nboundaryzones: [[3,3,3],[3,3,3]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[0,0,0],[0,0,0]]
INFO (Carpet): CoordBase domain specification for map 0:
   physical extent: [-12,-12,-12] : [12,12,12]   ([24,24,24])
   interior extent: [-11,-11,-11] : [11,11,11]   ([22,22,22])
   exterior extent: [-14,-14,-14] : [14,14,14]   ([28,28,28])
   base_spacing   : [1,1,1]
INFO (Carpet): Adapted domain specification for map 0:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-12,-12,-12] : [12,12,12]   ([24,24,24])
   interior extent   : [-11,-11,-11] : [11,11,11]   ([22,22,22])
   exterior extent   : [-14,-14,-14] : [14,14,14]   ([28,28,28])
   spacing           : [1,1,1]
INFO (Carpet): Base grid specification for map 0:
   number of grid points             : [29,29,29]
   number of coarse grid ghost points: [[3,3,3],[3,3,3]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
   [1]: [[9,9,9],[9,9,9]]
   [2]: [[9,9,9],[9,9,9]]
   [3]: [[9,9,9],[9,9,9]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
   [1]: [[0,0,0],[0,0,0]]
   [2]: [[0,0,0],[0,0,0]]
   [3]: [[0,0,0],[0,0,0]]
INFO (Carpet): Group and variable statistics:
INFO (Carpet):    There are 816 grid functions in 70 groups
INFO (Carpet):    There are 263 grid scalars in 49 groups
INFO (Carpet):    There are 81 1-dimensional grid arrays in 7 groups
INFO (Carpet):    There are 3 2-dimensional grid arrays in 2 groups
INFO (Carpet):    There are 0 3-dimensional grid arrays in 0 groups
INFO (Carpet):    (The number of variables counts all time levels)
INFO (CarpetIOScalar): Periodic scalar output requested for:
   ILLINOISGRMHD::rho_b
INFO (CarpetIOASCII): I/O Method 'IOASCII_0D' registered: 0D AMR output of grid variables to ASCII files
INFO (CarpetIOASCII): I/O Method 'IOASCII_1D' registered: 1D AMR output of grid variables to ASCII files
INFO (CarpetIOASCII): Periodic 1D AMR output requested for:
   ILLINOISGRMHD::Ax
   ILLINOISGRMHD::Ay
   ILLINOISGRMHD::Az
   ILLINOISGRMHD::psi6phi
   ILLINOISGRMHD::rho_b
INFO (CarpetIOASCII): I/O Method 'IOASCII_2D' registered: 2D AMR output of grid variables to ASCII files
INFO (CarpetIOASCII): I/O Method 'IOASCII_3D' registered: 3D AMR output of grid variables to ASCII files
INFO (CarpetIOHDF5): I/O Method 'IOHDF5' registered: AMR output of grid variables to HDF5 files
INFO (CarpetIOHDF5): I/O Method 'IOHDF5_0D' registered: 0D AMR output of grid variables to HDF5 files
INFO (CarpetIOHDF5): I/O Method 'IOHDF5_1D' registered: 1D AMR output of grid variables to HDF5 files
INFO (CarpetIOHDF5): I/O Method 'IOHDF5_2D' registered: 2D AMR output of grid variables to HDF5 files
INFO (CarpetIOHDF5): I/O Method 'IOHDF5_3D' registered: 3D AMR output of grid variables to HDF5 files
3
INFO (IllinoisGRMHD): Warning!! Many features in IllinoisGRMHD have been improved alongside
the development of GRHayL. Please update your parfile to use the new features.
Running GRHayLib with backward-compatible settings...
INFO (MoL): Using Runge-Kutta 4 as the time integrator.
INFO (MoL): The maximum number of evolved variables is 595. 33 are registered.
INFO (MoL): The maximum number of slow evolved variables is 595. 0 are registered.
INFO (MoL): The maximum number of constrained variables is 595. 13 are registered.
INFO (MoL): The maximum number of SandR variables is 595. 16 are registered.
INFO (MoL): The maximum number of evolved array variables is 595. 0 are registered.
INFO (MoL): The maximum number of constrained array variables is 595. 0 are registered.
INFO (MoL): The maximum number of SandR array variables is 595. 0 are registered.
INFO (MoL): The maximum size of any array variables is 0.
INFO (Vectors): Testing vectorisation... [errors may result in segfaults]
INFO (Vectors): 375/375 tests passed 
INFO (CarpetRegrid2): Enforcing grid structure properties, iteration 0
INFO (CarpetRegrid2): Enforcing grid structure properties, iteration 0
INFO (CarpetRegrid2): Enforcing grid structure properties, iteration 0
INFO (CarpetRegrid2): Enforcing grid structure properties, iteration 1
INFO (Carpet): Grid structure (superregions, grid points):
   [0][0][0]   exterior: [0,0,0] : [28,28,28]   ([29,29,29] + PADDING) 24389
   [1][0][0]   exterior: [2,2,2] : [54,54,54]   ([53,53,53] + PADDING) 148877
   [2][0][0]   exterior: [29,29,29] : [83,83,83]   ([55,55,55] + PADDING) 166375
   [3][0][0]   exterior: [91,91,91] : [133,133,133]   ([43,43,43] + PADDING) 79507
INFO (Carpet): Grid structure (superregions, coordinates):
   [0][0][0]   exterior: [-14,-14,-14] : [14,14,14] : [1,1,1]
   [1][0][0]   exterior: [-13,-13,-13] : [13,13,13] : [0.5,0.5,0.5]
   [2][0][0]   exterior: [-6.75,-6.75,-6.75] : [6.75,6.75,6.75] : [0.25,0.25,0.25]
   [3][0][0]   exterior: [-2.625,-2.625,-2.625] : [2.625,2.625,2.625] : [0.125,0.125,0.125]
INFO (Carpet): There are not enough time levels for the desired temporal prolongation order in the grid function group "HYDROBASE::BVEC".  With Carpet::prolongation_order_time=2, you need at least 3 time levels.
INFO (Carpet): There are not enough time levels for the desired temporal prolongation order in the grid function group "HYDROBASE::AVEC".  With Carpet::prolongation_order_time=2, you need at least 3 time levels.
INFO (Carpet): There are not enough time levels for the desired temporal prolongation order in the grid function group "HYDROBASE::APHI".  With Carpet::prolongation_order_time=2, you need at least 3 time levels.
INFO (Carpet): Global grid structure statistics:
INFO (Carpet): GF: rhs: 36k active, 101k owned (+178%), 161k total (+59%), 15 steps/time
INFO (Carpet): GF: vars: 322, pts: 59M active, 117M owned (+99%), 186M total (+59%), 1.0 comp/proc
INFO (Carpet): GA: vars: 342, pts: 0M active, 0M total (+0%)
INFO (Carpet): Total required memory: 1.481 GByte (for GAs and currently active GFs)
INFO (Carpet): Load balance:  min     avg     max     sdv     max/avg-1
INFO (Carpet): Level  0:       2M      2M      2M      0M owned      4%
INFO (Carpet): Level  1:      16M     17M     17M      0M owned      2%
INFO (Carpet): Level  2:      26M     27M     27M      0M owned      2%
INFO (Carpet): Level  3:      13M     13M     13M      0M owned      2%
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>1.0000000e+00  dy=>1.0000000e+00  dz=>1.0000000e+00
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-14.000,14.000]  y=>[-14.000,14.000]  z=>[-14.000,14.000]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,28]  y=>[0,28]  z=>[0,28]
INFO (IllinoisGRMHD): Setting Symmetry = none... at iteration = 0
INFO (Time): Timestep set to 0.5 (courant_static)
INFO (TOVSolver): Integrated TOV equation
INFO (TOVSolver): Information about the TOVs used:
INFO (): TOV    radius    mass  bary_mass mass(g) cent.rho rho(cgi)        K   K(cgi)    Gamma
INFO ():   1  0.809903 0.140503 0.151197 2.79e+32 0.129285    8e+16        1 1.45e+03        2
INFO (TOVSolver): Not using old matter initial data
INFO (TOVSolver): Done interpolation.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::METRIC. The unregistered variable(s) is(are) ADMBASE::gxx, ADMBASE::gxy, ADMBASE::gxz, ADMBASE::gyy, ADMBASE::gyz, ADMBASE::gzz.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::CURV. The unregistered variable(s) is(are) ADMBASE::kxx, ADMBASE::kxy, ADMBASE::kxz, ADMBASE::kyy, ADMBASE::kyz, ADMBASE::kzz.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::LAPSE. The unregistered variable(s) is(are) ADMBASE::alp.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::SHIFT. The unregistered variable(s) is(are) ADMBASE::betax, ADMBASE::betay, ADMBASE::betaz.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::METRIC. The unregistered variable(s) is(are) ADMBASE::gxx, ADMBASE::gxy, ADMBASE::gxz, ADMBASE::gyy, ADMBASE::gyz, ADMBASE::gzz.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::CURV. The unregistered variable(s) is(are) ADMBASE::kxx, ADMBASE::kxy, ADMBASE::kxz, ADMBASE::kyy, ADMBASE::kyz, ADMBASE::kzz.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::LAPSE. The unregistered variable(s) is(are) ADMBASE::alp.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group ADMBASE::SHIFT. The unregistered variable(s) is(are) ADMBASE::betax, ADMBASE::betay, ADMBASE::betaz.
WARNING[L1,P1] (Carpet): No boundary conditions registered for variables in group ADMBASE::METRIC. The unregistered variable(s) is(are) ADMBASE::gxx, ADMBASE::gxy, ADMBASE::gxz, ADMBASE::gyy, ADMBASE::gyz, ADMBASE::gzz.
WARNING[L1,P1] (Carpet): No boundary conditions registered for variables in group ADMBASE::CURV. The unregistered variable(s) is(are) ADMBASE::kxx, ADMBASE::kxy, ADMBASE::kxz, ADMBASE::kyy, ADMBASE::kyz, ADMBASE::kzz.
WARNING[L1,P1] (Carpet): No boundary conditions registered for variables in group ADMBASE::LAPSE. The unregistered variable(s) is(are) ADMBASE::alp.
WARNING[L1,P1] (Carpet): No boundary conditions registered for variables in group ADMBASE::SHIFT. The unregistered variable(s) is(are) ADMBASE::betax, ADMBASE::betay, ADMBASE::betaz.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group HYDROBASE::VEL. The unregistered variable(s) is(are) HYDROBASE::vel[0], HYDROBASE::vel[1], HYDROBASE::vel[2].
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group HYDROBASE::VEL. The unregistered variable(s) is(are) HYDROBASE::vel[0], HYDROBASE::vel[1], HYDROBASE::vel[2].
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group HYDROBASE::W_LORENTZ. The unregistered variable(s) is(are) HYDROBASE::w_lorentz.
WARNING[L1,P0] (Carpet): No boundary conditions registered for variables in group HYDROBASE::W_LORENTZ. The unregistered variable(s) is(are) HYDROBASE::w_lorentz.
WARNING[L1,P1] (Carpet): No boundary conditions registered for variables in group HYDROBASE::VEL. The unregistered variable(s) is(are) HYDROBASE::vel[0], HYDROBASE::vel[1], HYDROBASE::vel[2].
WARNING[L1,P1] (Carpet): No boundary conditions registered for variables in group HYDROBASE::W_LORENTZ. The unregistered variable(s) is(are) HYDROBASE::w_lorentz.
INFO (Seed_Magnetic_Fields): Seeding magnetic fields
INFO (IllinoisGRMHD): C2P: Iter. # 0, Lev: 0 NumPts= 15138 | Backups: 0 0 0 | Fixes: VL= 0 rho*= 0
                 Averaged pts = 0 Font1D 0 | Failures: 0 InHoriz= 0 / 0 | 1.00 iters/gridpt
   Error, Sum: rho 4.798e-22, 3.772e-01 | tau 3.415e-15, 4.877e-02 | Sx 0.000e+00, 0.000e+00 | Sy 0.000e+00, 0.000e+00 | Sz 0.000e+00, 0.000e+00

Rank 0 with PID 135447 received signal 8
Writing backtrace to Baikal_PreSync/backtrace.0.txt
Rank 1 with PID 135448 received signal 8
Writing backtrace to Baikal_PreSync/backtrace.1.txt
--------------------------------------------------------------------------
Primary job  terminated normally, but 1 process returned
a non-zero exit code. Per user-direction, the job has been aborted.
--------------------------------------------------------------------------
--------------------------------------------------------------------------
mpirun noticed that process rank 0 with PID 0 on node fv-az735-601 exited on signal 8 (Floating point exception).
--------------------------------------------------------------------------
  Elapsed time: 3.0 s