[Users] NaNs between [CCTK_PREREGRID] and [CCTK_PRESTEP]

Severin Frank severin.frank at uni-tuebingen.de
Fri Jun 14 11:57:02 CDT 2019


Dear all,

My own thorn runs into NaNs just before evolution starts. To search 
where exactly those NaNs are appearing I included subroutines which 
print example values for the corresponding variables and changed the 
schedule position of these output routines. (See SWTNS_inittest and 
SWTNS_regridtest inside the schedule.ccl)

The last slot inside the schedule where the values still seemed to work, 
is inside [CCTK_PREREGRID]. In [CCTK_PRESTEP] the values are already 
messed up. The only schedule bin that is in between those two is 
[CCTK_POSTREGRID]. I don't have any regridding and whenever I schedule 
my output routine inside the [CCTK_POSTREGRID] bin I don't have any 
output, as you can see in the attached output file.

Maybe I should point out that I use the Llama Multipatch environment for 
my thorn.

Does anyone have an idea how I can check what happens with my initial 
data before evolution starts?

I attached the schedule of my thorn and a simulation output file with 
respect to the (as well attached) parameter file.

Thanks a lot!

Best regards,

Severin

-------------- next part --------------
# Schedule definitions for thorn SWTNS

# Evolved variables
STORAGE: pressuredensity[2]
STORAGE: metricpots[2]
STORAGE: scalar[2] density[2]
STORAGE: drscalar[2]
STORAGE: drrscalar[2]
STORAGE: drdensity[2]
STORAGE: tovradius[1]
STORAGE: scalardot densitydot

# Startup

SCHEDULE SWTNS_startup AT startup
{
  LANG: C
  OPTIONS: meta
} "Register banner with Cactus"


SCHEDULE SWTNS_register_MoL IN MoL_Register
{
  LANG: C
  OPTIONS: meta
} "Register variables with MoL"


SCHEDULE SWTNS_init AT initial AFTER TOV_C_Exact
{
  LANG: Fortran
} "Initialise the system"

SCHEDULE SWTNS_inittest IN CCTK_PREREGRID
{
  LANG: Fortran
} "TEST the system"

 
SCHEDULE SWTNS_regridtest AT CCTK_POSTREGRID AFTER SpatialCoordinates
{
  LANG: Fortran
} "TEST the system"

# Calculate the RHS


SCHEDULE SWTNS_calc_rhs IN MoL_CalcRHS
{
  LANG: Fortran
} "Calculate the RHS"
-------------- next part --------------
#===============================================================
# Testing SWTNS on a static TOV star
#
# Severin Frank
#===============================================================

#################### Thorns ####################################
ActiveThorns = "Time MoL"
ActiveThorns = "CoordBase CartGrid3d Boundary CoordinatesSymmetry StaticConformal"

ActiveThorns = "SymBase ADMBase TmunuBase HydroBase InitBase ADMCoupling ADMMacros"
ActiveThorns = "IOUtil Formaline"
ActiveThorns = "SpaceMask CoordGauge Constants LocalReduce LocalInterp AEILocalInterp LoopControl 
                SphericalSurface Vectors" 
#AHFinderDirect CoordinatesSymmetry
ActiveThorns = "Carpet CarpetInterp"
# CarpetRegrid2 CarpetLib CarpetTracker 
ActiveThorns = "CarpetIOASCII CarpetIOScalar CarpetIOHDF5 CarpetIOBasic"
ActiveThorns = "NaNChecker CarpetReduce"
ActiveThorns = "CarpetIOASCII"
#ML_ADMConstraints 
ActiveThorns = "Coordinates Interpolate2 CarpetInterp2 GlobalDerivative SWTNS"  
#ADMDerivatives
ActiveThorns = "TOVSolver"
ActiveThorns = "GenericFD NewRad"
#ActiveThorns = "EOS_Omni"
#ActiveThorns = "GRHydro"

#################### Terminate #################################
Cactus::terminate                    = "time"
Cactus::cctk_final_time              = 1

#################### Time Integration ##########################
Time::timestep_method                = "given"
Time::timestep                       = 0.09

MoL::ODE_Method                      = "Generic"
MoL::Generic_Type                    = "RK"
MoL::MoL_Intermediate_Steps          = 4
MoL::MoL_Num_Scratch_Levels          = 3

#################### Grid Setup ################################
Carpet::domain_from_multipatch        = yes
CartGrid3D::type                        = "multipatch"
CartGrid3D::set_coordinate_ranges_on    = "all maps"
Coordinates::coordinate_system          = "Thornburg04"

Coordinates::h_cartesian                = 0.1
Coordinates::h_radial                   = 0.11

Coordinates::sphere_inner_radius        = 1.8 #20
Coordinates::sphere_outer_radius        = 5 #100
Coordinates::n_angular                  = 20

Driver::ghost_size                      = 5

Coordinates::outer_boundary_size        = 5

Coordinates::patch_boundary_size        = 5 
Coordinates::additional_overlap_size    = 3
Interpolate2::interpolator_order         = 4
Interpolate2::continue_if_selftest_fails = no
Interpolate2::verbose                    = no

Coordinates::store_inverse_jacobian     = "yes"

GenericFD::jacobian_group = "Coordinates::jacobian"
GenericFD::jacobian_derivative_group = "Coordinates::jacobian2"
GenericFD::jacobian_identity_map = 0

TmunuBase::stress_energy_storage = yes
TmunuBase::stress_energy_at_RHS  = yes
TmunuBase::timelevels            =  1
TmunuBase::prolongation_type     = none

HydroBase::timelevels            = 1

ADMMacros::spatial_order = 4

ADMBase::metric_type     = "physical"

#ML_ADMConstraints::timelevels = 3

SpaceMask::use_mask      = "yes"

#################### Initial Data ##############################
InitBase::initial_data_setup_method = "init_some_levels"

ADMBase::initial_data            = "tov"
ADMBase::initial_lapse           = "tov"
ADMBase::initial_shift           = "tov"
ADMBase::initial_dtlapse         = "zero" 
ADMBase::initial_dtshift         = "zero" 

TOVSolver::TOV_Rho_Central[0] = 1.28e-3#3.24e-3
TOVSolver::TOV_Gamma          = 2.0
TOVSolver::TOV_K              = 100.0

#################### Finite Differencing ########################
SummationByParts::order                          = 2
SummationByParts::use_dissipation                = no
SummationByParts::onesided_interpatch_boundaries = no
SummationByParts::onesided_outer_boundaries      = yes
SummationByParts::sbp_upwind_deriv                   = yes
SummationByParts::sbp_1st_deriv                      = yes
SummationByParts::sbp_2nd_deriv                      = yes

#################### NaN Checker ################################
NaNChecker::check_every = 1
NaNChecker::action_if_found = "just warn" #"terminate", "just warn", "abort"
NaNChecker::check_vars = "HydroBase::rho HydroBase::press 
			  SWTNS::Xi SWTNS::Pidot SWTNS::PHI SWTNS::LAMBDA TOVSolver::TOV_PHI TOVSolver::TOV_R"

#################### Output #####################################
IOBasic::outInfo_every                  = 4
IOBasic::outInfo_vars                   = "
                                          #HydroBase::rho
                                          #HydroBase::press
					  SWTNS::gappa
                                          SWTNS::Xi
                                          SWTNS::Pidot
                                          SWTNS::PHI 
                                          SWTNS::LAMBDA 
                                          #TOVSolver::TOV_PHI 
                                          #TOVSolver::TOV_R
				          "
 IOHDF5::out_every                       = 4
 IOHDF5::out_vars                        = "
                                           grid::coordinates{out_every=100000}
                                          HydroBase::rho
                                          HydroBase::press
                                          SWTNS::Xi
                                          SWTNS::Pidot                                   
                                           "                                          
-------------- next part --------------
Simulation name: SWTNS_14062019
Running simulation SWTNS_14062019
Preparing:
Checking:
/home/frank/simulations/SWTNS_14062019/output-0000-active
Baade
Fr 14. Jun 18:17:45 CEST 2019
Environment:
Starting:
INFO (Cactus): Increasing logging level from 0 to 3
INFO (Cactus): Increasing logging level from 0 to 3
--------------------------------------------------------------------------------

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

Cactus version:    4.2.3
Compile date:      Jun 14 2019 (18:17:13)
Run date:          Jun 14 2019 (18:17:45+0200)
Run host:          Baade (pid=30059)
Working directory: /home/frank/simulations/SWTNS_14062019/output-0000
Executable:        /home/frank/simulations/SWTNS_14062019/SIMFACTORY/exe/cactus_Pingudebug
Parameter file:    /home/frank/simulations/SWTNS_14062019/output-0000/SWTNS_test.par
--------------------------------------------------------------------------------

Activating thorn Cactus...Success -> active implementation Cactus
Activation requested for 
--->Time MoL CoordBase CartGrid3d Boundary CoordinatesSymmetry StaticConformal SymBase ADMBase TmunuBase HydroBase InitBase ADMCoupling ADMMacros IOUtil Formaline SpaceMask CoordGauge Constants LocalReduce LocalInterp AEILocalInterp LoopControl 
                SphericalSurface Vectors Carpet CarpetInterp CarpetIOASCII CarpetIOScalar CarpetIOHDF5 CarpetIOBasic NaNChecker CarpetReduce CarpetIOASCII Coordinates Interpolate2 CarpetInterp2 GlobalDerivative SWTNS TOVSolver GenericFD NewRad <---
Warning: thorn CarpetIOASCII already scheduled for activation
Thorn Carpet requests automatic activation of CarpetLib
Thorn Carpet requests automatic activation of MPI
Thorn Carpet requests automatic activation of Timers
Thorn CarpetIOHDF5 requests automatic activation of HDF5
Thorn Coordinates requests automatic activation of TensorTypes
Thorn Coordinates requests automatic activation of TGRtensor
Thorn GlobalDerivative requests automatic activation of SummationByParts
Thorn Interpolate2 requests automatic activation of LAPACK
Thorn LoopControl requests automatic activation of CycleClock
Thorn LoopControl requests automatic activation of hwloc
Thorn SWTNS requests automatic activation of Fortran
Thorn HDF5 requests automatic activation of zlib
Thorn LAPACK requests automatic activation of BLAS
Activating thorn ADMBase...Success -> active implementation ADMBase
Activating thorn ADMCoupling...Success -> active implementation ADMCoupling
Activating thorn ADMMacros...Success -> active implementation ADMMacros
Activating thorn AEILocalInterp...Success -> active implementation AEILocalInterp
Activating thorn BLAS...Success -> active implementation BLAS
Activating thorn Boundary...Success -> active implementation boundary
Activating thorn Carpet...Success -> active implementation Driver
Activating thorn CarpetInterp...Success -> active implementation interp
Activating thorn CarpetInterp2...Success -> active implementation interp2
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 CartGrid3d...Success -> active implementation grid
Activating thorn Constants...Success -> active implementation Constants
Activating thorn CoordBase...Success -> active implementation CoordBase
Activating thorn CoordGauge...Success -> active implementation CoordGauge
Activating thorn Coordinates...Success -> active implementation Coordinates
Activating thorn CoordinatesSymmetry...Success -> active implementation CoordinatesSymmetry
Activating thorn CycleClock...Success -> active implementation CycleClock
Activating thorn Formaline...Success -> active implementation Formaline
Activating thorn Fortran...Success -> active implementation Fortran
Activating thorn GenericFD...Success -> active implementation GenericFD
Activating thorn GlobalDerivative...Success -> active implementation GlobalDerivative
Activating thorn HDF5...Success -> active implementation HDF5
Activating thorn hwloc...Success -> active implementation hwloc
Activating thorn HydroBase...Success -> active implementation HydroBase
Activating thorn InitBase...Success -> active implementation InitBase
Activating thorn Interpolate2...Success -> active implementation Interpolate
Activating thorn IOUtil...Success -> active implementation IO
Activating thorn LAPACK...Success -> active implementation LAPACK
Activating thorn LocalInterp...Success -> active implementation LocalInterp
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 SpaceMask...Success -> active implementation SpaceMask
Activating thorn SphericalSurface...Success -> active implementation SphericalSurface
Activating thorn StaticConformal...Success -> active implementation StaticConformal
Activating thorn SummationByParts...Success -> active implementation SummationByParts
Activating thorn SWTNS...Success -> active implementation SWTNS
Activating thorn SymBase...Success -> active implementation SymBase
Activating thorn TensorTypes...Success -> active implementation TensorTypes
Activating thorn TGRtensor...Success -> active implementation TGRtensor
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
--------------------------------------------------------------------------------
  if (recover initial data)
    Recover parameters
  endif

  Startup routines
    [CCTK_STARTUP]
      Carpet::MultiModel_Startup: Multi-model Startup routine
      Coordinates::Coordinates_ChoosePatchSystem: [meta] Choose patch system
      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
      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
      CarpetIOBasic::CarpetIOBasicStartup: [global] Startup routine
      Formaline::Formaline_PrintIDs: [meta] Print the build and simulation ids
      HydroBase::HydroBase_StartUp: Startup banner
      CarpetIOASCII::CarpetIOASCIIStartup: [global] Startup routine
      LocalInterp::LocalInterp_Startup: register LocalInterp's interpolation operators
      LocalReduce::LocalReduce_Startup: Startup routine
      CarpetIOHDF5::CarpetIOHDF5_Startup: Startup routine
      MoL::MoL_Startup: Startup banner
      SWTNS::SWTNS_startup: [meta] Register banner with Cactus
      SymBase::SymBase_Startup: Register GH Extension for SymBase
      CarpetIOScalar::CarpetIOScalarStartup: [global] Startup routine
      Vectors::Vectors_Startup: Print startup message

  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
      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
      Formaline::Formaline_OutputSource: Output Cactus source tree
      Formaline::Formaline_RegisterWarnings: [meta] Register to receive warnings and info messages from the flesh
      Formaline::Formaline_AnnounceInitial: [global] Put some meta information about the current run into permanent storage
      MoL::MoL_SetupIndexArrays: Set up the MoL bookkeeping index arrays
      MoL::MoL_SetupRKCoefficients: [global] Initialize the generic Runge-Kutta coefficients
      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
        SWTNS::SWTNS_register_MoL: [meta] Register variables with 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::RegisterSymmetryBoundaries: [meta] Register symmetry boundaries
          Coordinates::Coordinates_RegisterSymmetry: [meta] Register inter-patch boundaries as symmetries
        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
      CartGrid3D::ParamCheck_CartGrid3D: Check coordinates for CartGrid3D
      Coordinates::Coordinates_ParamCheck: Check thorn parameters for consistency.
      Fortran::CheckFortranParameters: Test whether Fortran parameters work correctly
      GlobalDerivative::GlobalDeriv_ParamCheck: [global] Check parameters
      MoL::MoL_ParamCheck: Basic parameter checking
      TOVSolver::TOV_C_ParamCheck: [global] Check parameters
      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 MultiPatch_SpatialCoordinates: Determine the global coordinates of each gridpoint.
          Coordinates::Coordinates_SetGlobalCoords: [local] Determine the global coordinates of each gridpoint.
          Coordinates::Coordinates_SetJacobian: [local] Fill in the Jacobian matrices for Thornburg04 coordinates.
          Coordinates::Coordinates_SetInverseJacobian: [local] Numerically evaluate the inverse Jacobian matrices.
          Coordinates::Coordinates_SetVolumeForm: [local] Set weight mask (for Carpet reduction operators)
        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
        CartGrid3D::SpatialSpacings: [singlemap] Set up ranges for spatial 3D Cartesian coordinates (on all maps)
        CartGrid3D::SpatialCoordinates: Set up spatial 3D Cartesian coordinates on the GH
        SphericalSurface::SphericalSurface_SetupRes: [global] [loop-local] Set surface resolution automatically
        GROUP MultiPatch_SpatialCoordinates: Determine the global coordinates of each gridpoint.
          Coordinates::Coordinates_SetGlobalCoords: [local] Determine the global coordinates of each gridpoint.
          Coordinates::Coordinates_SetJacobian: [local] Fill in the Jacobian matrices for Thornburg04 coordinates.
          Coordinates::Coordinates_SetInverseJacobian: [local] Numerically evaluate the inverse Jacobian matrices.
          Coordinates::Coordinates_SetVolumeForm: [local] Set weight mask (for Carpet reduction operators)
        Interpolate2::Interpolate2Init: Initialise interpolating inter-patch boundaries
        GROUP Interpolate2Test: Test interpolating inter-patch boundaries
          Interpolate2::Interpolate2TestInit: Test: Initialise test grid function
          Interpolate2::Interpolate2TestSelectBCs: [level] Test: Interpolate test grid function
          GROUP Interpolate2TestApplyBCs: Test: Interpolate test grid function
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
              Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          Interpolate2::Interpolate2TestCheck: Test: Check test grid function
        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
        SummationByParts::SBP_SetNormMask: Setup the mask for the calculation of the norm
        SymBase::SymBase_Check: Check whether the driver set up the grid consistently
        Time::Time_Initialise: [global] Initialise Time variables
        Time::TemporalSpacings: [singlemap] Set fixed timestep
      [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
        CarpetIOASCII::CarpetIOASCIIInit: [global] Initialisation routine
        CarpetIOBasic::CarpetIOBasicInit: [global] Initialisation routine
        CarpetIOHDF5::CarpetIOHDF5_Init: [global] Initialisation routine
        CarpetIOScalar::CarpetIOScalarInit: [global] Initialisation routine
        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 HydroBase_Prim2ConInitial: Recover the conservative variables from the primitive variables
        MoL::MoL_StartLoop: [level] Initialise the step size control
        SWTNS::SWTNS_init: Initialise the system
        GROUP ADMBase_PostInitial: Schedule group for modifying the ADM initial data, such as e.g. adding noise
        GROUP SetTmunu: Calculate the stress-energy tensor
          TmunuBase::TmunuBase_ZeroTmunu: Initialise the stress-energy tensor to zero
          GROUP AddToTmunu: Add to the stress-energy tensor here
      [CCTK_POSTINITIAL]
        CarpetIOHDF5::CarpetIOHDF5_CloseFiles: [global] Close all filereader input files
        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
          ADMBase::ADMBase_Boundaries: [level] Select ADMBase boundary conditions - may be required for mesh refinement
          GROUP ADMBase_ApplyBCs: Apply the boundary conditions of ADMBase
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
              Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          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
                  CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                  Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                  CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
                Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
            GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
          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
        GROUP MoL_PseudoEvolution: Calculate pseudo-evolved quantities
          GROUP ADMBase_SetADMVars: Set the ADM variables before this group, and use them afterwards
        SummationByParts::SBP_CheckGridSizes: Check grid sizes and ghost zones
      Initialise finer grids recursively
      Restrict from finer grids
      [CCTK_POSTRESTRICTINITIAL]
        GROUP MoL_PostStep: Ensure that everything is correct after restriction
          ADMBase::ADMBase_Boundaries: [level] Select ADMBase boundary conditions - may be required for mesh refinement
          GROUP ADMBase_ApplyBCs: Apply the boundary conditions of ADMBase
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
              Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          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
                  CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                  Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                  CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
                Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
            GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
          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
        GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
      [CCTK_POSTPOSTINITIAL]
        GROUP Con2Prim: Convert from conservative to primitive variables (might be redundant)
        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
        CartGrid3D::SpatialSpacings: [singlemap] Set up ranges for spatial 3D Cartesian coordinates (on all maps)
        CartGrid3D::SpatialCoordinates: Set up spatial 3D Cartesian coordinates on the GH
        SphericalSurface::SphericalSurface_SetupRes: [global] [loop-local] Set surface resolution automatically
        GROUP MultiPatch_SpatialCoordinates: Determine the global coordinates of each gridpoint.
          Coordinates::Coordinates_SetGlobalCoords: [local] Determine the global coordinates of each gridpoint.
          Coordinates::Coordinates_SetJacobian: [local] Fill in the Jacobian matrices for Thornburg04 coordinates.
          Coordinates::Coordinates_SetInverseJacobian: [local] Numerically evaluate the inverse Jacobian matrices.
          Coordinates::Coordinates_SetVolumeForm: [local] Set weight mask (for Carpet reduction operators)
        Interpolate2::Interpolate2Init: Initialise interpolating inter-patch boundaries
        GROUP Interpolate2Test: Test interpolating inter-patch boundaries
          Interpolate2::Interpolate2TestInit: Test: Initialise test grid function
          Interpolate2::Interpolate2TestSelectBCs: [level] Test: Interpolate test grid function
          GROUP Interpolate2TestApplyBCs: Test: Interpolate test grid function
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
              Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          Interpolate2::Interpolate2TestCheck: Test: Check test grid function
        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
        SummationByParts::SBP_SetNormMask: Setup the mask for the calculation of the norm
        SymBase::SymBase_Check: Check whether the driver set up the grid consistently
        Time::Time_Initialise: [global] Initialise Time variables
        Time::TemporalSpacings: [singlemap] Set fixed timestep
      [CCTK_RECOVER_VARIABLES]
      [CCTK_POST_RECOVER_VARIABLES]
        CarpetIOHDF5::CarpetIOHDF5_InitCheckpointingIntervals: [global] Initialisation of checkpointing intervals 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
          ADMBase::ADMBase_Boundaries: [level] Select ADMBase boundary conditions - may be required for mesh refinement
          GROUP ADMBase_ApplyBCs: Apply the boundary conditions of ADMBase
            GROUP BoundaryConditions: Execute all boundary conditions
              Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
              CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
              Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
              CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
            Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          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
                  CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                  Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                  CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
                Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
            GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
          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
        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
        Formaline::Formaline_AnnounceUpdate: [global] Put some meta information about the current run into permanent storage
        LoopControl::lc_statistics_analysis: [meta] Output LoopControl statistics
  endif
  Output grid variables

  do loop over timesteps
    [CCTK_PREREGRID]
      SWTNS::SWTNS_inittest: TEST the system
    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 MultiPatch_SpatialCoordinates: Determine the global coordinates of each gridpoint.
        Coordinates::Coordinates_SetGlobalCoords: [local] Determine the global coordinates of each gridpoint.
        Coordinates::Coordinates_SetJacobian: [local] Fill in the Jacobian matrices for Thornburg04 coordinates.
        Coordinates::Coordinates_SetInverseJacobian: [local] Numerically evaluate the inverse Jacobian matrices.
        Coordinates::Coordinates_SetVolumeForm: [local] Set weight mask (for Carpet reduction operators)
      GROUP MoL_PostStep: Ensure that everything is correct after regridding
        ADMBase::ADMBase_Boundaries: [level] Select ADMBase boundary conditions - may be required for mesh refinement
        GROUP ADMBase_ApplyBCs: Apply the boundary conditions of ADMBase
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
            CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
            Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
            CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
        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
                CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
              Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
        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
      GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
      SWTNS::SWTNS_regridtest: TEST the system
      SpaceMask::MaskZero: Initialise mask to zero
      SpaceMask::MaskOne: Set mask to one
    Rotate timelevels
    iteration = iteration+1
    t = t+dt
    [CCTK_PRESTEP]
      ADMBase::ADMBase_LapseStatic: Copy the lapse to the current time level
      ADMBase::ADMBase_ShiftStatic: Copy the shift to the current time level
      ADMBase::ADMBase_Static: Copy the metric and extrinsic curvature to the current time level
      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
          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
                GROUP HydroBase_RHS: Groups for scheduling tasks for calculating RHS of hydro variables
                SWTNS::SWTNS_calc_rhs: Calculate the RHS
              GROUP MoL_PostRHS: Modify RHS functions
              GROUP MoL_RHSBoundaries: Any 'final' modifications to the RHS functions (boundaries etc.)
              MoL::MoL_Add: Updates calculated with a generic method
              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.
                ADMBase::ADMBase_Boundaries: [level] Select ADMBase boundary conditions - may be required for mesh refinement
                GROUP ADMBase_ApplyBCs: Apply the boundary conditions of ADMBase
                  GROUP BoundaryConditions: Execute all boundary conditions
                    Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
                    CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
                    CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                    Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                    CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
                  Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
                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
                        CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                        Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                        CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
                      Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
                  GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
                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
              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
    Evolve finer grids recursively
    Restrict from finer grids
    [CCTK_POSTRESTRICT]
      GROUP MoL_PostStep: Ensure that everything is correct after restriction
        ADMBase::ADMBase_Boundaries: [level] Select ADMBase boundary conditions - may be required for mesh refinement
        GROUP ADMBase_ApplyBCs: Apply the boundary conditions of ADMBase
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
            CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
            Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
            CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
        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
                CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
              Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
        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
      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
      Formaline::Formaline_AnnounceUpdate: [global] Put some meta information about the current run into permanent storage
      LoopControl::lc_statistics_analysis: [meta] Output LoopControl statistics
    endif
    Output grid variables
    enddo

  Termination routines
    [CCTK_TERMINATE]
      CarpetIOHDF5::CarpetIOHDF5_TerminationCheckpoint: [meta] Termination checkpoint routine
      Formaline::Formaline_AnnounceFinal: [global] Put some meta information about the current run into permanent storage
      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 MultiPatch_SpatialCoordinates: Determine the global coordinates of each gridpoint.
        Coordinates::Coordinates_SetGlobalCoords: [local] Determine the global coordinates of each gridpoint.
        Coordinates::Coordinates_SetJacobian: [local] Fill in the Jacobian matrices for Thornburg04 coordinates.
        Coordinates::Coordinates_SetInverseJacobian: [local] Numerically evaluate the inverse Jacobian matrices.
        Coordinates::Coordinates_SetVolumeForm: [local] Set weight mask (for Carpet reduction operators)
      GROUP MoL_PostStep: Ensure that everything is correct after regridding
        ADMBase::ADMBase_Boundaries: [level] Select ADMBase boundary conditions - may be required for mesh refinement
        GROUP ADMBase_ApplyBCs: Apply the boundary conditions of ADMBase
          GROUP BoundaryConditions: Execute all boundary conditions
            Boundary::Boundary_ApplyPhysicalBCs: Apply all requested local physical boundary conditions
            CartGrid3D::CartGrid3D_ApplyBC: Apply symmetry boundary conditions
            CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
            Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
            CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
          Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
        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
                CoordinatesSymmetry::CoordinatesSymmetry_Apply_FirstPass: Apply multipatch symmetries
                Interpolate2::Interpolate2ApplyBC: [level] Apply interpolating inter-patch boundaries
                CoordinatesSymmetry::CoordinatesSymmetry_Apply_SecondPass: Apply multipatch symmetries for remaining points not filled by interpatch interpolation
              Boundary::Boundary_ClearSelection: [level] Unselect all grid variables for boundary conditions
          GROUP HydroBase_Con2Prim: Convert from conservative to primitive variables
        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
      GROUP MoL_PseudoEvolutionBoundaries: Apply boundary conditions to pseudo-evolved quantities
      SWTNS::SWTNS_regridtest: TEST the system
      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 0.373 seconds
Current core file size limit: hard=[unlimited], soft=0 MB
Current memory size limit: hard=[unlimited], soft=[unlimited]
INFO (CycleClock): Measuring CycleClock tick via OpenMP...
INFO (CycleClock): Calibrated CycleClock: 0.398509 ns per clock tick (2.50935 GHz)
INFO (Formaline): Configuration id: config-Pingudebug-Baade-home-frank-Cactus
INFO (Formaline): Build id: build-Pingudebug-Baade-frank-2019.06.14-16.17.11-27330
INFO (Formaline): Simulation id: run-SWTNS_test-Baade-frank-2019.06.14-16.17.45-30059
INFO (Formaline): Run id: run-SWTNS_test-Baade-frank-2019.06.14-16.17.45-30059
INFO (Vectors): Using vector size 2 for architecture SSE2 (64-bit precision)
--------------------------------------------------------------------------------
AMR driver provided by Carpet
--------------------------------------------------------------------------------
AMR info I/O provided by CarpetIOBasic
--------------------------------------------------------------------------------
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 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
--------------------------------------------------------------------------------
MoL: Generalized time integration.
--------------------------------------------------------------------------------
SWTNS
--------------------------------------------------------------------------------
AMR scalar I/O provided by CarpetIOScalar
--------------------------------------------------------------------------------

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 6 threads, this is thread 0
INFO (Carpet): There are 12 threads in total
INFO (Carpet): There are 6 threads per process
INFO (Carpet): This process runs on host Baade, pid=30059
INFO (Carpet): This process runs on 24 cores: 0-23
INFO (Carpet): Thread 0 runs on 24 cores: 0-23
INFO (Carpet): Thread 1 runs on 24 cores: 0-23
INFO (Carpet): Thread 2 runs on 24 cores: 0-23
INFO (Carpet): Thread 3 runs on 24 cores: 0-23
INFO (Carpet): Thread 4 runs on 24 cores: 0-23
INFO (Carpet): Thread 5 runs on 24 cores: 0-23
INFO (Carpet): This simulation is running in 3 dimensions
INFO (Carpet): Boundary specification for map 0:
   nboundaryzones: [[5,5,5],[5,5,5]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[4,4,4],[4,4,4]]
INFO (Carpet): CoordBase domain specification for map 0:
   physical extent: [-1.8,-1.8,-1.8] : [1.8,1.8,1.8]   ([3.6,3.6,3.6])
   interior extent: [-2.1,-2.1,-2.1] : [2.1,2.1,2.1]   ([4.2,4.2,4.2])
   exterior extent: [-2.6,-2.6,-2.6] : [2.6,2.6,2.6]   ([5.2,5.2,5.2])
   base_spacing   : [0.1,0.1,0.1]
INFO (Carpet): Adapted domain specification for map 0:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-1.8,-1.8,-1.8] : [1.8,1.8,1.8]   ([3.6,3.6,3.6])
   interior extent   : [-2.1,-2.1,-2.1] : [2.1,2.1,2.1]   ([4.2,4.2,4.2])
   exterior extent   : [-2.6,-2.6,-2.6] : [2.6,2.6,2.6]   ([5.2,5.2,5.2])
   spacing           : [0.1,0.1,0.1]
INFO (Carpet): Base grid specification for map 0:
   number of grid points             : [53,53,53]
   number of coarse grid ghost points: [[5,5,5],[5,5,5]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Boundary specification for map 1:
   nboundaryzones: [[5,5,5],[5,5,5]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[4,4,4],[4,4,0]]
INFO (Carpet): CoordBase domain specification for map 1:
   physical extent: [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent: [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent: [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   base_spacing   : [0.0785398,0.0785398,0.11]
INFO (Carpet): Adapted domain specification for map 1:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent   : [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent   : [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   spacing           : [0.0785398,0.0785398,0.11]
INFO (Carpet): Base grid specification for map 1:
   number of grid points             : [37,37,43]
   number of coarse grid ghost points: [[5,5,5],[5,5,5]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Boundary specification for map 2:
   nboundaryzones: [[5,5,5],[5,5,5]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[4,4,4],[4,4,0]]
INFO (Carpet): CoordBase domain specification for map 2:
   physical extent: [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent: [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent: [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   base_spacing   : [0.0785398,0.0785398,0.11]
INFO (Carpet): Adapted domain specification for map 2:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent   : [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent   : [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   spacing           : [0.0785398,0.0785398,0.11]
INFO (Carpet): Base grid specification for map 2:
   number of grid points             : [37,37,43]
   number of coarse grid ghost points: [[5,5,5],[5,5,5]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Boundary specification for map 3:
   nboundaryzones: [[5,5,5],[5,5,5]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[4,4,4],[4,4,0]]
INFO (Carpet): CoordBase domain specification for map 3:
   physical extent: [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent: [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent: [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   base_spacing   : [0.0785398,0.0785398,0.11]
INFO (Carpet): Adapted domain specification for map 3:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent   : [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent   : [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   spacing           : [0.0785398,0.0785398,0.11]
INFO (Carpet): Base grid specification for map 3:
   number of grid points             : [37,37,43]
   number of coarse grid ghost points: [[5,5,5],[5,5,5]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Boundary specification for map 4:
   nboundaryzones: [[5,5,5],[5,5,5]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[4,4,4],[4,4,0]]
INFO (Carpet): CoordBase domain specification for map 4:
   physical extent: [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent: [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent: [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   base_spacing   : [0.0785398,0.0785398,0.11]
INFO (Carpet): Adapted domain specification for map 4:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent   : [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent   : [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   spacing           : [0.0785398,0.0785398,0.11]
INFO (Carpet): Base grid specification for map 4:
   number of grid points             : [37,37,43]
   number of coarse grid ghost points: [[5,5,5],[5,5,5]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Boundary specification for map 5:
   nboundaryzones: [[5,5,5],[5,5,5]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[4,4,4],[4,4,0]]
INFO (Carpet): CoordBase domain specification for map 5:
   physical extent: [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent: [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent: [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   base_spacing   : [0.0785398,0.0785398,0.11]
INFO (Carpet): Adapted domain specification for map 5:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent   : [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent   : [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   spacing           : [0.0785398,0.0785398,0.11]
INFO (Carpet): Base grid specification for map 5:
   number of grid points             : [37,37,43]
   number of coarse grid ghost points: [[5,5,5],[5,5,5]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Boundary specification for map 6:
   nboundaryzones: [[5,5,5],[5,5,5]]
   is_internal   : [[0,0,0],[0,0,0]]
   is_staggered  : [[0,0,0],[0,0,0]]
   shiftout      : [[4,4,4],[4,4,0]]
INFO (Carpet): CoordBase domain specification for map 6:
   physical extent: [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent: [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent: [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   base_spacing   : [0.0785398,0.0785398,0.11]
INFO (Carpet): Adapted domain specification for map 6:
   convergence factor: 2
   convergence level : 0
   physical extent   : [-0.785398,-0.785398,1.8] : [0.785398,0.785398,5.1]   ([1.5708,1.5708,3.3])
   interior extent   : [-1.02102,-1.02102,1.47] : [1.02102,1.02102,4.99]   ([2.04204,2.04204,3.52])
   exterior extent   : [-1.41372,-1.41372,0.92] : [1.41372,1.41372,5.54]   ([2.82743,2.82743,4.62])
   spacing           : [0.0785398,0.0785398,0.11]
INFO (Carpet): Base grid specification for map 6:
   number of grid points             : [37,37,43]
   number of coarse grid ghost points: [[5,5,5],[5,5,5]]
INFO (Carpet): Buffer zone counts (excluding ghosts):
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Overlap zone counts:
   [0]: [[0,0,0],[0,0,0]]
INFO (Carpet): Group and variable statistics:
INFO (Carpet):    There are 1059 grid functions in 62 groups
INFO (Carpet):    There are 94 grid scalars in 48 groups
INFO (Carpet):    There are 11 1-dimensional grid arrays in 4 groups
INFO (Carpet):    There are 1 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)
WARNING[L2,P0] (IOUtil): Parameter file 'SWTNS_test.par' to be written into directory '.' is identical with original parameter file. Parameter file will not be copied.
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): 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): Periodic AMR output requested for:
   GRID::x
   GRID::y
   GRID::z
   GRID::r
   HYDROBASE::rho
   HYDROBASE::press
   SWTNS::Xi
   SWTNS::Pidot
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
--------------------------------------------------------------------------------
INFO (Formaline): Writing tarballs with the Cactus sources into the directory "./cactus-source"
INFO (MoL): Using Generic Runge-Kutta 4 as the time integrator.
INFO (SymBase): Symmetry on lower x-face: multipatch
INFO (SymBase): Symmetry on upper x-face: multipatch
INFO (SymBase): Symmetry on lower y-face: multipatch
INFO (SymBase): Symmetry on upper y-face: multipatch
INFO (SymBase): Symmetry on lower z-face: multipatch
INFO (SymBase): Symmetry on upper z-face: multipatch
INFO (MoL): The maximum number of evolved variables is 277. 2 are registered.
INFO (MoL): The maximum number of slow evolved variables is 277. 0 are registered.
INFO (MoL): The maximum number of constrained variables is 277. 0 are registered.
INFO (MoL): The maximum number of SandR variables is 277. 0 are registered.
INFO (MoL): The maximum number of evolved array variables is 277. 0 are registered.
INFO (MoL): The maximum number of constrained array variables is 277. 0 are registered.
INFO (MoL): The maximum number of SandR array variables is 277. 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): 373/373 tests passed 
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>1.0000000e-01  dy=>1.0000000e-01  dz=>1.0000000e-01
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-2.600, 2.600]  y=>[-2.600, 2.600]  z=>[-2.600, 2.600]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,52]  y=>[0,52]  z=>[0,52]
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>7.8539816e-02  dy=>7.8539816e-02  dz=>1.1000000e-01
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-1.414, 1.414]  y=>[-1.414, 1.414]  z=>[ 0.920, 5.540]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,36]  y=>[0,36]  z=>[0,42]
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>7.8539816e-02  dy=>7.8539816e-02  dz=>1.1000000e-01
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-1.414, 1.414]  y=>[-1.414, 1.414]  z=>[ 0.920, 5.540]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,36]  y=>[0,36]  z=>[0,42]
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>7.8539816e-02  dy=>7.8539816e-02  dz=>1.1000000e-01
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-1.414, 1.414]  y=>[-1.414, 1.414]  z=>[ 0.920, 5.540]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,36]  y=>[0,36]  z=>[0,42]
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>7.8539816e-02  dy=>7.8539816e-02  dz=>1.1000000e-01
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-1.414, 1.414]  y=>[-1.414, 1.414]  z=>[ 0.920, 5.540]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,36]  y=>[0,36]  z=>[0,42]
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>7.8539816e-02  dy=>7.8539816e-02  dz=>1.1000000e-01
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-1.414, 1.414]  y=>[-1.414, 1.414]  z=>[ 0.920, 5.540]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,36]  y=>[0,36]  z=>[0,42]
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRange: Range already registered for system 'cart3d'
WARNING[L3,P0] (Cactus): CCTK_CoordRegisterRangePhysIndex: Range already registered for system 'cart3d'
INFO (CartGrid3D): Grid Spacings:
INFO (CartGrid3D): dx=>7.8539816e-02  dy=>7.8539816e-02  dz=>1.1000000e-01
INFO (CartGrid3D): Computational Coordinates:
INFO (CartGrid3D): x=>[-1.414, 1.414]  y=>[-1.414, 1.414]  z=>[ 0.920, 5.540]
INFO (CartGrid3D): Indices of Physical Coordinates:
INFO (CartGrid3D): x=>[0,36]  y=>[0,36]  z=>[0,42]
INFO (Coordinates): Setting up global coordinates for thornburg04.
INFO (Coordinates): Setting up global coordinates for thornburg04.
INFO (Coordinates): Setting up global coordinates for thornburg04.
INFO (Coordinates): Setting up global coordinates for thornburg04.
INFO (Coordinates): Setting local coordinates: Thornburg04
INFO (Coordinates): Setting local coordinates: Thornburg04
INFO (Coordinates): Setting local coordinates: Thornburg04
INFO (Coordinates): Setting local coordinates: Thornburg04
INFO (Interpolate2): Setting up interpolation for level 0
INFO (TOVSolver): Integrated TOV equation
INFO (TOVSolver): Radius of Star no 1 i=0 has been written to Radius of SWTNS Thorn
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   8.12502  1.40016  1.50618 2.78e+33  0.00128 7.92e+14      100 1.45e+05        2
INFO (TOVSolver): Not using old matter initial data
INFO (TOVSolver): Done interpolation.
INFO (TOVSolver): metric potential PHI from star no 1 has been written to SWTNS Thorn
INFO (TOVSolver): Not using old matter initial data
INFO (TOVSolver): Done interpolation.
INFO (TOVSolver): metric potential PHI from star no 1 has been written to SWTNS Thorn
INFO (TOVSolver): Not using old matter initial data
INFO (TOVSolver): Done interpolation.
INFO (TOVSolver): metric potential PHI from star no 1 has been written to SWTNS Thorn
INFO (TOVSolver): Not using old matter initial data
INFO (TOVSolver): Done interpolation.
INFO (TOVSolver): metric potential PHI from star no 1 has been written to SWTNS Thorn
 Check if PHI and TOV_R are global...
 Radius =    8.1250189592188544     
 start initial
 done initial
 PHI(7,1,1) =  -0.31203947166319207     
 Xi(7,1,1) =   -1.6659814841362133     
 gappa(7,1,1) =    1.3752656760887515E-003
 LAMBDA(7,1,1) =    2.3504790755095938E-002
 PHI(7,1,1) =  -0.31203947166319207     
 Check if PHI and TOV_R are global...
 Radius =    8.1250189592188544     
 start initial
 done initial
 PHI(7,1,1) =  -0.28239377817209776     
 Xi(7,1,1) =   -1.0011460856491121     
 gappa(7,1,1) =    1.8076449973081683E-003
 LAMBDA(7,1,1) =    2.2101014560640550E-002
 PHI(7,1,1) =  -0.28239377817209776     
 Check if PHI and TOV_R are global...
 Radius =    8.1250189592188544     
 start initial
 done initial
 PHI(7,1,1) =  -0.24524991108592692     
 Xi(7,1,1) =   -2.9258434528059707E-002
 gappa(7,1,1) =    2.7803092031021891E-003
 LAMBDA(7,1,1) =    1.7602502069937798E-002
 PHI(7,1,1) =  -0.24524991108592692     
 Check if PHI and TOV_R are global...
 Radius =    8.1250189592188544     
 start initial
 done initial
 PHI(7,1,1) =  -0.24524991108592692     
 Xi(7,1,1) =   -2.9258434528059707E-002
 gappa(7,1,1) =    2.7803092031021891E-003
 LAMBDA(7,1,1) =    1.7602502069937798E-002
 PHI(7,1,1) =  -0.24524991108592692     
---------------------------------------------------------------------------------------------------------------------------------------------------------------
Iteration      Time |              SWTNS::gappa |                SWTNS::PHI |             SWTNS::LAMBDA |                 SWTNS::Xi |              SWTNS::Pidot
                    |      minimum      maximum |      minimum      maximum |      minimum      maximum |      minimum      maximum |      minimum      maximum
---------------------------------------------------------------------------------------------------------------------------------------------------------------
        0     0.000 |    0.0009607    0.0028877 |   -0.3120395   -0.2452499 |    0.0176025    0.0235048 |   -2.3314292    0.0000000 |   -2.3314292    0.0000000
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =   -1.6659814841362133     
 Pi =  -0.77156041097629624     
 gappa =    1.3752656760887515E-003
 LAMBDA =    2.3504790755095938E-002
 PHI =  -0.31203947166319207     
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =   -1.0011460856491121     
 Pi =  -0.70877210207930408     
 gappa =    1.8076449973081683E-003
 LAMBDA =    2.2101014560640550E-002
 PHI =  -0.28239377817209776     
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =   -2.9258434528059707E-002
 Pi =   -9.3796313558531977E-002
 gappa =    2.7803092031021891E-003
 LAMBDA =    1.7602502069937798E-002
 PHI =  -0.24524991108592692     
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =   -2.9258434528059707E-002
 Pi =   -9.3796313558531977E-002
 gappa =    2.7803092031021891E-003
 LAMBDA =    1.7602502069937798E-002
 PHI =  -0.24524991108592692     
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =   -1.6659814841362133     
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =   0.36853026149343271     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =  -0.13571036654178581     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =   -1.0011460856491121     
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =   0.42886871367008417     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =  -0.19643074159405582     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =   -2.9258434528059707E-002
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =    0.0000000000000000     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =    0.0000000000000000     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =   -2.9258434528059707E-002
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =   -0.0000000000000000     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =    0.0000000000000000     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =   -1.7007017026301465     
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =   0.36791447413233591     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =  -0.13311017014654425     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =   -1.0330408302426808     
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =   0.43336535925556585     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =  -0.19468315521501411     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =   -3.3479268638193643E-002
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =    0.0000000000000000     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =    0.0000000000000000     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =   -3.3479268638193643E-002
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =   -0.0000000000000000     
 dyXi =    0.0000000000000000     
 dzXi =    0.0000000000000000     
 drXi =    0.0000000000000000     
 dxxXi =    0.0000000000000000     
 dxyXi =    0.0000000000000000     
 dxzXi =    0.0000000000000000     
 dyyXi =    0.0000000000000000     
 dyzXi =    0.0000000000000000     
 dzzXi =    0.0000000000000000     
 drrXi =    0.0000000000000000     
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
        4     0.360 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
        8     0.720 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 ###########################################
 testing initial...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 Pi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 tested inital!
 ###########################################
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z =  -2.6000000000000001     
 r =   4.1856899072912706     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  -2.0000000000000000     
 y =  -2.6000000000000001     
 z = -0.39999999999999991     
 r =   3.3045423283716615     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x =  0.14069534150978583     
 y = -0.88831542556513243     
 z = -0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
 allocate RHS...
 start right hand side
 iterating...
 giving example points for (7,1,1) position
 x = -0.14069534150978583     
 y =  0.88831542556513243     
 z =  0.19365052434858662     
 r =  0.92000000000000004     
 Xi =                        NaN
 gappa =                        NaN
 LAMBDA =                        NaN
 PHI =                        NaN
 dxPHI =                        NaN
 dyPHI =                        NaN
 dzPHI =                        NaN
 drPHI =                        NaN
 Wr =                        NaN
 Pr =                        NaN
 dxPr =                        NaN
 dyPr =                        NaN
 dzPr =                        NaN
 drPr =                        NaN
 Qr =                        NaN
 dxXi =                        NaN
 dyXi =                        NaN
 dzXi =                        NaN
 drXi =                        NaN
 dxxXi =                        NaN
 dxyXi =                        NaN
 dxzXi =                        NaN
 dyyXi =                        NaN
 dyzXi =                        NaN
 dzzXi =                        NaN
 drrXi =                        NaN
 Pidot =                        NaN
 done right hand side
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 89888 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 87079 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Xi'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::Pidot'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::PHI'
WARNING[L1,P0] (NaNChecker): There were 58867 NaN/Inf value(s) found in variable 'SWTNS::LAMBDA'
WARNING[L2,P0] (CarpetIOHDF5): Option string 'downsample={1 1 1}' will be ignored for HDF5 output of variable 'NANCHECKER::NaNmask'
       12     1.080 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308 | 1.797693e+308 -1.797693e+308
INFO (Carpet): Terminating due to cctk_final_time at t = 1.080000
--------------------------------------------------------------------------------
Done.
Stopping:
Fr 14. Jun 18:19:39 CEST 2019
Done.
Fr 14. Jun 18:19:39 CEST 2019
Simfactory Done at date: 0


More information about the Users mailing list