diff --git a/Makefile.Defines b/Makefile.Defines index 291f2c604..820ad6d7d 100644 --- a/Makefile.Defines +++ b/Makefile.Defines @@ -65,13 +65,13 @@ GPAR = -fopenmp -ftree-parallelize-loops=4 GMEM = -fsanitize=undefined -fsanitize=address -fsanitize=leak GWARNINGS = -Wall -Warray-bounds -Wimplicit-interface -Wextra -Warray-temporaries -FFLAGS = $(IDEBUG) $(HEAPARR) -#FFLAGS = -init=snan,arrays -no-wrap-margin -O3 $(STRICTREAL) $(SIMDVEC) $(PAR) +#FFLAGS = $(IDEBUG) $(HEAPARR) +FFLAGS = -init=snan,arrays -no-wrap-margin -O3 $(STRICTREAL) $(SIMDVEC) $(PAR) FORTRAN = ifort #AR = xiar #FORTRAN = gfortran -#FFLAGS = -ffree-line-length-none $(GDEBUG) $(GMEM) +#FFLAGS = -ffree-line-length-none $(GDEBUG) #$(GMEM) AR = ar # DO NOT include in CFLAGS the "-c" option to compile object only diff --git a/descriptionator.sh b/descriptionator.sh deleted file mode 100755 index 3d86c8f14..000000000 --- a/descriptionator.sh +++ /dev/null @@ -1,7 +0,0 @@ -#!/bin/bash -for file_out in */*.f90; do - file_in="../../swifter-omp/$file_out"; - desc=$(grep "Description" $file_in | sed "s/! Description : //") - sed -i "" "s/Compute Hill sphere radii of massive bodie/$desc/" $file_out -done - diff --git a/docs/src/fragmentation.f90 b/docs/src/fragmentation.f90 index 460060183..c90f64cb4 100644 --- a/docs/src/fragmentation.f90 +++ b/docs/src/fragmentation.f90 @@ -369,7 +369,7 @@ subroutine calculate_system_energy(linclude_fragments) class is (symba_pl) select type(param) class is (symba_parameters) - plwksp%nplm = count(plwksp%Gmass > param%mtiny / mscale) + plwksp%nplm = count(plwksp%Gmass > param%Gmtiny / mscale) end select end select call tmpsys%pl%eucl_index() @@ -381,7 +381,7 @@ subroutine calculate_system_energy(linclude_fragments) class is (symba_pl) select type(param) class is (symba_parameters) - nplm = count(pl%mass > param%mtiny) + nplm = count(pl%mass > param%Gmtiny) end select end select if (lk_plpl) call pl%eucl_index() @@ -836,7 +836,7 @@ end subroutine fragmentation_initialize - module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, vb2, den1, den2, regime, Mlr, Mslr, mtiny, Qloss) + module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, vb2, den1, den2, regime, Mlr, Mslr, Gmtiny, Qloss) !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton !! !! Determine the collisional regime of two colliding bodies. @@ -857,7 +857,7 @@ module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, v ! Arguments integer(I4B), intent(out) :: regime real(DP), intent(out) :: Mlr, Mslr - real(DP), intent(in) :: Mcb, m1, m2, rad1, rad2, den1, den2, mtiny + real(DP), intent(in) :: Mcb, m1, m2, rad1, rad2, den1, den2, Gmtiny real(DP), dimension(:), intent(in) :: xh1, xh2, vb1, vb2 real(DP), intent(out) :: Qloss !! The residual energy after the collision ! Constants @@ -931,7 +931,7 @@ module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, v Qloss = 0.0_DP U_binding = (3.0_DP * Mtot) / (5.0_DP * Rp) ! LS12 eq. 27 - if ((m1 < mtiny).or.(m2 < mtiny)) then + if ((m1 < Gmtiny).or.(m2 < Gmtiny)) then regime = COLLRESOLVE_REGIME_MERGE !perfect merging regime Mlr = Mtot Mslr = 0.0_DP diff --git a/docs/src/io.f90 b/docs/src/io.f90 index 42cc8ddd9..1e0e8d626 100644 --- a/docs/src/io.f90 +++ b/docs/src/io.f90 @@ -493,7 +493,7 @@ module subroutine io_param_reader(self, unit, iotype, v_list, iostat, iomsg) read(param_value, *) param%Ecollisions case("EUNTRACKED") read(param_value, *) param%Euntracked - case ("NPLMAX", "NTPMAX", "MTINY", "PARTICLE_FILE", "FRAGMENTATION", "SEED", "YARKOVSKY", "YORP") ! Ignore SyMBA-specific, not-yet-implemented, or obsolete input parameters + case ("NPLMAX", "NTPMAX", "GMTINY", "PARTICLE_FILE", "FRAGMENTATION", "SEED", "YARKOVSKY", "YORP") ! Ignore SyMBA-specific, not-yet-implemented, or obsolete input parameters case default write(iomsg,*) "Unknown parameter -> ",param_name iostat = -1 @@ -1211,16 +1211,20 @@ module subroutine io_write_discard(self, param) associate(tp_discards => self%tp_discards, nsp => self%tp_discards%nbody, pl => self%pl, npl => self%pl%nbody) if (nsp == 0) return - select case(param%out_stat) - case('APPEND') + if (lfirst) then + select case(param%out_stat) + case('APPEND') + open(unit = LUN, file = param%discard_out, status = 'OLD', position = 'APPEND', form = 'FORMATTED', iostat = ierr) + case('NEW', 'REPLACE', 'UNKNOWN') + open(unit = LUN, file = param%discard_out, status = param%out_stat, form = 'FORMATTED', iostat = ierr) + case default + write(*,*) 'Invalid status code for OUT_STAT: ',trim(adjustl(param%out_stat)) + call util_exit(FAILURE) + end select + lfirst = .false. + else open(unit = LUN, file = param%discard_out, status = 'OLD', position = 'APPEND', form = 'FORMATTED', iostat = ierr) - case('NEW', 'REPLACE', 'UNKNOWN') - open(unit = LUN, file = param%discard_out, status = param%out_stat, form = 'FORMATTED', iostat = ierr) - case default - write(*,*) 'Invalid status code for OUT_STAT: ',trim(adjustl(param%out_stat)) - call util_exit(FAILURE) - end select - lfirst = .false. + end if if (param%lgr) call tp_discards%pv2v(param) write(LUN, HDRFMT) param%t, nsp, param%lbig_discard diff --git a/docs/src/setup.f90 b/docs/src/setup.f90 index 6cba6d27b..9346e8c12 100644 --- a/docs/src/setup.f90 +++ b/docs/src/setup.f90 @@ -54,8 +54,8 @@ module subroutine setup_construct_system(system, param) allocate(symba_pl :: system%pl) allocate(symba_tp :: system%tp) allocate(symba_tp :: system%tp_discards) - allocate(symba_merger :: system%mergeadd_list) - allocate(symba_merger :: system%mergesub_list) + allocate(symba_merger :: system%pl_adds) + allocate(symba_merger :: system%pl_discards) allocate(symba_plplenc :: system%plplenc_list) allocate(symba_pltpenc :: system%pltpenc_list) end select diff --git a/docs/src/swiftest_classes.f90 b/docs/src/swiftest_classes.f90 index 2455e77f2..051add1aa 100644 --- a/docs/src/swiftest_classes.f90 +++ b/docs/src/swiftest_classes.f90 @@ -469,11 +469,11 @@ module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, real(DP), intent(inout) :: Qloss end subroutine fragmentation_initialize - module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, vb2, den1, den2, regime, Mlr, Mslr, mtiny, Qloss) + module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, vb2, den1, den2, regime, Mlr, Mslr, Gmtiny, Qloss) implicit none integer(I4B), intent(out) :: regime real(DP), intent(out) :: Mlr, Mslr - real(DP), intent(in) :: Mcb, m1, m2, rad1, rad2, den1, den2, mtiny + real(DP), intent(in) :: Mcb, m1, m2, rad1, rad2, den1, den2, Gmtiny real(DP), dimension(:), intent(in) :: xh1, xh2, vb1, vb2 real(DP), intent(out) :: Qloss !! The residual energy after the collision end subroutine fragmentation_regime diff --git a/docs/src/symba_classes.f90 b/docs/src/symba_classes.f90 index 0e66ebf7c..6ecb27751 100644 --- a/docs/src/symba_classes.f90 +++ b/docs/src/symba_classes.f90 @@ -19,7 +19,7 @@ module symba_classes type, extends(swiftest_parameters) :: symba_parameters character(STRMAX) :: particle_file = PARTICLE_OUTFILE !! Name of output particle information file - real(DP) :: MTINY = -1.0_DP !! Smallest mass that is fully gravitating + real(DP) :: GMTINY = -1.0_DP !! Smallest mass that is fully gravitating integer(I4B), dimension(:), allocatable :: seed !! Random seeds logical :: lfragmentation = .false. !! Do fragmentation modeling instead of simple merger. contains @@ -73,9 +73,9 @@ module symba_classes type, extends(helio_pl) :: symba_pl logical, dimension(:), allocatable :: lcollision !! flag indicating whether body has merged with another this time step logical, dimension(:), allocatable :: lencounter !! flag indicating whether body is part of an encounter this time step - logical, dimension(:), allocatable :: lmtiny !! flag indicating whether this body is below the MTINY cutoff value - integer(I4B) :: nplm !! number of bodies above the MTINY limit - integer(I8B) :: nplplm !! Number of body (all massive)-body (only those above MTINY) comparisons in the flattened upper triangular matrix + logical, dimension(:), allocatable :: lmtiny !! flag indicating whether this body is below the GMTINY cutoff value + integer(I4B) :: nplm !! number of bodies above the GMTINY limit + integer(I8B) :: nplplm !! Number of body (all massive)-body (only those above GMTINY) comparisons in the flattened upper triangular matrix integer(I4B), dimension(:), allocatable :: nplenc !! number of encounters with other planets this time step integer(I4B), dimension(:), allocatable :: ntpenc !! number of encounters with test particles this time step integer(I4B), dimension(:), allocatable :: levelg !! level at which this body should be moved @@ -160,8 +160,8 @@ module symba_classes ! symba_nbody_system class definitions and method interfaces !******************************************************************************************************************************** type, extends(helio_nbody_system) :: symba_nbody_system - class(symba_merger), allocatable :: mergeadd_list !! List of added bodies in mergers or collisions - class(symba_merger), allocatable :: mergesub_list !! List of subtracted bodies in mergers or collisions + class(symba_merger), allocatable :: pl_adds !! List of added bodies in mergers or collisions + class(symba_merger), allocatable :: pl_discards !! List of subtracted bodies in mergers or collisions class(symba_pltpenc), allocatable :: pltpenc_list !! List of massive body-test particle encounters in a single step class(symba_plplenc), allocatable :: plplenc_list !! List of massive body-massive body encounters in a single step integer(I4B) :: irec !! System recursion level diff --git a/docs/src/symba_collision.f90 b/docs/src/symba_collision.f90 index 952d59709..caffdf296 100644 --- a/docs/src/symba_collision.f90 +++ b/docs/src/symba_collision.f90 @@ -449,7 +449,7 @@ module subroutine symba_collision_resolve_fragmentations(self, system, param) v2_si(:) = plpl_collisions%v2(:,i) * param%DU2M / param%TU2S !! The velocity of the parent from inside the step (at collision) density_si(:) = mass_si(:) / (4.0_DP / 3._DP * PI * radius_si(:)**3) !! The collective density of the parent and its children Mcb_si = cb%mass * param%MU2KG - mtiny_si = (param%MTINY / param%GU) * param%MU2KG + mtiny_si = (param%GMTINY / param%GU) * param%MU2KG mass_res(:) = 0.0_DP diff --git a/docs/src/symba_fragmentation.f90 b/docs/src/symba_fragmentation.f90 index efdd8c0d7..9c13170af 100644 --- a/docs/src/symba_fragmentation.f90 +++ b/docs/src/symba_fragmentation.f90 @@ -34,7 +34,7 @@ module function symba_fragmentation_casedisruption(system, param, family, x, v, select type(pl => system%pl) class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) + associate(pl_adds => system%pl_adds, pl_discards => system%pl_discards, cb => system%cb) ! Collisional fragments will be uniformly distributed around the pre-impact barycenter nfrag = NFRAG_DISRUPT allocate(m_frag(nfrag)) @@ -91,11 +91,11 @@ module function symba_fragmentation_casedisruption(system, param, family, x, v, lmask(:) = .false. lmask(family(:)) = .true. pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) + nstart = pl_discards%nbody + 1 + nend = pl_discards%nbody + nfamily + call pl_discards%append(pl, lmask) ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily + pl_discards%ncomp(nstart:nend) = nfamily allocate(plnew, mold=pl) call plnew%setup(nfrag, param) @@ -133,10 +133,10 @@ module function symba_fragmentation_casedisruption(system, param, family, x, v, end if ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody + nstart = pl_adds%nbody + 1 + nend = pl_adds%nbody + plnew%nbody + call pl_adds%append(plnew) + pl_adds%ncomp(nstart:nend) = plnew%nbody call plnew%setup(0, param) deallocate(plnew) @@ -179,7 +179,7 @@ module function symba_fragmentation_casehitandrun(system, param, family, x, v, m select type(pl => system%pl) class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) + associate(pl_adds => system%pl_adds, pl_discards => system%pl_discards, cb => system%cb) mtot = sum(mass(:)) xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot @@ -247,11 +247,11 @@ module function symba_fragmentation_casehitandrun(system, param, family, x, v, m lmask(:) = .false. lmask(family(:)) = .true. pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) + nstart = pl_discards%nbody + 1 + nend = pl_discards%nbody + nfamily + call pl_discards%append(pl, lmask) ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily + pl_discards%ncomp(nstart:nend) = nfamily allocate(plnew, mold=pl) call plnew%setup(nfrag, param) @@ -289,10 +289,10 @@ module function symba_fragmentation_casehitandrun(system, param, family, x, v, m end if ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody + nstart = pl_adds%nbody + 1 + nend = pl_adds%nbody + plnew%nbody + call pl_adds%append(plnew) + pl_adds%ncomp(nstart:nend) = plnew%nbody call plnew%setup(0, param) deallocate(plnew) @@ -334,7 +334,7 @@ module function symba_fragmentation_casemerge(system, param, family, x, v, mass, select type(pl => system%pl) class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) + associate(pl_adds => system%pl_adds, pl_discards => system%pl_discards, cb => system%cb) status = MERGED write(*, '("Merging bodies ",99(I8,",",:))') pl%id(family(:)) mass_new = sum(mass(:)) @@ -386,11 +386,11 @@ module function symba_fragmentation_casemerge(system, param, family, x, v, mass, lmask(:) = .false. lmask(family(:)) = .true. pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) + nstart = pl_discards%nbody + 1 + nend = pl_discards%nbody + nfamily + call pl_discards%append(pl, lmask) ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily + pl_discards%ncomp(nstart:nend) = nfamily ! Create the new merged body allocate(plnew, mold=pl) @@ -422,10 +422,10 @@ module function symba_fragmentation_casemerge(system, param, family, x, v, mass, end if ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody + nstart = pl_adds%nbody + 1 + nend = pl_adds%nbody + plnew%nbody + call pl_adds%append(plnew) + pl_adds%ncomp(nstart:nend) = plnew%nbody call plnew%setup(0, param) deallocate(plnew) @@ -468,7 +468,7 @@ module function symba_fragmentation_casesupercatastrophic(system, param, family, select type(pl => system%pl) class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) + associate(pl_adds => system%pl_adds, pl_discards => system%pl_discards, cb => system%cb) ! Collisional fragments will be uniformly distributed around the pre-impact barycenter nfrag = NFRAG_SUPERCAT allocate(m_frag(nfrag)) @@ -521,11 +521,11 @@ module function symba_fragmentation_casesupercatastrophic(system, param, family, lmask(:) = .false. lmask(family(:)) = .true. pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) + nstart = pl_discards%nbody + 1 + nend = pl_discards%nbody + nfamily + call pl_discards%append(pl, lmask) ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily + pl_discards%ncomp(nstart:nend) = nfamily allocate(plnew, mold=pl) call plnew%setup(nfrag, param) @@ -563,10 +563,10 @@ module function symba_fragmentation_casesupercatastrophic(system, param, family, end if ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody + nstart = pl_adds%nbody + 1 + nend = pl_adds%nbody + plnew%nbody + call pl_adds%append(plnew) + pl_adds%ncomp(nstart:nend) = plnew%nbody call plnew%setup(0, param) deallocate(plnew) diff --git a/docs/src/symba_io.f90 b/docs/src/symba_io.f90 index 2e568dd7e..713429365 100644 --- a/docs/src/symba_io.f90 +++ b/docs/src/symba_io.f90 @@ -71,8 +71,8 @@ module subroutine symba_io_param_reader(self, unit, iotype, v_list, iostat, ioms case ("FRAGMENTATION") call io_toupper(param_value) if (param_value == "YES" .or. param_value == "T") self%lfragmentation = .true. - case ("MTINY") - read(param_value, *) param%mtiny + case ("GMTINY") + read(param_value, *) param%Gmtiny case("SEED") read(param_value, *) nseeds_from_file ! Because the number of seeds can vary between compilers/systems, we need to make sure we can handle cases in which the input file has a different @@ -111,12 +111,12 @@ module subroutine symba_io_param_reader(self, unit, iotype, v_list, iostat, ioms write(*,*) "SEED: N,VAL = ",size(param%seed), param%seed(:) end if - if (self%mtiny < 0.0_DP) then - write(iomsg,*) "MTINY invalid or not set: ", self%mtiny + if (self%Gmtiny < 0.0_DP) then + write(iomsg,*) "GMTINY invalid or not set: ", self%Gmtiny iostat = -1 return else - write(*,*) "MTINY = ", self%mtiny + write(*,*) "GMTINY = ", self%Gmtiny end if if (.not.self%lclose) then @@ -167,7 +167,7 @@ module subroutine symba_io_param_writer(self, unit, iotype, v_list, iostat, ioms ! Special handling is required for writing the random number seed array as its size is not known until runtime ! For the "SEED" parameter line, the first value will be the size of the seed array and the rest will be the seed array elements write(param_name, Afmt) "PARTICLE_FILE"; write(param_value, Afmt) trim(adjustl(param%particle_file)); write(unit, Afmt) adjustl(param_name), adjustl(param_value) - write(param_name, Afmt) "MTINY"; write(param_value, Rfmt) param%mtiny; write(unit, Afmt) adjustl(param_name), adjustl(param_value) + write(param_name, Afmt) "GMTINY"; write(param_value, Rfmt) param%Gmtiny; write(unit, Afmt) adjustl(param_name), adjustl(param_value) write(param_name, Afmt) "FRAGMENTATION"; write(param_value, Lfmt) param%lfragmentation; write(unit, Afmt) adjustl(param_name), adjustl(param_value) if (param%lfragmentation) then write(param_name, Afmt) "SEED" @@ -225,10 +225,10 @@ module subroutine symba_io_write_discard(self, param) character(*), parameter :: PLNAMEFMT = '(I8, 2(1X, E23.16))' class(swiftest_body), allocatable :: pltemp - associate(pl => self%pl, npl => self%pl%nbody, mergesub_list => self%mergesub_list, mergeadd_list => self%mergeadd_list) + associate(pl => self%pl, npl => self%pl%nbody, pl_discards => self%pl_discards, pl_adds => self%pl_adds) if (self%tp_discards%nbody > 0) call io_write_discard(self, param) - if (mergesub_list%nbody == 0) return + if (pl_discards%nbody == 0) return select case(param%out_stat) case('APPEND') open(unit = LUN, file = param%discard_out, status = 'OLD', position = 'APPEND', form = 'FORMATTED', iostat = ierr) @@ -240,31 +240,31 @@ module subroutine symba_io_write_discard(self, param) end select lfirst = .false. if (param%lgr) then - call mergesub_list%pv2v(param) - call mergeadd_list%pv2v(param) + call pl_discards%pv2v(param) + call pl_adds%pv2v(param) end if - write(LUN, HDRFMT) param%t, mergesub_list%nbody, param%lbig_discard + write(LUN, HDRFMT) param%t, pl_discards%nbody, param%lbig_discard iadd = 1 isub = 1 - do while (iadd <= mergeadd_list%nbody) - nadd = mergeadd_list%ncomp(iadd) - nsub = mergesub_list%ncomp(isub) + do while (iadd <= pl_adds%nbody) + nadd = pl_adds%ncomp(iadd) + nsub = pl_discards%ncomp(isub) do j = 1, nadd - if (iadd <= mergeadd_list%nbody) then - write(LUN, NAMEFMT) ADD, mergesub_list%id(iadd), mergesub_list%status(iadd) - write(LUN, VECFMT) mergeadd_list%xh(1, iadd), mergeadd_list%xh(2, iadd), mergeadd_list%xh(3, iadd) - write(LUN, VECFMT) mergeadd_list%vh(1, iadd), mergeadd_list%vh(2, iadd), mergeadd_list%vh(3, iadd) + if (iadd <= pl_adds%nbody) then + write(LUN, NAMEFMT) ADD, pl_discards%id(iadd), pl_discards%status(iadd) + write(LUN, VECFMT) pl_adds%xh(1, iadd), pl_adds%xh(2, iadd), pl_adds%xh(3, iadd) + write(LUN, VECFMT) pl_adds%vh(1, iadd), pl_adds%vh(2, iadd), pl_adds%vh(3, iadd) else exit end if iadd = iadd + 1 end do do j = 1, nsub - if (isub <= mergesub_list%nbody) then - write(LUN, NAMEFMT) SUB, mergesub_list%id(isub), mergesub_list%status(isub) - write(LUN, VECFMT) mergesub_list%xh(1, isub), mergesub_list%xh(2, isub), mergesub_list%xh(3, isub) - write(LUN, VECFMT) mergesub_list%vh(1, isub), mergesub_list%vh(2, isub), mergesub_list%vh(3, isub) + if (isub <= pl_discards%nbody) then + write(LUN, NAMEFMT) SUB, pl_discards%id(isub), pl_discards%status(isub) + write(LUN, VECFMT) pl_discards%xh(1, isub), pl_discards%xh(2, isub), pl_discards%xh(3, isub) + write(LUN, VECFMT) pl_discards%vh(1, isub), pl_discards%vh(2, isub), pl_discards%vh(3, isub) else exit end if diff --git a/docs/src/symba_setup.f90 b/docs/src/symba_setup.f90 index 021873a70..ab8b5543e 100644 --- a/docs/src/symba_setup.f90 +++ b/docs/src/symba_setup.f90 @@ -25,7 +25,7 @@ module subroutine symba_setup_initialize_system(self, param) call pl%sort("mass", ascending=.false.) select type(param) class is (symba_parameters) - pl%lmtiny(:) = pl%Gmass(:) > param%MTINY + pl%lmtiny(:) = pl%Gmass(:) > param%GMTINY pl%nplm = count(pl%lmtiny(:)) end select end select diff --git a/docs/src/symba_step.f90 b/docs/src/symba_step.f90 index 41e7a3a74..7065625b4 100644 --- a/docs/src/symba_step.f90 +++ b/docs/src/symba_step.f90 @@ -237,7 +237,7 @@ module subroutine symba_step_reset_system(self) ! Internals integer(I4B) :: i - associate(system => self, pltpenc_list => self%pltpenc_list, plplenc_list => self%plplenc_list, mergeadd_list => self%mergeadd_list, mergesub_list => self%mergesub_list) + associate(system => self, pltpenc_list => self%pltpenc_list, plplenc_list => self%plplenc_list, pl_adds => self%pl_adds, pl_discards => self%pl_discards) select type(pl => system%pl) class is (symba_pl) select type(tp => system%tp) @@ -265,8 +265,8 @@ module subroutine symba_step_reset_system(self) pltpenc_list%nenc = 0 end if - call mergeadd_list%resize(0) - call mergesub_list%resize(0) + call pl_adds%resize(0) + call pl_discards%resize(0) end select end select end associate diff --git a/docs/src/symba_util.f90 b/docs/src/symba_util.f90 index 98c8889d8..911f85304 100644 --- a/docs/src/symba_util.f90 +++ b/docs/src/symba_util.f90 @@ -381,23 +381,23 @@ module subroutine symba_util_rearray_pl(self, system, param) ! Internals class(symba_pl), allocatable :: pl_discards !! The discarded body list. - associate(pl => self, mergeadd_list => system%mergeadd_list) + associate(pl => self, pl_adds => system%pl_adds) allocate(pl_discards, mold=pl) ! Remove the discards call pl%spill(pl_discards, lspill_list=(pl%ldiscard(:) .or. pl%status(:) == INACTIVE), ldestructive=.true.) ! Add in any new bodies - call pl%append(mergeadd_list) + call pl%append(pl_adds) ! If there are still bodies in the system, sort by mass in descending order and re-index if (pl%nbody > 0) then call pl%sort("mass", ascending=.false.) - pl%lmtiny(:) = pl%Gmass(:) > param%MTINY + pl%lmtiny(:) = pl%Gmass(:) > param%GMTINY pl%nplm = count(pl%lmtiny(:)) call pl%eucl_index() end if - ! Destroy the discarded body list, since we already have what we need in the mergesub_list + ! Destroy the discarded body list, since we already have what we need in the pl_discards call pl_discards%setup(0,param) deallocate(pl_discards) end associate diff --git a/examples/helio_gr_test/init_cond.py b/examples/helio_gr_test/init_cond.py index 8d197c6f4..5b378da74 100755 --- a/examples/helio_gr_test/init_cond.py +++ b/examples/helio_gr_test/init_cond.py @@ -24,6 +24,7 @@ sim.param['CHK_EJECT'] = 1000.0 sim.param['OUT_FORM'] = "EL" sim.param['OUT_STAT'] = "UNKNOWN" +sim.param['RHILL_PRESENT'] = "NO" sim.param['GR'] = 'YES' bodyid = { diff --git a/examples/helio_gr_test/param.swifter.in b/examples/helio_gr_test/param.swifter.in index 789250f41..acca6f7aa 100644 --- a/examples/helio_gr_test/param.swifter.in +++ b/examples/helio_gr_test/param.swifter.in @@ -21,7 +21,7 @@ CHK_QMIN_RANGE 0.004650467260962157 1000.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES +RHILL_PRESENT NO C 63241.07708426628 J2 4.7535806948127355e-12 J4 -2.2473967953572827e-18 -RHILL_PRESENT YES diff --git a/examples/helio_gr_test/param.swiftest.in b/examples/helio_gr_test/param.swiftest.in index ace6f3cad..f5a748693 100644 --- a/examples/helio_gr_test/param.swiftest.in +++ b/examples/helio_gr_test/param.swiftest.in @@ -25,6 +25,7 @@ DU2M 149597870700.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES +RHILL_PRESENT NO FRAGMENTATION NO ROTATION NO TIDES NO diff --git a/examples/helio_gr_test/pl.swifter.in b/examples/helio_gr_test/pl.swifter.in index 782e57140..f39e7af56 100644 --- a/examples/helio_gr_test/pl.swifter.in +++ b/examples/helio_gr_test/pl.swifter.in @@ -2,35 +2,35 @@ 0 39.476926408897625196 0.0 0.0 0.0 0.0 0.0 0.0 -1 6.5537098095653139645e-06 0.0014751234419554511911 +1 6.5537098095653139645e-06 1.6306381826061645943e-05 -0.13267502226188271353 0.2786606257975073886 0.010601098875389479426 --11.331978934667442676 4.8184460126705647045 1.4332264599878684131 -2 9.663313399581537916e-05 0.00675908960945781479 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 +2 9.663313399581537916e-05 4.0453784346544178454e-05 --0.69398700025820403425 -0.19235393648106968723 0.03740673057980103272 -1.9245789988923785786 -7.1528261190002948057 -0.20922405362759749996 -3 0.000120026935827952453094 0.010044837538502923644 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 +3 0.000120026935827952453094 4.25875607065040958e-05 -0.49463573470256239073 -0.8874896493821613497 4.051630875713834232e-05 -5.386704768180099809 3.0357508899436080915 -0.00016218409216515533796 -4 1.2739802010675941456e-05 0.0072467236860282326973 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 +4 1.2739802010675941456e-05 2.265740805092889601e-05 --1.5655322071100350456 0.56626121192188216824 0.050269397991054412533 --1.5477080637857006753 -4.370087697214287981 -0.05361768768801557225 -5 0.037692251088985676735 0.35527094075555771578 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 +5 0.037692251088985676735 0.00046732617030490929307 -4.0891378954287338487 -2.9329188614380639066 -0.07930573161132697946 -1.575024788882753283 2.3719591091996699917 -0.045089307261129988257 -6 0.011285899820091272997 0.43765464106459166412 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 +6 0.011285899820091272997 0.00038925687730393611812 -6.3349788609660162564 -7.674600716671800882 -0.11868650931385750502 -1.4598618704191345578 1.2948691245181617393 -0.080593167691228835176 -7 0.0017236589478267730203 0.46956055286931676728 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 +7 0.0017236589478267730203 0.00016953449859497231466 -14.832516206189200858 13.032608531076540714 -0.14378102535616668622 --0.9573374666934839659 1.014553546383260322 0.016118112341773867214 -8 0.0020336100526728302319 0.7813163071687303693 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 +8 0.0020336100526728302319 0.000164587904124493665 -29.561664938083289655 -4.6012285192418387325 -0.586585578731106283 -0.17051705220469790965 1.1424784769020628332 -0.027423757798549895085 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/helio_gr_test/pl.swiftest.in b/examples/helio_gr_test/pl.swiftest.in index 10d425453..b624d25ba 100644 --- a/examples/helio_gr_test/pl.swiftest.in +++ b/examples/helio_gr_test/pl.swiftest.in @@ -1,33 +1,33 @@ 8 1 6.5537098095653139645e-06 1.6306381826061645943e-05 -0.13267502226188271353 0.2786606257975073886 0.010601098875389479426 --11.331978934667442676 4.8184460126705647045 1.4332264599878684131 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 2 9.663313399581537916e-05 4.0453784346544178454e-05 --0.69398700025820403425 -0.19235393648106968723 0.03740673057980103272 -1.9245789988923785786 -7.1528261190002948057 -0.20922405362759749996 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 3 0.000120026935827952453094 4.25875607065040958e-05 -0.49463573470256239073 -0.8874896493821613497 4.051630875713834232e-05 -5.386704768180099809 3.0357508899436080915 -0.00016218409216515533796 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 4 1.2739802010675941456e-05 2.265740805092889601e-05 --1.5655322071100350456 0.56626121192188216824 0.050269397991054412533 --1.5477080637857006753 -4.370087697214287981 -0.05361768768801557225 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 5 0.037692251088985676735 0.00046732617030490929307 -4.0891378954287338487 -2.9329188614380639066 -0.07930573161132697946 -1.575024788882753283 2.3719591091996699917 -0.045089307261129988257 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 6 0.011285899820091272997 0.00038925687730393611812 -6.3349788609660162564 -7.674600716671800882 -0.11868650931385750502 -1.4598618704191345578 1.2948691245181617393 -0.080593167691228835176 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 7 0.0017236589478267730203 0.00016953449859497231466 -14.832516206189200858 13.032608531076540714 -0.14378102535616668622 --0.9573374666934839659 1.014553546383260322 0.016118112341773867214 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 8 0.0020336100526728302319 0.000164587904124493665 -29.561664938083289655 -4.6012285192418387325 -0.586585578731106283 -0.17051705220469790965 1.1424784769020628332 -0.027423757798549895085 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/helio_gr_test/swiftest_relativity.ipynb b/examples/helio_gr_test/swiftest_relativity.ipynb index 03948cdf7..db7a4926e 100644 --- a/examples/helio_gr_test/swiftest_relativity.ipynb +++ b/examples/helio_gr_test/swiftest_relativity.ipynb @@ -116,15 +116,15 @@ "Mean precession rate for Mercury long. peri. (arcsec/100 y)\n", "JPL Horizons : 571.3210506300043\n", "Swifter GR : 571.6183105524942\n", - "Swiftest GR : 571.6157754511288\n", + "Swiftest GR : 571.5701928436062\n", "Obs - Swifter : -0.2972599224899675\n", - "Obs - Swiftest : -0.2947248211246545\n", - "Swiftest - Swifter: -0.0025351013653107657\n" + "Obs - Swiftest : -0.2491422136018948\n", + "Swiftest - Swifter: -0.04811770888807132\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/examples/helio_swifter_comparison/init_cond.py b/examples/helio_swifter_comparison/init_cond.py index 4680d9e0a..b8b9b4369 100755 --- a/examples/helio_swifter_comparison/init_cond.py +++ b/examples/helio_swifter_comparison/init_cond.py @@ -20,6 +20,7 @@ sim.param['OUT_FORM'] = "XV" sim.param['OUT_STAT'] = "UNKNOWN" sim.param['GR'] = 'NO' +sim.param['RHILL_PRESENT'] = 'YES' bodyid = { "Sun": 0, diff --git a/examples/helio_swifter_comparison/param.swifter.in b/examples/helio_swifter_comparison/param.swifter.in index 5cf0cb8b9..417c3ab04 100644 --- a/examples/helio_swifter_comparison/param.swifter.in +++ b/examples/helio_swifter_comparison/param.swifter.in @@ -21,6 +21,6 @@ CHK_QMIN_RANGE 0.004650467260962157 1000.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES +RHILL_PRESENT YES J2 4.7535806948127355e-12 J4 -2.2473967953572827e-18 -RHILL_PRESENT YES diff --git a/examples/helio_swifter_comparison/param.swiftest.in b/examples/helio_swifter_comparison/param.swiftest.in index 73818e198..df058ad4c 100644 --- a/examples/helio_swifter_comparison/param.swiftest.in +++ b/examples/helio_swifter_comparison/param.swiftest.in @@ -25,11 +25,9 @@ DU2M 149597870700.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES +RHILL_PRESENT YES FRAGMENTATION NO ROTATION NO TIDES NO ENERGY NO GR NO -YARKOVSKY NO -YORP NO -MTINY 0.0 diff --git a/examples/helio_swifter_comparison/pl.swifter.in b/examples/helio_swifter_comparison/pl.swifter.in index e0ef4e881..0b02f19c8 100644 --- a/examples/helio_swifter_comparison/pl.swifter.in +++ b/examples/helio_swifter_comparison/pl.swifter.in @@ -2,35 +2,35 @@ 0 39.476926408897625196 0.0 0.0 0.0 0.0 0.0 0.0 -1 6.5537098095653139645e-06 0.0014751243077781048702 +1 6.5537098095653139645e-06 0.001475124456355905224 1.6306381826061645943e-05 -0.33206272695596028566 0.07436707001147663254 -0.02438290851908785084 --4.2340114788918336805 10.486553514018327622 1.2453138107251555947 -2 9.663313399581537916e-05 0.006759104275397271956 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 +2 9.663313399581537916e-05 0.006759069616556246028 4.0453784346544178454e-05 --0.7188115337296047125 -0.0118554711069603201795 0.041316403191083782287 -0.07826338813583945357 -7.419533988988633545 -0.10634201014368884618 -3 0.000120026935827952453094 0.010044787321379672528 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 +3 0.000120026935827952453094 0.010044908171483009529 4.25875607065040958e-05 -0.35677088372527121507 -0.95189300879814897627 4.4027442504036787155e-05 -5.7819217550992820422 2.18192814489641851 -0.00012230072278352209966 -4 1.2739802010675941456e-05 0.007246743835971885302 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 +4 1.2739802010675941456e-05 0.0072466797341124641736 2.265740805092889601e-05 --1.5233712071242269115 0.6723825347339112968 0.051459143378398922164 --1.8728417739956807141 -4.239719661832373223 -0.042909557750301418264 -5 0.037692251088985676735 0.35527126534549128905 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 +5 0.037692251088985676735 0.35527079166215922855 0.00046732617030490929307 -4.049944927347420176 -2.9910878677758190314 -0.078187280837353656526 -1.6060801375519682711 2.349356876761497338 -0.045690062807172619064 -6 0.011285899820091272997 0.4376527512949726007 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 +6 0.011285899820091272997 0.43765832419088212185 0.00038925687730393611812 -6.298929503477405767 -7.706413024510769816 -0.11669919842191249504 -1.4661378456572359413 1.2872251175075805794 -0.08070991686100478242 -7 0.0017236589478267730203 0.4695362423191493196 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 +7 0.0017236589478267730203 0.46960112247450473807 0.00016953449859497231466 -14.856082147529010129 13.007589275314199284 -0.14417795763685259391 --0.9554310497290159123 1.0161753499437922057 0.016099529164307530124 -8 0.0020336100526728302319 0.7812870996943599397 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 +8 0.0020336100526728302319 0.78136567314580814177 0.000164587904124493665 -29.55744967800954015 -4.629377558152945049 -0.58590957207831262377 -0.17162147939801157335 1.1422848961108499101 -0.027445465472921385952 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/helio_swifter_comparison/pl.swiftest.in b/examples/helio_swifter_comparison/pl.swiftest.in index 9d49cc3da..84cae57a2 100644 --- a/examples/helio_swifter_comparison/pl.swiftest.in +++ b/examples/helio_swifter_comparison/pl.swiftest.in @@ -1,33 +1,33 @@ 8 -1 6.5537098095653139645e-06 +1 6.5537098095653139645e-06 0.001475124456355905224 1.6306381826061645943e-05 -0.33206272695596028566 0.07436707001147663254 -0.02438290851908785084 --4.2340114788918336805 10.486553514018327622 1.2453138107251555947 -2 9.663313399581537916e-05 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 +2 9.663313399581537916e-05 0.006759069616556246028 4.0453784346544178454e-05 --0.7188115337296047125 -0.0118554711069603201795 0.041316403191083782287 -0.07826338813583945357 -7.419533988988633545 -0.10634201014368884618 -3 0.000120026935827952453094 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 +3 0.000120026935827952453094 0.010044908171483009529 4.25875607065040958e-05 -0.35677088372527121507 -0.95189300879814897627 4.4027442504036787155e-05 -5.7819217550992820422 2.18192814489641851 -0.00012230072278352209966 -4 1.2739802010675941456e-05 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 +4 1.2739802010675941456e-05 0.0072466797341124641736 2.265740805092889601e-05 --1.5233712071242269115 0.6723825347339112968 0.051459143378398922164 --1.8728417739956807141 -4.239719661832373223 -0.042909557750301418264 -5 0.037692251088985676735 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 +5 0.037692251088985676735 0.35527079166215922855 0.00046732617030490929307 -4.049944927347420176 -2.9910878677758190314 -0.078187280837353656526 -1.6060801375519682711 2.349356876761497338 -0.045690062807172619064 -6 0.011285899820091272997 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 +6 0.011285899820091272997 0.43765832419088212185 0.00038925687730393611812 -6.298929503477405767 -7.706413024510769816 -0.11669919842191249504 -1.4661378456572359413 1.2872251175075805794 -0.08070991686100478242 -7 0.0017236589478267730203 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 +7 0.0017236589478267730203 0.46960112247450473807 0.00016953449859497231466 -14.856082147529010129 13.007589275314199284 -0.14417795763685259391 --0.9554310497290159123 1.0161753499437922057 0.016099529164307530124 -8 0.0020336100526728302319 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 +8 0.0020336100526728302319 0.78136567314580814177 0.000164587904124493665 -29.55744967800954015 -4.629377558152945049 -0.58590957207831262377 -0.17162147939801157335 1.1422848961108499101 -0.027445465472921385952 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/helio_swifter_comparison/swiftest_vs_swifter.ipynb b/examples/helio_swifter_comparison/swiftest_vs_swifter.ipynb index 9a4c22cb1..709b6cd44 100644 --- a/examples/helio_swifter_comparison/swiftest_vs_swifter.ipynb +++ b/examples/helio_swifter_comparison/swiftest_vs_swifter.ipynb @@ -153,7 +153,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/examples/helio_swifter_comparison/tp.swifter.in b/examples/helio_swifter_comparison/tp.swifter.in index b37f04011..8a66912f4 100644 --- a/examples/helio_swifter_comparison/tp.swifter.in +++ b/examples/helio_swifter_comparison/tp.swifter.in @@ -1,13 +1,13 @@ 4 101 -2.2759060918449769417 1.6823262546111898974 -0.3661544509052930274 --2.3097811686367798667 2.7916683305060454227 0.51377483806222698173 +2.1159283340247889704 1.8593322968487970837 -0.33108647801775120678 +-2.557303042640355446 2.5920133227445458545 0.5530693963730075664 102 -3.0206599411327550442 -1.0715345879373190385 0.4820489106686373093 -0.64736314289225124926 2.5354787229381968757 -1.8109825958052419904 +3.055528708824450046 -0.9023759798915096386 0.36193041623852567623 +0.4122422441588732561 2.6115158464246720372 -1.8437451126910543971 103 --0.47156753362343428737 -3.1411451968218520037 0.73253063903937232215 -3.067486522793096946 -0.061867034122113133084 -0.11064022385054755856 +-0.26900389298636068203 -3.1374127668516589296 0.7234488489303841918 +3.0956076496295565968 0.17648254651685860603 -0.16591700615421532186 104 --2.0454358521790818592 -0.83017357434175576003 0.27369621627497042748 -1.8825682786003801814 -3.9015333153827542793 -0.112405737336568095776 +-1.9061083760262669262 -1.0793924233562111059 0.26419511130887440853 +2.3545884478521155142 -3.673223720899393644 -0.17666743480430943436 diff --git a/examples/helio_swifter_comparison/tp.swiftest.in b/examples/helio_swifter_comparison/tp.swiftest.in index b37f04011..8a66912f4 100644 --- a/examples/helio_swifter_comparison/tp.swiftest.in +++ b/examples/helio_swifter_comparison/tp.swiftest.in @@ -1,13 +1,13 @@ 4 101 -2.2759060918449769417 1.6823262546111898974 -0.3661544509052930274 --2.3097811686367798667 2.7916683305060454227 0.51377483806222698173 +2.1159283340247889704 1.8593322968487970837 -0.33108647801775120678 +-2.557303042640355446 2.5920133227445458545 0.5530693963730075664 102 -3.0206599411327550442 -1.0715345879373190385 0.4820489106686373093 -0.64736314289225124926 2.5354787229381968757 -1.8109825958052419904 +3.055528708824450046 -0.9023759798915096386 0.36193041623852567623 +0.4122422441588732561 2.6115158464246720372 -1.8437451126910543971 103 --0.47156753362343428737 -3.1411451968218520037 0.73253063903937232215 -3.067486522793096946 -0.061867034122113133084 -0.11064022385054755856 +-0.26900389298636068203 -3.1374127668516589296 0.7234488489303841918 +3.0956076496295565968 0.17648254651685860603 -0.16591700615421532186 104 --2.0454358521790818592 -0.83017357434175576003 0.27369621627497042748 -1.8825682786003801814 -3.9015333153827542793 -0.112405737336568095776 +-1.9061083760262669262 -1.0793924233562111059 0.26419511130887440853 +2.3545884478521155142 -3.673223720899393644 -0.17666743480430943436 diff --git a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/init_cond.py b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/init_cond.py index b292ed42f..a700466b1 100755 --- a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/init_cond.py +++ b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/init_cond.py @@ -43,7 +43,7 @@ tpid = 100 radius = np.double(4.25875607065041e-05) -mass = np.double(0.00012002693582795244940133) +Gmass = np.double(0.00012002693582795244940133) apl = np.longdouble(1.0) atp = np.longdouble(1.01) vpl = np.longdouble(2 * np.pi) @@ -55,7 +55,7 @@ p_tp = np.array([atp, 0.0, 0.0], dtype=np.double) v_tp = np.array([0.0, vtp, 0.0], dtype=np.double) -Rhill = apl * 0.0100447248332378922085 +Rhill = np.double(apl * 0.0100447248332378922085) #Make Swifter files plfile = open(swifter_pl, 'w') @@ -63,7 +63,7 @@ print(1,GMSun,file=plfile) print('0.0 0.0 0.0',file=plfile) print('0.0 0.0 0.0',file=plfile) -print(plid,"{:.23g}".format(mass),Rhill, file=plfile) +print(plid,"{:.23g}".format(Gmass),Rhill, file=plfile) print(radius, file=plfile) print(*p_pl, file=plfile) print(*v_pl, file=plfile) @@ -125,7 +125,8 @@ plfile.write_record(v_pl[0]) plfile.write_record(v_pl[1]) plfile.write_record(v_pl[2]) -plfile.write_record(mass) +plfile.write_record(Gmass) +plfile.write_record(Rhill) plfile.write_record(radius) plfile.close() tpfile = FortranFile(swiftest_tp, 'w') @@ -156,6 +157,7 @@ print(f'OUT_TYPE REAL8') print(f'OUT_FORM XV') print(f'OUT_STAT REPLACE') +print(f'RHILL_PRESENT yes') print(f'CHK_CLOSE yes') print(f'CHK_RMIN {rmin}') print(f'CHK_RMAX {rmax}') diff --git a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/param.swiftest.in b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/param.swiftest.in index 36937896f..d9c20a3be 100644 --- a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/param.swiftest.in +++ b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/param.swiftest.in @@ -12,6 +12,7 @@ BIN_OUT bin.swiftest.dat OUT_TYPE REAL8 OUT_FORM XV OUT_STAT REPLACE +RHILL_PRESENT yes CHK_CLOSE yes CHK_RMIN 0.004650467260962157 CHK_RMAX 1000.0 diff --git a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swifter.in b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swifter.in index 95513c9fd..17d461561 100644 --- a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swifter.in +++ b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swifter.in @@ -2,7 +2,7 @@ 1 39.476926408897625196 0.0 0.0 0.0 0.0 0.0 0.0 -2 0.00012002693582795244940133 0.010044724833237891545 +2 0.00012002693582795244940133 0.010044724833237892 4.25875607065041e-05 1.0 0.0 0.0 0.0 6.283185307179586 0.0 diff --git a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swiftest.in b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swiftest.in index 6f4bc1337..c94c6ae61 100644 Binary files a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swiftest.in and b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/pl.swiftest.in differ diff --git a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb index 29dcf43aa..20122244c 100644 --- a/examples/rmvs_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb +++ b/examples/rmvs_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb @@ -81,8 +81,8 @@ { "data": { "text/plain": [ - "[,\n", - " ]" + "[,\n", + " ]" ] }, "execution_count": 6, @@ -91,7 +91,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -103,7 +103,7 @@ } ], "source": [ - "swiftdiff['px'].plot.line(x=\"time (y)\")" + "swiftdiff['vx'].plot.line(x=\"time (y)\")" ] }, { diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in index 2e8d49f62..81c636655 100644 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in @@ -1,5 +1,5 @@ 0 0.00029591220819207774 0.004650467260962157 -0.0 -0.0 +4.7535806948127355e-12 +-2.2473967953572827e-18 diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/init_cond.py b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/init_cond.py index 094b261f0..49d017b86 100755 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/init_cond.py +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/init_cond.py @@ -37,6 +37,7 @@ sim.param['OUT_STAT'] = "UNKNOWN" sim.param['GR'] = 'NO' sim.param['CHK_CLOSE'] = 'YES' +sim.param['RHILL_PRESENT'] = 'YES' sim.param['MU2KG'] = swiftest.MSun sim.param['TU2S'] = swiftest.JD2S diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/param.swifter.in b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/param.swifter.in index 6a283276e..36dd2060f 100644 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/param.swifter.in +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/param.swifter.in @@ -22,5 +22,5 @@ EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES RHILL_PRESENT YES -J2 0.0 -J4 0.0 +J2 4.7535806948127355e-12 +J4 -2.2473967953572827e-18 diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.in b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.in index 86a616119..207dd84f6 100644 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.in +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.in @@ -1,33 +1,33 @@ 8 -1 4.9125474498983623693e-11 0.0014751239400086721089 +1 4.9125474498983623693e-11 0.001475124456355905224 1.6306381826061645943e-05 --0.09861361766419070307 0.29750596935836171042 0.03335708456145129036 --0.032353632540864457612 -0.0078122718370876240157 0.0023293874953380202045 -2 7.243452483873646905e-10 0.0067590794275223005208 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-0.018820805516945871005 -0.023743802865467341506 -0.00021385162925667799668 +2 7.243452483873646905e-10 0.006759069616556246028 4.0453784346544178454e-05 --0.6439817957564198947 -0.3248550380869373866 0.032702713983447248558 -0.008969709495375973937 -0.018153139924556138673 -0.0007667345025597138231 -3 8.9970113821660187435e-10 0.010044873080337524463 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +0.012753121506668980284 -0.015678149412530151263 -0.0009510907726656827677 +3 8.9970113821660187435e-10 0.010044908171483009529 4.25875607065040958e-05 -0.59421674333603324847 -0.82331253628773626296 3.7129329104855261984e-05 -0.013670550280388280365 0.010004295439859960809 -5.226292361234363611e-07 -4 9.549535102761465607e-11 0.0072467054748629370034 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +0.012205130808798069983 0.0117727888369263504476 -6.0385404652521189453e-07 +4 9.549535102761465607e-11 0.0072466797341124641736 2.265740805092889601e-05 --1.592721551706784977 0.48166390206865000723 0.049163460846716633412 --0.0035287723306552309585 -0.01219974682608557931 -0.00016910795626524249315 -5 2.825345908631354893e-07 0.35527074967975702942 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.0027036789764029569086 -0.012421968497550240837 -0.00019400613558421780209 +5 2.825345908631354893e-07 0.35527079166215922855 0.00046732617030490929307 -4.119089774477131094 -2.8872942462256898644 -0.080165336328135106125 -0.004245402942744468111 0.0065414198811065849687 -0.00012215100047356211078 -6 8.459715183006415395e-08 0.4376562090257202473 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +0.0041683967523185880624 0.0065946899141205552256 -0.00012065009272080269359 +6 8.459715183006415395e-08 0.43765832419088212185 0.00038925687730393611812 -6.3629100567525149756 -7.649727796147929304 -0.12023019299387090186 -0.0039834472120812329868 0.0035613826786502411278 -0.00022039988214595340028 -7 1.2920249163736673626e-08 0.4695793205674148502 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +0.0039680130835247464163 0.0035798698934692090544 -0.00022010758050265331019 +7 1.2920249163736673626e-08 0.46960112247450473807 0.00016953449859497231466 -14.814154683311180349 13.052040295401360126 -0.14347198499748289868 --0.002625101393275708784 0.0027742356008832688187 4.416821810149910185e-05 -8 1.5243589003230834323e-08 0.7813388398513013378 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.0026297294662822792016 0.0027702756265410048361 4.4212949669357180555e-05 +8 1.5243589003230834323e-08 0.78136567314580814177 0.000164587904124493665 -29.564924658285640646 -4.579331535234244299 -0.5871109926822926095 -0.00046449847307956888343 0.003128345390031967918 -7.5036135696161668576e-05 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.00046181040300440859715 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swifter.in b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swifter.in index 595cdc169..3179473c0 100644 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swifter.in +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swifter.in @@ -2,35 +2,35 @@ 0 0.00029591220819207775568 0.0 0.0 0.0 0.0 0.0 0.0 -1 4.9125474498983623693e-11 0.0014751239400086721089 +1 4.9125474498983623693e-11 0.001475124456355905224 1.6306381826061645943e-05 --0.09861361766419070307 0.29750596935836171042 0.03335708456145129036 --0.032353632540864457612 -0.0078122718370876240157 0.0023293874953380202045 -2 7.243452483873646905e-10 0.0067590794275223005208 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-0.018820805516945871005 -0.023743802865467341506 -0.00021385162925667799668 +2 7.243452483873646905e-10 0.006759069616556246028 4.0453784346544178454e-05 --0.6439817957564198947 -0.3248550380869373866 0.032702713983447248558 -0.008969709495375973937 -0.018153139924556138673 -0.0007667345025597138231 -3 8.9970113821660187435e-10 0.010044873080337524463 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +0.012753121506668980284 -0.015678149412530151263 -0.0009510907726656827677 +3 8.9970113821660187435e-10 0.010044908171483009529 4.25875607065040958e-05 -0.59421674333603324847 -0.82331253628773626296 3.7129329104855261984e-05 -0.013670550280388280365 0.010004295439859960809 -5.226292361234363611e-07 -4 9.549535102761465607e-11 0.0072467054748629370034 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +0.012205130808798069983 0.0117727888369263504476 -6.0385404652521189453e-07 +4 9.549535102761465607e-11 0.0072466797341124641736 2.265740805092889601e-05 --1.592721551706784977 0.48166390206865000723 0.049163460846716633412 --0.0035287723306552309585 -0.01219974682608557931 -0.00016910795626524249315 -5 2.825345908631354893e-07 0.35527074967975702942 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.0027036789764029569086 -0.012421968497550240837 -0.00019400613558421780209 +5 2.825345908631354893e-07 0.35527079166215922855 0.00046732617030490929307 -4.119089774477131094 -2.8872942462256898644 -0.080165336328135106125 -0.004245402942744468111 0.0065414198811065849687 -0.00012215100047356211078 -6 8.459715183006415395e-08 0.4376562090257202473 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +0.0041683967523185880624 0.0065946899141205552256 -0.00012065009272080269359 +6 8.459715183006415395e-08 0.43765832419088212185 0.00038925687730393611812 -6.3629100567525149756 -7.649727796147929304 -0.12023019299387090186 -0.0039834472120812329868 0.0035613826786502411278 -0.00022039988214595340028 -7 1.2920249163736673626e-08 0.4695793205674148502 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +0.0039680130835247464163 0.0035798698934692090544 -0.00022010758050265331019 +7 1.2920249163736673626e-08 0.46960112247450473807 0.00016953449859497231466 -14.814154683311180349 13.052040295401360126 -0.14347198499748289868 --0.002625101393275708784 0.0027742356008832688187 4.416821810149910185e-05 -8 1.5243589003230834323e-08 0.7813388398513013378 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.0026297294662822792016 0.0027702756265410048361 4.4212949669357180555e-05 +8 1.5243589003230834323e-08 0.78136567314580814177 0.000164587904124493665 -29.564924658285640646 -4.579331535234244299 -0.5871109926822926095 -0.00046449847307956888343 0.003128345390031967918 -7.5036135696161668576e-05 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.00046181040300440859715 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in index 86a616119..207dd84f6 100644 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in @@ -1,33 +1,33 @@ 8 -1 4.9125474498983623693e-11 0.0014751239400086721089 +1 4.9125474498983623693e-11 0.001475124456355905224 1.6306381826061645943e-05 --0.09861361766419070307 0.29750596935836171042 0.03335708456145129036 --0.032353632540864457612 -0.0078122718370876240157 0.0023293874953380202045 -2 7.243452483873646905e-10 0.0067590794275223005208 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-0.018820805516945871005 -0.023743802865467341506 -0.00021385162925667799668 +2 7.243452483873646905e-10 0.006759069616556246028 4.0453784346544178454e-05 --0.6439817957564198947 -0.3248550380869373866 0.032702713983447248558 -0.008969709495375973937 -0.018153139924556138673 -0.0007667345025597138231 -3 8.9970113821660187435e-10 0.010044873080337524463 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +0.012753121506668980284 -0.015678149412530151263 -0.0009510907726656827677 +3 8.9970113821660187435e-10 0.010044908171483009529 4.25875607065040958e-05 -0.59421674333603324847 -0.82331253628773626296 3.7129329104855261984e-05 -0.013670550280388280365 0.010004295439859960809 -5.226292361234363611e-07 -4 9.549535102761465607e-11 0.0072467054748629370034 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +0.012205130808798069983 0.0117727888369263504476 -6.0385404652521189453e-07 +4 9.549535102761465607e-11 0.0072466797341124641736 2.265740805092889601e-05 --1.592721551706784977 0.48166390206865000723 0.049163460846716633412 --0.0035287723306552309585 -0.01219974682608557931 -0.00016910795626524249315 -5 2.825345908631354893e-07 0.35527074967975702942 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.0027036789764029569086 -0.012421968497550240837 -0.00019400613558421780209 +5 2.825345908631354893e-07 0.35527079166215922855 0.00046732617030490929307 -4.119089774477131094 -2.8872942462256898644 -0.080165336328135106125 -0.004245402942744468111 0.0065414198811065849687 -0.00012215100047356211078 -6 8.459715183006415395e-08 0.4376562090257202473 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +0.0041683967523185880624 0.0065946899141205552256 -0.00012065009272080269359 +6 8.459715183006415395e-08 0.43765832419088212185 0.00038925687730393611812 -6.3629100567525149756 -7.649727796147929304 -0.12023019299387090186 -0.0039834472120812329868 0.0035613826786502411278 -0.00022039988214595340028 -7 1.2920249163736673626e-08 0.4695793205674148502 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +0.0039680130835247464163 0.0035798698934692090544 -0.00022010758050265331019 +7 1.2920249163736673626e-08 0.46960112247450473807 0.00016953449859497231466 -14.814154683311180349 13.052040295401360126 -0.14347198499748289868 --0.002625101393275708784 0.0027742356008832688187 4.416821810149910185e-05 -8 1.5243589003230834323e-08 0.7813388398513013378 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.0026297294662822792016 0.0027702756265410048361 4.4212949669357180555e-05 +8 1.5243589003230834323e-08 0.78136567314580814177 0.000164587904124493665 -29.564924658285640646 -4.579331535234244299 -0.5871109926822926095 -0.00046449847307956888343 0.003128345390031967918 -7.5036135696161668576e-05 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.00046181040300440859715 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_rmvs_vs_swifter_rmvs.ipynb b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_rmvs_vs_swifter_rmvs.ipynb index 124ae2910..86a6d8098 100644 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_rmvs_vs_swifter_rmvs.ipynb +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/swiftest_rmvs_vs_swifter_rmvs.ipynb @@ -104,7 +104,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -130,7 +130,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,7 +163,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -198,7 +198,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -230,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -588,26 +588,26 @@ " fill: currentColor;\n", "}\n", "
<xarray.DataArray 'px' ()>\n",
-       "array(0.)\n",
+       "array(-9.71445147e-15)\n",
        "Coordinates:\n",
-       "    id       int64 105\n",
-       "    time     float64 1.09e+03
" + " id int64 101\n", + " time float64 1.14e+03" ], "text/plain": [ "\n", - "array(0.)\n", + "array(-9.71445147e-15)\n", "Coordinates:\n", - " id int64 105\n", - " time float64 1.09e+03" + " id int64 101\n", + " time float64 1.14e+03" ] }, - "execution_count": 13, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "swiftdiff['px'].sel(id=105).isel(time=109)" + "swiftdiff['px'].sel(id=101).isel(time=114)" ] }, { diff --git a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/tp.in b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/tp.in index c8cc418b0..c1e239467 100644 --- a/examples/rmvs_swifter_comparison/8pl_16tp_encounters/tp.in +++ b/examples/rmvs_swifter_comparison/8pl_16tp_encounters/tp.in @@ -1,49 +1,49 @@ 16 -105 -0.59427697124197276235 -0.8232523083817967491 3.7129329104855261984e-05 -0.020564990514662154913 0.010004295439859960809 -5.226292361234363611e-07 -109 -4.119750673485228276 -2.8866333472175926822 -0.080165336328135106125 -0.041127620144391897894 0.0065414198811065849687 -0.00012215100047356211078 101 --0.09859055695785905182 0.2975290300646933339 0.03335708456145129036 --0.029750083068855306956 -0.0078122718370876240157 0.0023293874953380202045 +-0.30947664140174180325 0.16192347328838543885 0.041620272188990829754 +-0.01621725604493672035 -0.023743802865467341506 -0.00021385162925667799668 102 --0.09863667837052235432 0.29748290865203008693 0.03335708456145129036 --0.034957182012873608268 -0.0078122718370876240157 0.0023293874953380202045 +-0.30952276281440505024 0.16187735187572213635 0.041620272188990829754 +-0.021424354988955021661 -0.023743802865467341506 -0.00021385162925667799668 103 --0.6439245854659476631 -0.32479782779646521051 0.032702713983447248558 -0.0153169432007213678765 -0.018153139924556138673 -0.0007667345025597138231 +-0.55665652353468386693 -0.46068452244605162527 0.02580196630219121906 +0.019100355212014374223 -0.015678149412530151263 -0.0009510907726656827677 104 --0.6440390060468921263 -0.32491224837740956266 0.032702713983447248558 -0.002622475790030579998 -0.018153139924556138673 -0.0007667345025597138231 +-0.5567709441156283301 -0.4607989430269959774 0.02580196630219121906 +0.0064058878013235863447 -0.015678149412530151263 -0.0009510907726656827677 +105 +0.6979392465946233637 -0.7360158052852626698 3.261671020506711323e-05 +0.019099571043071944532 0.0117727888369263504476 -6.0385404652521189453e-07 106 -0.5941565154300937346 -0.82337276419367577684 3.7129329104855261984e-05 -0.0067761100461144049487 0.010004295439859960809 -5.226292361234363611e-07 +0.6978187907827443359 -0.73613626109714169754 3.261671020506711323e-05 +0.005310690574524194567 0.0117727888369263504476 -6.0385404652521189453e-07 107 --1.5926895092930311026 0.48169594448240382611 0.049163460846716633412 --0.00044929323243133797994 -0.01219974682608557931 -0.00016910795626524249315 +-1.6176294307533440886 0.38317575049123231423 0.04771055403546069218 +0.00037580012182093606998 -0.012421968497550240837 -0.00019400613558421780209 108 --1.5927535941205388514 0.48163185965489618834 0.049163460846716633412 --0.006608251428879123937 -0.01219974682608557931 -0.00016910795626524249315 +-1.6176935155808518374 0.38311166566372467646 0.04771055403546069218 +-0.005783158074626849887 -0.012421968497550240837 -0.00019400613558421780209 +109 +4.1534063578978459574 -2.834088304936593694 -0.081136554176388195336 +0.041050613953966016978 0.0065946899141205552256 -0.00012065009272080269359 110 -4.118428875469033912 -2.8879551452337870465 -0.080165336328135106125 --0.032636814258902961672 0.0065414198811065849687 -0.00012215100047356211078 +4.152084559881651593 -2.8354101029527880584 -0.081136554176388195336 +-0.032713820449328842588 0.0065946899141205552256 -0.00012065009272080269359 111 -6.3634605491076454697 -7.64917730379279881 -0.12023019299387090186 -0.026096616095614821179 0.0035613826786502411278 -0.00022039988214595340028 +6.395266446455758924 -7.620612254932671803 -0.121992225877669294154 +0.026081181967058334609 0.0035798698934692090544 -0.00022010758050265331019 112 -6.3623595643973844815 -7.650278288503059798 -0.12023019299387090186 --0.01812972167145235694 0.0035613826786502411278 -0.00022039988214595340028 +6.394165461745497936 -7.621713239642932791 -0.121992225877669294154 +-0.01814515580000884351 0.0035798698934692090544 -0.00022010758050265331019 113 -14.814394441298382787 13.052280053388562564 -0.14347198499748289868 -0.010469662145386185101 0.0027742356008832688187 4.416821810149910185e-05 +14.793375114914683266 13.074458101351583039 -0.14311846037737518955 +0.0104650340723796142495 0.0027702756265410048361 4.4212949669357180555e-05 114 -14.813914925323977911 13.051800537414157688 -0.14347198499748289868 --0.015719864931937603536 0.0027742356008832688187 4.416821810149910185e-05 +14.79289559894027839 13.073978585377178163 -0.14311846037737518955 +-0.015724493004944172653 0.0027702756265410048361 4.4212949669357180555e-05 115 -29.565157420731857485 -4.579098772788029237 -0.5871109926822926095 -0.014900134286357700347 0.003128345390031967918 -7.5036135696161668576e-05 +29.568862657342247502 -4.5540701367497931074 -0.58771107137394917874 +0.0148974462162825404404 0.0031288137434451902125 -7.498349850432879627e-05 116 -29.564691895839423808 -4.5795642976804593616 -0.5871109926822926095 --0.0139711373401985618214 0.003128345390031967918 -7.5036135696161668576e-05 +29.568397132449813824 -4.554535661642223232 -0.58771107137394917874 +-0.013973825410273721728 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/rmvs_swifter_comparison/mars_ejecta/param.swifter.in b/examples/rmvs_swifter_comparison/mars_ejecta/param.swifter.in index f4035c4c0..3ffb6a2ee 100644 --- a/examples/rmvs_swifter_comparison/mars_ejecta/param.swifter.in +++ b/examples/rmvs_swifter_comparison/mars_ejecta/param.swifter.in @@ -14,7 +14,7 @@ IN_TYPE ASCII BIN_OUT bin.swifter.dat OUT_TYPE REAL8 ! double precision real output OUT_FORM XV ! osculating element output -OUT_STAT NEW +OUT_STAT UNKNOWN J2 0.0 ! no J2 term J4 0.0 ! no J4 term CHK_CLOSE yes ! check for planetary close encounters diff --git a/examples/rmvs_swifter_comparison/mars_ejecta/param.swiftest.in b/examples/rmvs_swifter_comparison/mars_ejecta/param.swiftest.in index 7df10c4d0..943e45ca3 100644 --- a/examples/rmvs_swifter_comparison/mars_ejecta/param.swiftest.in +++ b/examples/rmvs_swifter_comparison/mars_ejecta/param.swiftest.in @@ -24,3 +24,6 @@ GR no MU2KG 1.988409870698051e+30 DU2M 149597870700.0 TU2S 86400.0000 +RHILL_PRESENT no +DISCARD_OUT discard.swiftest.out +BIG_DISCARD yes ! output all planets if anything discarded diff --git a/examples/rmvs_swifter_comparison/mars_ejecta/swiftest_rmvs_vs_swifter_rmvs.ipynb b/examples/rmvs_swifter_comparison/mars_ejecta/swiftest_rmvs_vs_swifter_rmvs.ipynb index c0ae7eec3..5a26d4104 100644 --- a/examples/rmvs_swifter_comparison/mars_ejecta/swiftest_rmvs_vs_swifter_rmvs.ipynb +++ b/examples/rmvs_swifter_comparison/mars_ejecta/swiftest_rmvs_vs_swifter_rmvs.ipynb @@ -45,9 +45,9 @@ "output_type": "stream", "text": [ "Reading Swiftest file param.swiftest.in\n", - "Reading in time 6.001e+03\n", + "Reading in time 6.000e+03\n", "Creating Dataset\n", - "Successfully converted 6002 output frames.\n", + "Successfully converted 6001 output frames.\n", "Swiftest simulation data stored as xarray DataSet .ds\n" ] } @@ -104,7 +104,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -130,7 +130,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAElCAYAAADDUxRwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAmwklEQVR4nO3de7xVVb338c83LmKA4QWVq6Ci3FIEEktTtDAwO+Y1UUsNo4t17FHz2quyHpXqScWjZerx7pE6nUwyvIIezUuKAokhiYqyBQRREkHi4u/5Yw5ysVz7ttbcl8X+vl+v9dpzzTnmmL+x9uW3x5hzjqmIwMzMrFIfaekAzMxsy+CEYmZmuXBCMTOzXDihmJlZLpxQzMwsF04oZmaWCycUy52kH0m6LS33lfSupHYtHVddJH1a0vxmPmZI2r3COp6XNDqfiD5Ud63fR0k7SXpE0ipJv1DmRklvS3qqKeKx1s8JxT5E0kJJny1ad4qkPze2roh4LSK6RMTG/CJsnIb84Y6IRyNiz+aKKS8RMSQiHobNE0ATHKf4+zgReBPYJiLOAg4AxgC9I2LfpojBWj8nFGvzJLVv6Riq0C7A3+KDO6N3ARZGxOrGVuTPf8vhhGJlkdRT0v9IWi7pFUn/Xku5fqmH0L5gv6mS3pK0QNLXCsq2k3SBpJfSUMozkvqkbQMlPZD2my/puIL9bpJ0taQ/pf3+Imm3tO2RVGxOGrL5kqTRkmoknStpKXDjpnUFdfaR9PvUvhWSrqrlM3hP0nYF6/aR9KakDun9VyXNS0NB90napZbP6WOSbknHe1XS9yV9pGD711I9qyT9TdLwtH6hpM9KGgtcAHwptXOOpGMlPVN0nLMk/aGWGPpL+t90jAeAHUp9HyXdBJwMnJOO9XXgeuCT6f1FaZ/DJc2WtFLS45L2KqhvYfr8/wqsTvXul8qtTPGPLij/sKSfSHosxXe/pML4DijYd5GkU9L6rST9P0mvSXpD0jWStk7bdpB0d9rnLUmPFn7mVoaI8MuvzV7AQuCzRetOAf6clj8CPAP8AOgI7Aq8DHwubf8RcFta7gcE0D69/1/gl0AnYBiwHPhM2vY94DlgT0DA3sD2QGdgEXAq0B4YTjbcMiTtdxPwFrBv2n47MKUg9gB2L3g/GtgA/BTYCtg6ratJ29sBc4DL07E7AQfU8lnNAL5W8P7nwDVp+YvAAmBQiuv7wOOl4gJuAe4CuqbP7O/AhLTtWOB14BPpc9kd2KX4e1X4uaf3W6XPZVDBulnA0bW05QngsrTfgcCqOr6PNwH/t9TPR3o/HFgGjEqf58kp1q0K4p4N9Emffy9gBXAY2c/XmPS+eyr/MPASsEcq/zAwKW3rm2IdD3Qg+5kZlrZdAUwFtkuf7R+BS9O2S4Fr0j4dgE8Daunfv2p+tXgAfrW+V/plfxdYWfBawwcJZRTwWtE+5wM3puV//WEr/EOU/nhsBLoW7HcpcFNang8cUSKeLwGPFq37NfDDtHwTcH3BtsOAFwrel0oo64BORes2JZRPkiW69g34rE4DZqRlkSW+A9P7e0hJIb3/SPocdymMi+wP7j+BwQVlvw48nJbvA86o43tVMqGkdb8CLk7LQ4C3SX/Ui8r1JUuynQvW/Vep72PBZ15XQvkV8JOiY8wHDiqI+6sF284Fbi0qfx9wclp+GPh+wbZvAfcW/OzdWaJNAlYDuxWs+yTwSlr+MVkS3714X7/Ke7l7Z7X5YkR02/Qi+wXeZBegZxoqWClpJdlwy0711NkTeCsiVhWse5Xsv1PIEs5LJfbbBRhVdLwTgZ0LyiwtWF4DdKknluURsbaWbX2AVyNiQz11APyObKinJ9l/9QE8WhD35IKY3yL7I9erqI4dyHp6rxasa8jn0hA3AydIEvBl4LcR8c8S5XoCb8fm50BeLVGuoXYBzir6nvVJx9lkUVH5Y4vKHwD0KChT2/e4ts+nO/BR4JmCOu9N6yHrTS4A7pf0sqTzGt9MK+STYVaORWT/5Q1o5H6Lge0kdS1IKn3JhnM21bsbMLfE8f43IsaUG3AJdU2zvQjoK6l9fUklIlZKuh84jmxo645I//6mei6OiNvrieVNYD3pRHdaV+pzqc+H2hQRT0paRzacc0J6lbIE2FZS54Kk0rdUnQ20qe0XNzDeRWQ9lK/VVrieY5W6suxN4D2yodHXizemn8GzyBLfEOAhSU9HxPQyYjB8Ut7K8xTwTjqpurWyk+lDJX2irp0iYhHwOHCppE7pJO0EsnMekJ3Y/YmkAcrsJWl74G5gD0lfltQhvT4haVAD432D7DxPY9q3BJgkqXOKdf86yv8X8BXg6LS8yTXA+emP1aYT78cW7xzZpbi/BS6W1FXZifszgU2XAF8PnC1pRPpcdlfpk/tvAP1KnFi+BbgK2BARJS/9johXgZnARZI6SjoA+EIdba7PdcA3JI1KMXeW9HlJXWspfxvwBUmfSz9PnZRdKNG7Ace6HfispOPSyf3tJQ2LiPdTHJdL2hFAUi9Jn0vLh6fPUsA7ZMOxLXZ5+5bACcUaLf0B/ALZSfVXyP4TvB74WAN2H082Hr8YuJPsPMgDadtlZH9Y7yf7Bf9PYOv0n+ShwPFpv6V8cEK9IX4E3JyGPY6rr3BB+3YHXgNqyM7j1GYqMAB4IyLmFNRzZ4pziqR3yHpe42qp4ztk4/0vA38mS0w3pHr+G7g4rVsF/IHsJHOx/05fV0h6tmD9rcDQ9LUuJ5CdH3sL+CFZIipLRMwEvkaWyN4mG1o6pY7yi4AjyIZOl5P1Or5HA/5GRcRrZOfNzkqxzya7oAOyczMLgCfT9+BBsos+IPuePUh2vvAJ4JeR7umx8uiD3rmZbYnSZbLLgOER8WJLx2NbLvdQzLZ83wSedjKxpuaT8mZbMEkLya4s+2LLRmJtgYe8zMwsFx7yMjOzXDihmDWCSszEvKVQ0bxrZo3lhGJWJP1RXa1sosPXJV2mZn6ei3J4VopZc3NCMStt74joAnyG7P6Mcu7gNmtTnFDM6hARL5DNzTW0eJukfSU9kW6YXCLpKkkdC7aHpG9IelHZ9PVXp7uyN20vObW9Sk+53+Cp1iV9StLTkv6Rvn6qYFud08AXlGvU1Pdm4IRiVidJg8nmwZpVYvNG4P+QTe74SbLezLeKyhxONu383mTzfW2a9uOLZHeFH0U2WeGjwB0AEXFg2nfvyJ6S+Buyu8BrUtmd0r4fukRT2bNZ/gRcSTaN+2XAn9IUNpucQPYogB3JJqU8u0TbpgL9i6a3OYn677a3NswJxay0ZyW9Tfb8jOuBG4sLRMQzEfFkRGyIiIVkU+ofVFRsUkSsTNODPEQ2XQ1k09NfGhHz0gSUlwDDapmjC7LJI3uQTX2/PrJHFpe65v/zwIsRcWuK6w7gBTafl+vGiPh7RLxHNtXNsOJK0ozEvyFLIqT5yPqRzatmVpITillpwyNi24jYLSK+nyYa3IykPdIw1NI0T9QlFDzlMKltyvWGTm2/SUOnWu/Jh6edL5wKv66YijV06nszwAnFrBK/Ivvvf0BEbEM2DKW6d/mXRcDXC585ExFbR8TjpQpHxKqIOCsidiXrbZwp6TMlii4mS1aFCqfCb7CIeJLsQWSbpr73cJfVyQnFrHxdyWZFflfSQLI5sxqqvqntN5tyvxFTrU8jm+r/hDSV+5eAwZQ/VFXv1PdmmzihmJXvbLL/3FeRPXfjNw3dsQFT2/+Izafcb9BU6xGxguxCgLPInsl+DnB4RLzZ2MYlDZ363sxzeZlZ7Tz1vTWGeyhmVhdPfW8N5jl7zKwkT31vjeUhLzMzy4WHvMzMLBdteshrhx12iH79+rV0GGZmVeWZZ555MyK6F69v0wmlX79+zJw5s6XDMDOrKpKKZ2MAPORlZmY5cUIxM7NcOKGYmVku2vQ5FDOzlrB+/XpqampYu3ZtS4dSp06dOtG7d286dOjQoPJOKGZmzaympoauXbvSr18/Ch7i2apEBCtWrKCmpob+/fs3aB8PeZmZNbO1a9ey/fbbt9pkAiCJ7bffvlG9KCcUM7MW0JqTySaNjdEJxczMcuGEYmZWpT71qU+VXH/KKafwu9/9rpmjcUIxM6tajz9e8onRLcZXeZmZVakuXbrw7rvvEhF85zvfYcaMGfTv35+WmkXePRQzsyp35513Mn/+fJ577jmuu+66Fuu5OKGYmVW5Rx55hPHjx9OuXTt69uzJIYcc0iJxOKGYmW0BWsNlyE4oZmZV7sADD2TKlCls3LiRJUuW8NBDD7VIHD4pb2ZW5Y488khmzJjBxz/+cfbYYw8OOuigFonDCcXMrEq9++67QDbcddVVV7VwNB7yMjOznDihmJlZLpxQzMwsF04oZmaWCycUMzPLhROKmZnlwgnFzKwNWrRoEQcffDCDBg1iyJAhTJ48ueI6fR+KmVkb1L59e37xi18wfPhwVq1axYgRIxgzZgyDBw8uu85W1UORNFbSfEkLJJ1XYrskXZm2/1XS8KLt7STNknR380VtZlZ9evTowfDh2Z/Qrl27MmjQIF5//fWK6mw1PRRJ7YCrgTFADfC0pKkR8beCYuOAAek1CvhV+rrJGcA8YJtmCdrMrEIX/fF5/rb4nVzrHNxzG374hSENLr9w4UJmzZrFqFGj6i9ch9bUQ9kXWBARL0fEOmAKcERRmSOAWyLzJNBNUg8ASb2BzwPXN2fQZmbV7N133+Xoo4/miiuuYJttKvtfvNX0UIBewKKC9zVs3vuorUwvYAlwBXAO0LWug0iaCEwE6Nu3b0UBm5lVqjE9ibytX7+eo48+mhNPPJGjjjqq4vpaUw+l1GT+xc+xLFlG0uHAsoh4pr6DRMS1ETEyIkZ27969nDjNzKpeRDBhwgQGDRrEmWeemUudrSmh1AB9Ct73BhY3sMz+wL9JWkg2VHaIpNuaLlQzs+r22GOPceuttzJjxgyGDRvGsGHDmDZtWkV1tqYhr6eBAZL6A68DxwMnFJWZCnxb0hSy4bB/RMQS4Pz0QtJo4OyIOKmZ4jYzqzoHHHAAEcWDQJVpNQklIjZI+jZwH9AOuCEinpf0jbT9GmAacBiwAFgDnNpS8ZqZ2eZaTUIBiIhpZEmjcN01BcsBnF5PHQ8DDzdBeGZmVofWdA7FzMyqmBOKmZnlwgnFzMxy4YRiZma5cEIxM2uD1q5dy7777svee+/NkCFD+OEPf1hxna3qKi8zM2seW221FTNmzKBLly6sX7+eAw44gHHjxrHffvuVXad7KGZmbZAkunTpAmRzeq1fvx6p1OxWDeceiplZS7rnPFj6XL517vxxGDep3mIbN25kxIgRLFiwgNNPP32Lmr7ezMyaUbt27Zg9ezY1NTU89dRTzJ07t6L63EMxM2tJDehJNLVu3boxevRo7r33XoYOHVp2Pe6hmJm1QcuXL2flypUAvPfeezz44IMMHDiwojrdQzEza4OWLFnCySefzMaNG3n//fc57rjjOPzwwyuq0wnFzKwN2muvvZg1a1audXrIy8zMcuGEYmZmuXBCMTOzXDihmJlZLpxQzMwsF04oZmaWCycUM7M2bOPGjeyzzz4V34MCTihmZm3a5MmTGTRoUC51OaGYmbVRNTU1/OlPf+K0007LpT7fKW9m1oJ++tRPeeGtF3Ktc+B2Azl333PrLffd736Xn/3sZ6xatSqX47qHYmbWBt19993suOOOjBgxIrc63UMxM2tBDelJNIXHHnuMqVOnMm3aNNauXcs777zDSSedxG233VZ2ne6hmJm1QZdeeik1NTUsXLiQKVOmcMghh1SUTMAJxczMcuIhLzOzNm706NGMHj264nrcQzEzs1w4oZiZWS5aVUKRNFbSfEkLJJ1XYrskXZm2/1XS8LS+j6SHJM2T9LykM5o/ejOztq3VJBRJ7YCrgXHAYGC8pMFFxcYBA9JrIvCrtH4DcFZEDAL2A04vsa+ZmTWhVpNQgH2BBRHxckSsA6YARxSVOQK4JTJPAt0k9YiIJRHxLEBErALmAb2aM3gzs7au3qu8JPVtYF0rI+KdCmLpBSwqeF8DjGpAmV7Akk0rJPUD9gH+UkEsZmbWSA25bPhmIADVUSaAm4BbKoilVP3RmDKSugD/A3y3tuQmaSLZcBl9+zY0V5qZbXn69etH165dadeuHe3bt2fmzJkV1VdvQomIg4vXSdo5IpZWdOQPqwH6FLzvDSxuaBlJHciSye0R8fvaDhIR1wLXAowcObI4YZmZtSkPPfQQO+ywQy51lXsO5Su5HH1zTwMDJPWX1BE4HphaVGYq8JV0tdd+wD8iYokkAf8JzIuIy5ogNjMzq0e5d8ofIWkN8EBEzM8jkIjYIOnbwH1AO+CGiHhe0jfS9muAacBhwAJgDXBq2n1/4MvAc5Jmp3UXRMS0PGIzM2sqSy+5hH/Oy3f6+q0GDWTnCy6ot5wkDj30UCTx9a9/nYkTJ1Z03HITylFkJ76PlLR7ROTydJaUAKYVrbumYDmA00vs92fqPsdjZmZFHnvsMXr27MmyZcsYM2YMAwcO5MADDyy7vrISSkS8AdybXmZmVqaG9CSaSs+ePQHYcccdOfLII3nqqacqSihlnUORdLWkm9LyoWUf3czMWsTq1av/9aTG1atXc//99zN06NCK6ix3yGsd8EZaPgS4v6IozMysWb3xxhsceeSRAGzYsIETTjiBsWPHVlRnuQllDfCxdKmub+YwM6syu+66K3PmzMm1znITylvAe2Rzbz2WXzhmZlatGnUORVI3STcCR6dVtwAjc4/KzMyqTqN6KBGxUtIkoB/wJrAXUOtd6WZm1naUM+Q1AXglIu4Dnsk5HjMzq1LlJJS3gW9I2hOYA8yOiFn5hmVmZtWm0QklIi6VNB34OzAMOBBwQjEza+MafWOjpB+TPehqDPB6REzOPSozM2tyK1eu5JhjjmHgwIEMGjSIJ554oqL6Gp1QIuIHwD/TvkdLuq6iCMzMrEWcccYZjB07lhdeeIE5c+YwaNCgiuord/r6G4BBwPbALyuKwMzMmt0777zDI488woQJEwDo2LEj3bp1q6jOcm9s/Hey6VfaA5PJzqOYmVkjPfrbv/PmondzrXOHPl349HF71Fnm5Zdfpnv37px66qnMmTOHESNGMHnyZDp37lz2ccvtobwEdALuiggnEzOzKrNhwwaeffZZvvnNbzJr1iw6d+7MpEmTKqqz3B7K88AiYIKkn0fEJyqKwsysjaqvJ9FUevfuTe/evRk1ahQAxxxzTMUJpdweym5kyehaPnhqopmZVYmdd96ZPn36MH9+9tDd6dOnM3jw4IrqLLeHsigiZkjqASyrKAIzM2sR//Ef/8GJJ57IunXr2HXXXbnxxhsrqq/chDJW0t/JZht+lewkvZmZVZFhw4Yxc+bM3Oord8irG3AucA7ZPSlmZtbGldtD+TEwMCLmS9qYZ0BmZladGtxDkbT3puWIqImIB9PyeU0RmJmZVZfGDHnNkvRXSedI6tNkEZmZWVVqTEL5BdAZmAS8IukhSV9tmrDMzKzaNDihRMT3ImI3skf+Xk823cq1TRWYmZlVl8acQ9le0mnAJWQ3M4rsbnkzM6sy8+fPZ9iwYf96bbPNNlxxxRUV1dmYq7yWkiWgt4Ebgdsi4s8VHd3MzFrEnnvuyezZswHYuHEjvXr14sgjj6yozsYklDuB24B7ImJ9RUc1M7NWY/r06ey2227ssssuFdXT4IQSEcdVdCQzM/uQh266lmWvvpxrnTvusisHnzKxweWnTJnC+PHjKz5uuXfKm5nZFmDdunVMnTqVY489tuK6Gn2nvKQvRMQfKz6ymZk1qifRFO655x6GDx/OTjvtVHFd5fRQLq74qLWQNFbSfEkLJH3oDnxlrkzb/yppeEP3NTOzD7vjjjtyGe6C8hKKcjlycaVSO7LZi8cBg4Hxkoon5x8HDEivicCvGrGvmZkVWLNmDQ888ABHHXVULvWVMzlk5HLkD9sXWBARLwNImgIcAfytoMwRwC0REcCTkrqlZ7L0a8C+ubnprEt4r2OHpqjazNqAEV/4NMtqlrZoDB3aiW177MSKFStyq7Pc2YabQi82v1GyBhjVgDK9GrgvAJImkvVu6Nu3b1mBvq92vNfekyybWXlC8L6a6n/zBsbwfv7Hb00JpdRQWnGLayvTkH2zlRHXkqaMGTlyZFmf6Ff/37nl7GZmBsC8efPYuVePlg4jd+UklDdyjyJTAxTOYtwbWNzAMh0bsK+ZmTWhRp+Uj4gxTREI8DQwQFJ/SR2B44GpRWWmAl9JV3vtB/wjIpY0cF8zM2tCrWbIKyI2SPo2cB/QDrghIp6X9I20/RpgGnAYsABYQzZJZa37tkAzzMzarFaTUAAiYhpZ0ihcd03BcgCnN3RfMzNrPmVNvSLpzILlPfMLx8zMmsvll1/OkCFDGDp0KOPHj2ft2rUV1deohJLu+7gROFbStyQdAPiudDOzKvP6669z5ZVXMnPmTObOncvGjRuZMmVKRXU2asgrIlYCp0r6HPAmsBfw+4oiMDOzFrFhwwbee+89OnTowJo1a+jZs2dF9ZV7DmV9RDwjaTGwrKIIzMzasJV/fIl1i1fnWmfHnp3p9oXd6izTq1cvzj77bPr27cvWW2/NoYceyqGHHlrRccudvn6spN7ANcDlFUVgZmbN7u233+auu+7ilVdeYfHixaxevZrbbrutojrL7aF0A84FzgFOqygCM7M2rL6eRFN58MEH6d+/P927dwfgqKOO4vHHH+ekk04qu85yeyg/Bv4QEfMBT2plZlZl+vbty5NPPsmaNWuICKZPn86gQYMqqrPchHI+8OW0/FBFEZiZWbMbNWoUxxxzDMOHD+fjH/8477//PhMnVvawr3KHvNbxwZxeB5PdoW5mZlXkoosu4qKLLsqtvnJ7KGuAj0nqAJQ3B7yZmW1Ryk0oPwReIntK4u35hWNmZtWq3CGvf4+Iy8BTr5iZWaZRCUVSN7LnuO8iaS0wh+yy4VPzD83MzKpJo6dekVQDPAL8BdgbT71iZmaUN+S1AvgGsCdZD6Um14jMzKwqlfPExknA14AfAa8An845JjMzawaTJ09m6NChDBkyhCuuuKLi+hrdQ5H0Y7KnIs4GZkfEwxVHYWZmzWru3Llcd911PPXUU3Ts2JGxY8fy+c9/ngEDBpRdZzk9lB8AVwKrgKMlXVf20c3MrEXMmzeP/fbbj49+9KO0b9+egw46iDvvvLOiOsu9bPjrwK8j4t6Kjm5m1sbdc889LF26NNc6d955Z8aNG1dnmaFDh3LhhReyYsUKtt56a6ZNm8bIkSMrOm65CeUG4JuSOgO3R8TsiqIwM7NmNWjQIM4991zGjBlDly5d2HvvvWnfvtyUkCn7xkay+bzakw1/HVhRFGZmbVR9PYmmNGHCBCZMmADABRdcQO/evSuqr9ypV14COgF3RYSTiZlZFVq2LHvg7muvvcbvf/97xo8fX1F95fZQngcWARMk/TwiPlFRFGZm1uyOPvpoVqxYQYcOHbj66qvZdtttK6qv3ISyG/A2cG36amZmVebRRx/Ntb5yE8qiiJghqQewLM+AzMysOpV7DmWspN7ANcDlOcZjZmZVqtyE0g04FzgH+Gdu0ZiZtRER0dIh1KuxMTY4oUjau+Dtj8mu8JoPbGzUEc3M2rhOnTqxYsWKVp1UIoIVK1bQqVOnBu/TmHMosyTNBW4D7oiIB9NBz2tcmGZmbVvv3r2pqalh+fLlLR1KnTp16tSoe1Mak1B+ARwFTAIukfQocGtE3NC4EM3M2rYOHTrQv3//lg4jdw0e8oqI70XEbsBI4Hqyu+OvzSMISdtJekDSi+lryYuhJY2VNF/SAknnFaz/uaQXJP1V0p3pyZJmZtaMGnMOZXtJpwGXkD3yV2Q3N+bhPGB6RAwApqf3xcdvB1wNjAMGA+MlDU6bHwCGRsRewN+B83OKy8zMGqgxV3ktBX5N1kO5ETgwIvLqsx0B3JyWbwa+WKLMvsCCiHg5ItYBU9J+RMT9EbEhlXsSqGxCGjMza7TGnEO5k+yE/D0RsT7nOHaKiCUAEbFE0o4lyvRi8x5RDTCqRLmvAr/JOT4zM6tHvQlFUt+0eHb62kNSqaIrI+KdOup5ENi5xKYL64thUxUl1m12zZ2kC4ENwO11xDERmAjQt2/f2oqZmVkjNaSHcjMf/OEumUnS9puAW2qrJCI+W9s2SW9I6pF6J7VN51ID9Cl43xtYXFDHycDhwGeijou7I+Ja0sUEI0eObL0XgZuZVZl6E0pEHNwMcUwFTia7JPlk4K4SZZ4GBkjqD7wOHA+cANnVX2R37h8UEWuaIV4zMytS7tQreZsEjJH0IjAmvUdST0nTANJJ928D9wHzgN9GxPNp/6uArsADkmZLuqa5G2Bm1tZV9rzHnETECuAzJdYvBg4reD8NmFai3O5NGqCZmdWrtfRQzMysyjmhmJlZLpxQzMwsF04oZmaWCycUMzPLhROKmZnlwgnFzMxy4YRiZma5cEIxM7NcOKGYmVkunFDMzCwXTihmZpYLJxQzM8uFE4qZmeXCCcXMzHLhhGJmZrlwQjEzs1w4oZiZWS6cUMzMLBdOKGZmlgsnFDMzy4UTipmZ5cIJxczMcuGEYmZmuXBCMTOzXDihmJlZLpxQzMwsF04oZmaWCycUMzPLhROKmZnlwgnFzMxy0SoSiqTtJD0g6cX0ddtayo2VNF/SAknnldh+tqSQtEPTR21mZoVaRUIBzgOmR8QAYHp6vxlJ7YCrgXHAYGC8pMEF2/sAY4DXmiViMzPbTGtJKEcAN6flm4EvliizL7AgIl6OiHXAlLTfJpcD5wDRhHGamVktWktC2SkilgCkrzuWKNMLWFTwviatQ9K/Aa9HxJz6DiRpoqSZkmYuX7688sjNzAyA9s11IEkPAjuX2HRhQ6sosS4kfTTVcWhDKomIa4FrAUaOHOnejJlZTpotoUTEZ2vbJukNST0iYomkHsCyEsVqgD4F73sDi4HdgP7AHEmb1j8rad+IWJpbA8zMrE6tZchrKnByWj4ZuKtEmaeBAZL6S+oIHA9MjYjnImLHiOgXEf3IEs9wJxMzs+bVWhLKJGCMpBfJrtSaBCCpp6RpABGxAfg2cB8wD/htRDzfQvGamVmRZhvyqktErAA+U2L9YuCwgvfTgGn11NUv7/jMzKx+raWHYmZmVc4JxczMcuGEYmZmuXBCMTOzXDihmJlZLpxQzMwsF04oZmaWCycUMzPLhROKmZnlwgnFzMxy4YRiZma5cEIxM7NcOKGYmVkunFDMzCwXTihmZpYLJxQzM8uFE4qZmeXCCcXMzHLhhGJmZrlwQjEzs1w4oZiZWS6cUMzMLBdOKGZmlgsnFDMzy4UioqVjaDGSlgOvlrn7DsCbOYbTktyW1mdLaQe4La1VJW3ZJSK6F69s0wmlEpJmRsTIlo4jD25L67OltAPcltaqKdriIS8zM8uFE4qZmeXCCaV817Z0ADlyW1qfLaUd4La0Vrm3xedQzMwsF+6hmJlZLpxQzMwsF04oZZA0VtJ8SQskndfS8RSTdIOkZZLmFqzbTtIDkl5MX7ct2HZ+ast8SZ8rWD9C0nNp25WS1AJt6SPpIUnzJD0v6YxqbI+kTpKekjQnteOiamxHUZvaSZol6e5qboukhSmG2ZJmVnlbukn6naQX0u/MJ5u1LRHhVyNeQDvgJWBXoCMwBxjc0nEVxXggMByYW7DuZ8B5afk84KdpeXBqw1ZA/9S2dmnbU8AnAQH3AONaoC09gOFpuSvw9xRzVbUnHbNLWu4A/AXYr9raUdSmM4H/Au6u8p+xhcAOReuqtS03A6el5Y5At+ZsS7P/EFb7K33I9xW8Px84v6XjKhFnPzZPKPOBHmm5BzC/VPzAfamNPYAXCtaPB37dCtp1FzCmmtsDfBR4FhhVre0AegPTgUP4IKFUa1sW8uGEUnVtAbYBXiFdbNUSbfGQV+P1AhYVvK9J61q7nSJiCUD6umNaX1t7eqXl4vUtRlI/YB+y/+6rrj1piGg2sAx4ICKqsh3JFcA5wPsF66q1LQHcL+kZSRPTumpsy67AcuDGNBR5vaTONGNbnFAar9RYYjVfe11be1pVOyV1Af4H+G5EvFNX0RLrWkV7ImJjRAwj++9+X0lD6yjeatsh6XBgWUQ809BdSqxrFW1J9o+I4cA44HRJB9ZRtjW3pT3ZUPevImIfYDXZEFdtcm+LE0rj1QB9Ct73Bha3UCyN8YakHgDp67K0vrb21KTl4vXNTlIHsmRye0T8Pq2u2vZExErgYWAs1dmO/YF/k7QQmAIcIuk2qrMtRMTi9HUZcCewL9XZlhqgJvV8AX5HlmCarS1OKI33NDBAUn9JHYHjgaktHFNDTAVOTssnk52L2LT+eElbSeoPDACeSl3jVZL2S1d4fKVgn2aTjv2fwLyIuKxgU1W1R1J3Sd3S8tbAZ4EXqq0dABFxfkT0joh+ZD//MyLipGpsi6TOkrpuWgYOBeZShW2JiKXAIkl7plWfAf5Gc7aluU+AbQkv4DCyq41eAi5s6XhKxHcHsARYT/bfxgRge7KTqC+mr9sVlL8wtWU+BVdzACPJfrleAq6i6GRfM7XlALLu9l+B2el1WLW1B9gLmJXaMRf4QVpfVe0o0a7RfHBSvuraQnbeYU56Pb/p97ka25JiGAbMTD9nfwC2bc62eOoVMzPLhYe8zMwsF04oZmaWCycUMzPLhROKmZnlwgnFzMxy4YRiloM0y+u3Ct73lPS7JjrWFyX9oJZt76av3SXd2xTHN6uNE4pZProB/0ooEbE4Io5pomOdA/yyrgIRsRxYImn/JorB7EOcUMzyMQnYLT1T4+eS+ik9j0bSKZL+IOmPkl6R9G1JZ6YJ/J6UtF0qt5uke9MkhY9KGlh8EEl7AP+MiDfT+/6SnpD0tKSfFBX/A3Bik7barIATilk+zgNeiohhEfG9EtuHAieQzRN1MbAmsgn8niCb2gLgWuA7ETECOJvSvZD9yaa+32Qy2WSAnwCWFpWdCXy6zPaYNVr7lg7ArI14KCJWkc2R9A/gj2n9c8BeaTblTwH/XfBwvK1K1NODbIryTfYHjk7LtwI/Ldi2DOiZT/hm9XNCMWse/yxYfr/g/ftkv4cfAVZGNr19Xd4DPla0rrb5kzql8mbNwkNeZvlYRfaI4rJE9oyXVyQdC9ksy5L2LlF0HrB7wfvHyGb8hQ+fL9mDbII/s2bhhGKWg4hYATwmaa6kn5dZzYnABEmbZr49okSZR4B99MG42BlkD4V6mg/3XA4G/lRmLGaN5tmGzaqMpMnAHyPiwXrKPQIcERFvN09k1ta5h2JWfS4BPlpXAUndgcucTKw5uYdiZma5cA/FzMxy4YRiZma5cEIxM7NcOKGYmVkunFDMzCwX/x/UeybrQ0phsQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -163,7 +163,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -198,7 +198,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAElCAYAAADgCEWlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAlV0lEQVR4nO3deZhcZZn38e+PJCwGJEJ6JGQhCIgClwSMQAZlIoJABgYVF1BBEcmgzqgjiuD4IqAIjq+oDEjMIAQE8VVRRAwgDjCAI0sCAYkYCbIkJpCwhIRFIHC/fzxPQ1WlequuOtWn+ve5rrr67Od+qrvrrvOcc+6jiMDMzKzbeu0OwMzMhhYnBjMzq+LEYGZmVZwYzMysihODmZlVcWIwM7MqTgxWl6STJF2UhydJekrSiHbH1RtJb5O0qOB9hqRtB7mNhZKmNyeidbbd4+9R0msl3SBpjaRvKTlf0hOSbm1FPFYOTgwdStIDkvapmfZRSTcNdFsR8VBEbBwRLzYvwoHpzwdwRNwYEdsXFVOzRMSOEXE9VH+Qt2A/tb/HmcCjwKsj4ljgrcC+wISI2K0VMVg5ODFYR5A0st0xlNBWwB/jlbtctwIeiIinB7ohv/+dxYlhGJO0paRLJa2UdL+kT/ew3OT8jX1kxXqXS3pc0mJJR1csO0LSlyTdl7so5kuamOe9QdI1eb1Fkt5fsd4cSWdL+nVe7xZJ2+R5N+TF7sxdIR+QNF3SUklflPQwcH73tIptTpT089y+xySd1cN78KykzSqm7SLpUUmj8vjHJN2Tu1iulrRVD+/TppIuzPt7UNKXJa1XMf/ovJ01kv4oadc8/QFJ+0jaH/gS8IHczjslvU/S/Jr9HCvpsh5i2FrS/+R9XAOMrfd7lDQH+AhwXN7XPwPnAtPy+Ml5nQMlLZC0StL/SnpTxfYeyO//XcDTebt75OVW5finVyx/vaSvSvpdju83kirje2vFukskfTRP30DS/5X0kKRHJM2StFGeN1bSFXmdxyXdWPmeW4Miwq8OfAEPAPvUTPsocFMeXg+YD5wIrA+8DvgLsF+efxJwUR6eDAQwMo//D/A9YENgCrASeEee9wXgD8D2gICdgc2B0cAS4EhgJLArqRtjx7zeHOBxYLc8/2LgxxWxB7Btxfh0YC3wDWADYKM8bWmePwK4E/h23veGwFt7eK+uBY6uGP8mMCsPvwtYDLwxx/Vl4H/rxQVcCPwS2CS/Z38Gjsrz3gf8FXhLfl+2Bbaq/V1Vvu95fIP8vryxYtodwCE9tOX3wBl5vb2ANb38HucAX6v395HHdwVWALvn9/MjOdYNKuJeAEzM7/944DFgBunva9883pWXvx64D3h9Xv564PQ8b1KO9TBgFOlvZkqe9x3gcmCz/N7+CjgtzzsNmJXXGQW8DVC7///K/mp7AH616Beb/mmfAlZVvJ7hlcSwO/BQzTonAOfn4Zc/oCo/UPKHwIvAJhXrnQbMycOLgIPrxPMB4Maaad8HvpKH5wDnVsybAfypYrxeYnge2LBmWndimEZKWCP78V59HLg2D4uUwPbK41eSP9zz+Hr5fdyqMi7SB+dzwA4Vy/4zcH0evhr4TC+/q7qJIU87Bzg1D+8IPEH+cK5ZbhIpWY6umPajer/Hive8t8RwDvDVmn0sAv6hIu6PVcz7IvDDmuWvBj6Sh68Hvlwx75PAVRV/e7+o0yYBTwPbVEybBtyfh08hJeNta9f1q/GXD7k627siYkz3i/SP2G0rYMt8CL5K0ipSN8Zr+9jmlsDjEbGmYtqDpG+LkBLHfXXW2wrYvWZ/HwK2qFjm4YrhZ4CN+4hlZUT8rYd5E4EHI2JtH9sA+BmpC2VL0rfsAG6siPu7FTE/TvqwGl+zjbGkI68HK6b1533pjwuAD0oScDjwk4h4rs5yWwJPRPU5ggfrLNdfWwHH1vzOJub9dFtSs/z7apZ/KzCuYpmefsc9vT9dwKuA+RXbvCpPh3R0txj4jaS/SDp+4M20Wj5hNHwtIX3r2m6A6y0DNpO0SUVymETqJune7jbA3XX29z8RsW+jAdfRW2ngJcAkSSP7Sg4RsUrSb4D3k7qMLon8dTRv59SIuLiPWB4FXiCf0M3T6r0vfVmnTRFxs6TnSd0kH8yvepYDr5E0uiI5TKq3zX7qbvup/Yx3CemI4eieFu5jX/WuhHoUeJbU5fjX2pn5b/BYUgLbEbhO0m0R8d8NxGCZjxiGr1uB1fnk4UZKJ413kvSW3laKiCXA/wKnSdown4w8inROANIJzK9K2k7JmyRtDlwBvF7S4ZJG5ddbJL2xn/E+QjoPMpD2LQdOlzQ6x7pnL8v/CDgCOCQPd5sFnJA/dLpPML+vduVIl4D+BDhV0iZKJ6g/B3Rfenou8HlJb87vy7aqfxL7EWBynROoFwJnAWsjou4lxxHxIDAPOFnS+pLeChzUS5v78l/AMZJ2zzGPlvSPkjbpYfmLgIMk7Zf/njZUuiBgQj/2dTGwj6T355PYm0uaEhEv5Ti+LenvACSNl7RfHj4wv5cCVpO6Odt2WXWncGIYpvIH2UGkk8f3k76ZnQts2o/VDyP1Vy8DfkE6T3BNnncG6QPyN6R/1B8AG+Vvdu8EDs3rPcwrJ4774yTggtyd8P6+Fq5o37bAQ8BS0nmOnlwObAc8EhF3VmznFznOH0taTToSOqCHbfwrqT/8L8BNpARzXt7OT4FT87Q1wGWkk6m1fpp/Pibp9orpPwR2yj9780HS+aPHga+QEkpDImIecDQpIT1B6rL5aC/LLwEOJnVJriQdBXyBfnzORMRDpPNKx+bYF5AuXIB07mIxcHP+HfyWdHEDpN/Zb0nn034PfC/yPSHWOL1yxGxmQ1W+PHMFsGtE3NvueKyz+YjBrBw+AdzmpGBF8MlnsyFO0gOkK6He1d5IbLhwV5KZmVVxV5KZmVVxYjBrIUkfyvdI9LVcy6qqNkKpdtXX2h2HtYcTgw0ZeuV5Ad2vkPR0xfjbGtjmOuXHa+ZPl/RS3v4apeJ+RzYYf1WxQYCIuDgi3tnI9szaxSefbcjI17K/XAZDUgA7R8TiFu96WURMyDdJHQz8TNItEfHHvlbsJpedtg7iIwYrBTVQelnSD0klIX6VjwiO620fkVxGuplrh3yX7x2SViuVgT6pIp7uo4OjJD1EqtDaXR58Vd7fNNU8HEnSjnql9Pgjkr7UQ3t7K1/9UaW6QGuUyqV/qJf37DuSluXXdyRtkOd1ly0/VtIKSct7OlKSdLekgyrGRymVJZ/S2/tp5eXEYGXxDVK55imku5nHk0qGQ7pbdimpsNprSXfeRkQcTrrr+aBITy77j952kJPJu4ExpNLhT5PKZIwB/hH4hKR31az2D6T6SvuRCvABjMn7+33N9jch3aV7FakQ3bbAOjV9JI0Hfg18jXR39OeBSyV1SRoNnAkcEBGbAH9Puku4nn8H9iC9ZzuTahF9uWL+FqQ73ceTypqcLek1dbZzIfDhivEZwPKI6Gm/VnIdkRgknZe/9dQWbmt0e1flb2pX1EzfWukBMvdK+n+S1m/G/qx3uYvnaODfIqK7suvXSeU1IBWvG0cqhf1CpEd8DuQ67C2VqnY+SiojcXhELIqI6yPiDxHxUkTcBVxCSgSVToqIpyPi2X7s50Dg4Yj4VkT8LSLWRMQtdZb7MDA3IubmfV9DqoE0I89/CdhJ0kYRsTwiFvawvw8Bp0TEiohYCZxMqs7a7YU8/4WImEsqK1Hv0agXATMkvTqPH07fpTmsxDoiMZDqyu/fxO19k+p/oG7fAL6dK5I+QfqWZa3X6tLLy3Jp8s0iYkpE/BhAqXjcdUpPZHsSOIaKJ6JlS9bZWs/6W3q7x/LVuWrqB3Isy5WeePeGHrazJeuWAa8smf1YTeXZuqXOI2IZ8DvgEEljSLWi+qo2ayXWEYkhIm4gFd56maRt8jf/+bnPuad/nnrb+29SobPK7QnYm1S7H1KN/HcNKnDrr8rSy93Pl9g0IjaGVHo5Io6NiNeRCud9TtI78rqDuYPzR6TiehMjYlNSpVXVLBM9DNfT39Lb3eWrx1S8RkfE6QARcXUuXz4O+BOp+mg9y0hJptukPK0RF5COZN4H/L5eCWzrHB2RGHowG/jXiHgzqY/2e4Pc3ubAqopvWEtZ92Et1gKDLL080HLdlTYhPZTob5J2o+fnIHRbSerm6Wl/VwBbSPpsPjG8iaTd6yzXY/lqSa+V9E/5XMNzpO6fnspMXwJ8OZ+bGEs6J9PovRKXkR71+RkGUbHVyqEjE4OkjUkn5X4qaQHpEZLj8rz35Kssal9X97XZOtNcT6Q4jZZePo304bhK0ucHuM9PAqdIWkP6UP1JbwtHxDOk0tq/y/vbo2b+GtJzkA8ilR2/F3h7ne30Vr56PdLJ9mWko+R/oPrJfJW+Rjo3cRfpZPrtedqA5XMolwJbAz9vZBtWHh1TK0nSZOCKiNgpnyRbFBHj+litt+1NBz4fEQfmcZH+SbeIiLWSppFOPO436ODNSkDSicDrI+LDfS5spdaRRwwRsRq4X/lJW0p27mO1vrYZwHXAe/Okj5AeQm7W8SRtRrrYYna7Y7HW64jEIOkSUhfC9vmmnaNIl+odJelOYCHp0Ly/27uR9CStd+TtdR8VfJF0YnMx6ZzDD5rZDrOhSNLRpO6sK/OFHtbhOqYryczMmqOwI4Z8ZcWtSrf3L5R0cp1lpkt6UtKC/Dqx3rbMzKx1iiz89Rywd0Q8JWkUcJOkKyPi5prlbuw+4dsfY8eOjcmTJzczTjOzjjd//vxHI6Kr3rzCEkM+eftUHh2VX4Pux5o8eTLz5s0b7GbMzIYVSQ/2NK/Qk8/5Zp0FwArgmh7qxEzL3U1XStqxh+3MlDRP0ryVK1e2MmQzs2Gn0MQQES9GxBRgArCbpJ1qFrmdVAhtZ+A/SXdb1tvO7IiYGhFTu7rqHgmZmVmD2nK5akSsAq6npvBdRKyOiKfy8FxgVL6V38zMClLkVUlduTIjSg9Y2YdUAKxymS3yHcbk2jTrAY8VFaOZmRV7VdI44AJJI0gf+D+JiCskHQMQEbNIdxV/QtJaUjXNQwdYV9/MzAapyKuS7gJ2qTN9VsXwWcBZRcVkZmbr6oiSGGZm1jxODGYl8uJLL/Key9/DghUL2h2KdTAnBrMSuWPFHdz7xL3MWTin3aFYB3NiMCuRjddPj2SesfWMNkdincyJwayERqw3ot0hWAdzYjAzsypODGZmVsWJwczMqjgxmJlZFScGsxJxhRgrghODWQkJtTsE62BODGZmVsWJwczMqjgxmJlZFScGMzOr4sRgZmZVnBjMzKyKE4NZiQS+j8Faz4nBrIR8H4O1khODmZlVKSwxSNpQ0q2S7pS0UNLJdZaRpDMlLZZ0l6Rdi4rPzMySkQXu6zlg74h4StIo4CZJV0bEzRXLHABsl1+7A+fkn2ZmVpDCjhgieSqPjsqv2jNpBwMX5mVvBsZIGldUjGZmVvA5BkkjJC0AVgDXRMQtNYuMB5ZUjC/N08zMrCCFJoaIeDEipgATgN0k7VSzSL1LLda5Pk/STEnzJM1buXJlCyI1Mxu+2nJVUkSsAq4H9q+ZtRSYWDE+AVhWZ/3ZETE1IqZ2dXW1KkyzIcf3MVgRirwqqUvSmDy8EbAP8KeaxS4HjshXJ+0BPBkRy4uK0awsJN/HYK1T5FVJ44ALJI0gJaSfRMQVko4BiIhZwFxgBrAYeAY4ssD4zMyMAhNDRNwF7FJn+qyK4QA+VVRMZma2Lt/5bGZmVZwYzMysihODmZlVcWIwKxNfrWoFcGIwKyGX3bZWcmIwM7MqTgxmZlbFicHMzKo4MZiZWRUnBjMzq+LEYGZmVZwYzErEZbetCE4MZiXkstvWSk4MZmZWxYnBzMyqODGYmVkVJwYzM6vixGBmZlWcGMxKJD391qy1nBjMzKyKE4OZmVUpLDFImijpOkn3SFoo6TN1lpku6UlJC/LrxKLiMzOzZGSB+1oLHBsRt0vaBJgv6ZqI+GPNcjdGxIEFxmVmZhUKO2KIiOURcXseXgPcA4wvav9mZtY/bTnHIGkysAtwS53Z0yTdKelKSTv2sP5MSfMkzVu5cmUrQzUzG3YKTwySNgYuBT4bEatrZt8ObBUROwP/CVxWbxsRMTsipkbE1K6urpbGa2Y23BSaGCSNIiWFiyPi57XzI2J1RDyVh+cCoySNLTJGs6HMZbetCEVelSTgB8A9EXFGD8tskZdD0m45vseKitGsLITLblvrFHlV0p7A4cAfJC3I074ETAKIiFnAe4FPSFoLPAscGr7V08ysUIUlhoi4CXr/mhMRZwFnFRORmZnV4zufzcysihODmZlV6bMrSdKkfm5rVZ3LT83MrGT6c47hAiDo/fxAAHOAC5sQk5n1wJerWhH6TAwR8fbaaZK2iIiHWxOSmZm1U6PnGI5oahRmNiD5dh+zlmj0ctWDJT0DXBMRi5oZkJmZtVejRwzvARYD75Z0bhPjMTOzNmvoiCEiHgGuyi8zM+sgDR0xSDpb0pw8/M6mRmRmZm3VaFfS88Bf8vDeTYrFzMyGgEYTwzPAprmMdn9vgDOzQXJNSStCo1clPU6qfno28LvmhWNm/eGy29ZKAzpikDRG0vnAIXnShcDUpkdlZmZtM6AjhohYJel0YDLwKPAmYJ0nsZmZWXk10pV0FHB/RFwNzG9yPGZm1maNnHx+AjhG0nckHSlpl2YHZWZWVs8uWMDy/3Mi8eKL7Q6lYQNODBFxGnA0cBJwP7BXk2MyMyutlWedzaqf/pQXli9vdygNG3BikHQKcDCwL/DXiPhu06MyMyupjaZMAWDUuHHtDWQQGjliOBF4Lq97iKT/anpUZmZltV75LyVu9Aa384A3ApsD3+vPCpImSrpO0j2SFkr6TJ1lJOlMSYsl3SVp1wbjM+tovo/BWqnRxPBp0hVNI4H+diWtBY6NiDcCewCfkrRDzTIHANvl10zgnAbjMzOzBjWaGO4DNgR+GRH9OvkcEcsj4vY8vAa4Bxhfs9jBwIWR3AyMkVTejjozsxJqNDEsBK4FjpJ020BXljQZ2AW4pWbWeGBJxfhS1k0eSJopaZ6keStXrhzo7s3MrBeNJoZtSN1Is4EjB7KipI2BS4HPRsTq2tl1VlmnalhEzI6IqRExtaurayC7NzNrrQ4odNhoEb0lEXFt7uZZ0d+VcjXWS4GLI6JeKY2lwMSK8QnAsgZjNDNrnxI/l7vRI4b9JU0AZgHf7s8KSk8v/wFwT0Sc0cNilwNH5KuT9gCejIjy3iVi1mSx7gG0WdM1mhjGAF8EjiPd09AfewKHA3tLWpBfMyQdI+mYvMxc0gOAFgP/BXyywfjMCvHo82s5/s9LuX3108XuuLxfRq0EGu1KOgV4Q0QsktSvgiARcRN9/DlHegrJpxqMyaxwa9a+yJy/PsrUV7+KXV89ut3hmDVFv48YJO3cPRwRSyPit3n4+FYEZmZm7TGQrqQ78t3Ix0ma2PfiZp3PPf7WiQaSGL4FjAZOB+7P5S0+1pqwzMrFXf7WSfqdGCLiCxGxDelRnueSym3PblVgZmal1AGHkf0++Sxpc+DdwHuBt5O+JD3UorjMSsGXj1qPSnwfw0CuSnqYdITxBHA+cFG+0shs2FNBHwLRAXfV2tA3kMTwC+Ai4MqIeKFF8ZhZP7jstrVSvxNDRLy/lYGYlZG/v1snavTOZzOr4O/v1kkaeebzQa0IxMzMhoZGjhhObXoUZiXlc8HWiRpJDD5qNqvhfwp7WQd8W2gkMZS/1WYl5fsmyqOoS5hbwSefzQbBH9PWiZwYzEqozN9GbehrJDE80vQozMxsyBhwYoiIfVsRiFkZdXcl+Qu8dRJ3JZmZWRUnBjOzZhqml6si6XMVw9s3Lxyzcum+fNRF7ayTDKS6KpLGAN8G3iDpb8BdwFHAkc0Pzcxquey2FWFARwwRsSoijgROAm4BtgN+3p91JZ0naYWku3uYP13Sk5IW5NeJA4nNbDjxEYq10oCOGCq8EBHzJS0DVvRznTnAWcCFvSxzY0Qc2GBMZoXr/gLvj2nrJI2efN5f0gRgFqlrqU8RcQPweIP7MzOzgjSaGMYAXwSOA55rWjQwTdKdkq6UtGNPC0maKWmepHkrV65s4u7NzKzRxHAKcFlELAJebFIstwNbRcTOwH8Cl/W0YETMjoipETG1q6urSbs3a5y7kqyTNJoYTgAOz8PXNSOQiFgdEU/l4bnAKEljm7FtM7PilP/KsUYTw/PAX/Lw25sRiKQtlCuDSdotx/ZYM7Zt1ilcdrskSl4jpdGrkp4BNpU0CpjUnxUkXQJMB8ZKWgp8BRgFEBGzgPcCn5C0FngWODR80bYNca6VZJ2o0cTwFWAmcDZwcX9WiIjD+ph/FulyVjPrg+9jsFZqNDF8OiLOAJfEMDPrNI2UxDgH2CqXxLgT+DguiWHD1MtdSW2Nwqy5BpQYImJVPj9wA6kkxs70sySGmZmVQyNdSY8BxwDbk44YljY1IjMza6sBJ4aIOF3StcCfgSnA24A7mhyXWSl0XzjnriTr1gkXUw44MUg6BRgBLAAWRMT1TY7JzKzcSn79ciNHDCdKei2wC3CIpG0i4ujmh2Y29LXru6FK/sFjQ1ujl6v+M/D9iLiqmcGYlZXvK7BO0mhiOI90l/Jo4OKIWNC8kMzMrJ0arZX0aVJSGQmc2bxwzMql/KcZzdbVaGK4D9gQ+GVE7NXEeMxKyV3+1kkaTQwLgWuBoyTd1sR4zMzKbTherpptAzwBzM4/zYal8n8EWEuU/BCy0cSwJCKulTQOWNHMgMzKqKiPgU64ecqGvka7kvaXNAGYBXy7ifGYmVmbNZoYxgBfBI4DnmtaNGYl4y/w1on6nRgk7VwxegrpiqRFwItNj8rMzNpmIEcMd0i6S9JxgCLitwARcXxrQjMzs3YYSGL4FjAaOB24X9J1kj7WmrDMysEP6rFO1O/EEBFfiIhtgKnAucBepMtVzcysWwecdxrIOYbNJX0c+DrpUZ4Clgxg/fMkrZB0dw/zJelMSYtzl9Wu/d222XARnfCpMxyU/D6GgXQlPQx8n3TEcD6wV0RsPYD15wD79zL/AGC7/JpJera02ZDW/UHtMtjWSQZyg9svgIuAKyPihYHuKCJukDS5l0UOBi6MdAfPzZLGSBoXEcsHui+zTucy39ZKfSYGSZPy4Ofzz3E9fDtaFRGrBxHLeKq7ppbmaeskBkkzSUcVTJo0qXa2mZkNQn+OGC6g74svgtRVdOEgYqm37bodqhExm3zie+rUqe50tfbJf33+/m6dpM/EEBFvLyIQ0hHCxIrxCcCygvZtZmZZoyUxWuFy4Ih8ddIewJM+v2BmVrxGq6sOmKRLgOnAWElLga8AowAiYhYwF5gBLAaeIV0Sazak+QY3W0cHFNAqLDFExGF9zA/gUwWFY1ZKvo+hJEp++fJQ6koys37yfRPWSk4MZoPgriTrRE4MZmZWxYnBzMyqODGYDcLLXUnuS7IO4sRgZtZMHXC5qhODWYlEB3zoDAdlP4B0YjAbhO4Palc7tU7ixGBWQk5E1kpODGZmVsWJwWwQfIObdSInBjMzq+LEYGZmVZwYzAbBXUm2rvJfUuzEYFYiLrtdEiW/Fd6JwayEXHbbWsmJwWwQXCvJOpETg5mZVXFiMDOzKk4MZoPgmnbWiQpNDJL2l7RI0mJJx9eZP13Sk5IW5NeJRcZnZmYwsqgdSRoBnA3sCywFbpN0eUT8sWbRGyPiwKLiMmuGws49+whl6OuAw8gijxh2AxZHxF8i4nngx8DBBe7frOl8X4HVVfLL1IpMDOOBJRXjS/O0WtMk3SnpSkk7FhOaWbm47La1UmFdSdQ/2q79unU7sFVEPCVpBnAZsN06G5JmAjMBJk2a1OQwzQbOH9TWSYo8YlgKTKwYnwAsq1wgIlZHxFN5eC4wStLY2g1FxOyImBoRU7u6uloZs1mv3JFknajIxHAbsJ2krSWtDxwKXF65gKQtlO/1l7Rbju+xAmM0Mxv2CutKioi1kv4FuBoYAZwXEQslHZPnzwLeC3xC0lrgWeDQ8NPPrQRKfq7RrEqR5xi6u4fm1kybVTF8FnBWkTGZmTVTJ3yX9Z3PZiXiy2NLouSHkE4MZk1Q7o8Ba6oOyN1ODGaD0AG9BtYKPmIwM7OXdcC3BScGsyYo9/dDazofMZgNX+X/bmhN5yMGMzOrVe7jBScGs6Yo+weBNZGPGMyGt6I/AnwfQ0n4HIOZFU0l/+DpbOVP3k4MZk3gD2qrUvK/BycGs0Fw147Vcq0kMzNbl48YzKzcHwPWVIETg9lw1gG9BmbrcGIwK5FO6L/ueBE+YjAzdyVZZ3FiMBuEdn1/l1PR0BVR+t+OE4OZmVVxYjBrgrJ/Q7Qm8jkGs+HNp4KtExWaGCTtL2mRpMWSjq8zX5LOzPPvkrRrkfGZmQ2ejxj6TdII4GzgAGAH4DBJO9QsdgCwXX7NBM4pKj6zQSn354BZFRV1XbSkacBJEbFfHj8BICJOq1jm+8D1EXFJHl8ETI+I5T1td+rUqTFv3rwBx/Pls09m7vZTB7yemdlQsfvKRZxz2OcaWlfS/Iio+yE4clBRDcx4YEnF+FJg934sMx6oSgySZpKOKJg0aVJDwYx6/gW2eOHRhtY1MxsKRj/7XEu2W2RiqHewXXu40p9liIjZwGxIRwyNBPOVf/taI6uZmXW8Ik8+LwUmVoxPAJY1sIyZmbVQkYnhNmA7SVtLWh84FLi8ZpnLgSPy1Ul7AE/2dn7BzMyar7CupIhYK+lfgKuBEcB5EbFQ0jF5/ixgLjADWAw8AxxZVHxmZpYUeY6BiJhL+vCvnDarYjiATxUZk5mZVfOdz2ZmVsWJwczMqjgxmJlZFScGMzOrUlhJjFaRtBJ4sMHVxwKdcvuz2zI0dUpbOqUd4LZ02yoiuurNKH1iGAxJ83qqFVI2bsvQ1Clt6ZR2gNvSH+5KMjOzKk4MZmZWZbgnhtntDqCJ3JahqVPa0intALelT8P6HIOZma1ruB8xmJlZDScGMzOrMmwTg6T9JS2StFjS8e2Opx5J50laIenuimmbSbpG0r3552sq5p2Q27NI0n4V098s6Q953plSsU8qlzRR0nWS7pG0UNJnStyWDSXdKunO3JaTy9qWHMMISXdIuqLk7Xggx7BA0rySt2WMpJ9J+lP+n5lWeFsiYti9SGW/7wNeB6wP3Ans0O646sS5F7ArcHfFtP8Ajs/DxwPfyMM75HZsAGyd2zciz7sVmEZ6Qt6VwAEFt2McsGse3gT4c463jG0RsHEeHgXcAuxRxrbkGD4H/Ai4oqx/XzmGB4CxNdPK2pYLgI/n4fWBMUW3pdAGD5VXfrOurhg/ATih3XH1EOtkqhPDImBcHh4HLKrXBtJzL6blZf5UMf0w4PttbtMvgX3L3hbgVcDtpGeXl64tpCck/jewN68khtK1I+/3AdZNDKVrC/Bq4H7yhUHtastw7UoaDyypGF+ap5XBayM/1S7//Ls8vac2jc/DtdPbQtJkYBfSN+1StiV3vywAVgDXRERZ2/Id4DjgpYppZWwHpGfD/0bSfEkz87QytuV1wErg/NzFd66k0RTcluGaGOr1tZX9ut2e2jRk2ippY+BS4LMRsbq3RetMGzJtiYgXI2IK6Rv3bpJ26mXxIdkWSQcCKyJifn9XqTOt7e2osGdE7AocAHxK0l69LDuU2zKS1H18TkTsAjxN6jrqSUvaMlwTw1JgYsX4BGBZm2IZqEckjQPIP1fk6T21aWkerp1eKEmjSEnh4oj4eZ5cyrZ0i4hVwPXA/pSvLXsC/yTpAeDHwN6SLqJ87QAgIpblnyuAXwC7Uc62LAWW5qNQgJ+REkWhbRmuieE2YDtJW0taHzgUuLzNMfXX5cBH8vBHSP313dMPlbSBpK2B7YBb82HnGkl75KsSjqhYpxB5vz8A7omIMypmlbEtXZLG5OGNgH2AP1GytkTECRExISImk/7+r42ID5etHQCSRkvapHsYeCdwNyVsS0Q8DCyRtH2e9A7gjxTdlqJPEg2VFzCDdHXMfcC/tzueHmK8BFgOvED6BnAUsDnphOG9+edmFcv/e27PIiquQACmkv5R7gPOoubEVgHteCvpMPYuYEF+zShpW94E3JHbcjdwYp5eurZUxDGdV04+l64dpH75O/NrYff/cxnbkmOYAszLf2OXAa8pui0uiWFmZlWGa1eSmZn1wInBzMyqODGYmVkVJwYzM6vixGBmZlWcGMwq5MqWn6wY31LSz1q0r3dJOrGHeU/ln12SrmrF/s164sRgVm0M8HJiiIhlEfHeFu3rOOB7vS0QESuB5ZL2bFEMZutwYjCrdjqwTa7r/01Jk5WfhyHpo5Iuk/QrSfdL+hdJn8vFzm6WtFlebhtJV+WCbjdKekPtTiS9HnguIh7N41tL+r2k2yR9tWbxy4APtbTVZhWcGMyqHQ/cFxFTIuILdebvBHyQVIvnVOCZSMXOfk8qOwDpAe3/GhFvBj5P/aOCPUklu7t9l1Q47S3AwzXLzgPe1mB7zAZsZLsDMCuZ6yJiDakOzZPAr/L0PwBvyhVk/x74acUDszaos51xpPLK3fYEDsnDPwS+UTFvBbBlc8I365sTg9nAPFcx/FLF+Euk/6f1gFWRynL35llg05ppPdWn2TAvb1YIdyWZVVtDevxoQyI9Z+J+Se+DVFlW0s51Fr0H2LZi/HekKqew7vmE15OKoZkVwonBrEJEPAb8TtLdkr7Z4GY+BBwlqbva58F1lrkB2KXiAe2fIT1g5jbWPZJ4O/DrBmMxGzBXVzVrE0nfBX4VEb/tY7kbgIMj4oliIrPhzkcMZu3zdeBVvS0gqQs4w0nBiuQjBjMzq+IjBjMzq+LEYGZmVZwYzMysihODmZlVcWIwM7Mq/x93yCmUweLHVgAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/examples/symba_energy_momentum/cb.in b/examples/symba_energy_momentum/cb.in new file mode 100644 index 000000000..d4c7fe1f7 --- /dev/null +++ b/examples/symba_energy_momentum/cb.in @@ -0,0 +1,7 @@ +0 +39.47841760435743 ! G*Mass +0.005 ! Radius +0.0 ! J2 +0.0 ! J4 +0.4 0.4 0.4 !Ip +0.0 0.0 0.0 !rot !11.2093063 -38.75937204 82.25088158 ! rot (radian / year) \ No newline at end of file diff --git a/examples/symba_energy_momentum/collision_movie.py b/examples/symba_energy_momentum/collision_movie.py new file mode 100755 index 000000000..3fd3b6a86 --- /dev/null +++ b/examples/symba_energy_momentum/collision_movie.py @@ -0,0 +1,316 @@ +#!/usr/bin/env python3 +import swiftest +import numpy as np +import matplotlib.pyplot as plt +from matplotlib import animation +import matplotlib.collections as clt +from scipy.spatial.transform import Rotation as R + +xmin = -20.0 +xmax = 20.0 +ymin = -20.0 +ymax = 20.0 + +cases = ['supercat_head', 'supercat_off', 'disruption_head', 'disruption_off'] + +def scale_sim(ds): + + dsscale = ds.where(ds.id > 0, drop=True) # Remove the central body + + GMtot = dsscale['GMass'].sum(skipna=True, dim="id").isel(time=0) + rscale = ds['Radius'].sel(id=1, time=0) + dsscale['Radius'] /= rscale + + dsscale['radmarker'] = dsscale['Radius'].fillna(0) + + dsscale['px'] /= rscale + dsscale['py'] /= rscale + dsscale['pz'] /= rscale + + mpx = dsscale['GMass'] * dsscale['px'] + mpy = dsscale['GMass'] * dsscale['py'] + mpz = dsscale['GMass'] * dsscale['pz'] + xbsys = mpx.sum(skipna=True, dim="id") / GMtot + ybsys = mpy.sum(skipna=True, dim="id") / GMtot + zbsys = mpz.sum(skipna=True, dim="id") / GMtot + + mvx = dsscale['GMass'] * dsscale['vx'] + mvy = dsscale['GMass'] * dsscale['vy'] + mvz = dsscale['GMass'] * dsscale['vz'] + vxbsys = mvx.sum(skipna=True, dim="id") / GMtot + vybsys = mvy.sum(skipna=True, dim="id") / GMtot + vzbsys = mvz.sum(skipna=True, dim="id") / GMtot + + dsscale['pxb'] = dsscale['px'] - xbsys + dsscale['pyb'] = dsscale['py'] - ybsys + dsscale['pzb'] = dsscale['pz'] - zbsys + + dsscale['vxb'] = dsscale['vx'] - vxbsys + dsscale['vyb'] = dsscale['vy'] - vybsys + dsscale['vzb'] = dsscale['vz'] - vzbsys + + return dsscale + +class UpdatablePatchCollection(clt.PatchCollection): + def __init__(self, patches, *args, **kwargs): + self.patches = patches + clt.PatchCollection.__init__(self, patches, *args, **kwargs) + + def get_paths(self): + self.set_paths(self.patches) + return self._paths + +class AnimatedScatter(object): + """An animated scatter plot using matplotlib.animations.FuncAnimation.""" + + def __init__(self, ds, param): + + frame = 0 + nframes = ds['time'].size + self.ds = scale_sim(ds) + self.param = param + self.rot_angle = {} + + self.clist = {'Initial conditions' : 'xkcd:windows blue', + 'Disruption' : 'xkcd:baby poop', + 'Supercatastrophic' : 'xkcd:shocking pink', + 'Hit and run fragment' : 'xkcd:blue with a hint of purple', + 'Central body' : 'xkcd:almost black'} + + self.stream = self.data_stream(frame) + # Setup the figure and axes... + fig = plt.figure(figsize=(8,8), dpi=300) + plt.tight_layout(pad=0) + # set up the figure + self.ax = plt.Axes(fig, [0., 0., 1., 1.]) + self.ax.set_xlim(xmin, xmax) + self.ax.set_ylim(ymin, ymax) + self.ax.set_axis_off() + self.ax.set_aspect(1) + self.ax.get_xaxis().set_visible(False) + self.ax.get_yaxis().set_visible(False) + fig.add_axes(self.ax) + + # Then setup FuncAnimation. + self.ani = animation.FuncAnimation(fig, self.update, interval=1, frames=nframes, + init_func=self.setup_plot, blit=False) + self.ani.save(animfile, fps=60, dpi=300, + extra_args=['-vcodec', 'libx264']) + + def plot_pl_circles(self, pl, radmarker): + patches = [] + for i in range(pl.shape[0]): + s = plt.Circle((pl[i, 0], pl[i, 1]), radmarker[i]) + patches.append(s) + return patches + + def vec_props(self, c): + arrowprops = { + 'arrowstyle': '<|-', + 'mutation_scale': 20, + 'connectionstyle': 'arc3', + } + + arrow_args = { + 'xycoords': 'data', + 'textcoords': 'data', + 'arrowprops': arrowprops, + 'annotation_clip': True, + 'zorder': 100, + 'animated' : True + } + aarg = arrow_args.copy() + aprop = arrowprops.copy() + aprop['color'] = c + aarg['arrowprops'] = aprop + aarg['color'] = c + return aarg + + def plot_pl_vectors(self, pl, cval, r): + varrowend, varrowtip = self.velocity_vectors(pl, r) + arrows = [] + for i in range(pl.shape[0]): + aarg = self.vec_props(cval[i]) + a = self.ax.annotate("",xy=varrowend[i],xytext=varrowtip[i], **aarg) + arrows.append(a) + return arrows + + def plot_pl_spins(self, pl, id, cval, len): + sarrowend, sarrowtip = self.spin_arrows(pl, id, len) + arrows = [] + for i in range(pl.shape[0]): + aarg = self.vec_props(cval[i]) + aarg['arrowprops']['mutation_scale'] = 5 + aarg['arrowprops']['arrowstyle'] = "simple" + a = self.ax.annotate("",xy=sarrowend[i],xytext=sarrowtip[i], **aarg) + arrows.append(a) + return arrows + + def origin_to_color(self, origin): + cval = [] + for o in origin: + c = self.clist[o] + cval.append(c) + + return cval + + def velocity_vectors(self, pl, r): + px = pl[:, 0] + py = pl[:, 1] + vx = pl[:, 2] + vy = pl[:, 3] + vmag = np.sqrt(vx ** 2 + vy ** 2) + ux = np.zeros_like(vx) + uy = np.zeros_like(vx) + goodv = vmag > 0.0 + ux[goodv] = vx[goodv] / vmag[goodv] + uy[goodv] = vy[goodv] / vmag[goodv] + varrowend = [] + varrowtip = [] + for i in range(pl.shape[0]): + vend = (px[i], py[i]) + vtip = (px[i] + vx[i] * self.v_length, py[i] + vy[i] * self.v_length) + varrowend.append(vend) + varrowtip.append(vtip) + return varrowend, varrowtip + + def spin_arrows(self, pl, id, len): + px = pl[:, 0] + py = pl[:, 1] + sarrowend = [] + sarrowtip = [] + for i in range(pl.shape[0]): + endrel = np.array([0.0, len[i], 0.0]) + tiprel = np.array([0.0, -len[i], 0.0]) + r = R.from_rotvec(self.rot_angle[id[i]]) + endrel = r.apply(endrel) + tiprel = r.apply(tiprel) + send = (px[i] + endrel[0], py[i] + endrel[1]) + stip = (px[i] + tiprel[0], py[i] + tiprel[1]) + sarrowend.append(send) + sarrowtip.append(stip) + return sarrowend, sarrowtip + + def setup_plot(self): + # First frame + """Initial drawing of the scatter plot.""" + t, name, GMass, Radius, npl, pl, radmarker, origin = next(self.data_stream(0)) + + cval = self.origin_to_color(origin) + + # Scale markers to the size of the system + self.v_length = 0.50 # Length of arrow as fraction of velocity + + self.ax.margins(x=1, y=1) + self.ax.set_xlabel('x distance / ($R_1 + R_2$)', fontsize='16', labelpad=1) + self.ax.set_ylabel('y distance / ($R_1 + R_2$)', fontsize='16', labelpad=1) + + self.title = self.ax.text(0.50, 0.90, "", bbox={'facecolor': 'w', 'pad': 5}, transform=self.ax.transAxes, + ha="center", zorder=1000) + + self.title.set_text(titletext) + self.patches = self.plot_pl_circles(pl, radmarker) + + self.collection = UpdatablePatchCollection(self.patches, color=cval, alpha=0.5, zorder=50) + self.ax.add_collection(self.collection) + #self.varrows = self.plot_pl_vectors(pl, cval, radmarker) + self.sarrows = self.plot_pl_spins(pl, name, cval, radmarker) + + return self.collection, self.sarrows + + def update(self,frame): + """Update the scatter plot.""" + t, name, GMass, Radius, npl, pl, radmarker, origin = next(self.data_stream(frame)) + cval = self.origin_to_color(origin) + varrowend, varrowtip = self.velocity_vectors(pl, radmarker) + sarrowend, sarrowtip = self.spin_arrows(pl, name, radmarker) + for i, p in enumerate(self.patches): + p.set_center((pl[i, 0], pl[i,1])) + p.set_radius(radmarker[i]) + p.set_color(cval[i]) + #self.varrows[i].set_position(varrowtip[i]) + #self.varrows[i].xy = varrowend[i] + self.sarrows[i].set_position(sarrowtip[i]) + self.sarrows[i].xy = sarrowend[i] + + self.collection.set_paths(self.patches) + return self.collection, self.sarrows + + def data_stream(self, frame=0): + while True: + d = self.ds.isel(time=frame) + Radius = d['radmarker'].values + GMass = d['GMass'].values + x = d['pxb'].values + y = d['pyb'].values + vx = d['vxb'].values + vy = d['vyb'].values + name = d['id'].values + npl = d.id.count().values + id = d['id'].values + rotx = d['rot_x'].values + roty = d['rot_y'].values + rotz = d['rot_z'].values + + radmarker = d['radmarker'].values + origin = d['origin_type'].values + + t = self.ds.coords['time'].values[frame] + self.mask = np.logical_not(np.isnan(x)) + + x = np.nan_to_num(x, copy=False) + y = np.nan_to_num(y, copy=False) + vx = np.nan_to_num(vx, copy=False) + vy = np.nan_to_num(vy, copy=False) + radmarker = np.nan_to_num(radmarker, copy=False) + GMass = np.nan_to_num(GMass, copy=False) + Radius = np.nan_to_num(Radius, copy=False) + rotx = np.nan_to_num(rotx, copy=False) + roty = np.nan_to_num(roty, copy=False) + rotz = np.nan_to_num(rotz, copy=False) + rotvec = np.array([rotx, roty, rotz]) + self.rotvec = dict(zip(id, zip(*rotvec))) + + if frame == 0: + tmp = np.zeros_like(rotvec) + self.rot_angle = dict(zip(id, zip(*tmp))) + else: + t0 = self.ds.coords['time'].values[frame-1] + dt = t - t0 + idxactive = np.arange(id.size)[self.mask] + for i in id[idxactive]: + self.rot_angle[i] = self.rot_angle[i] + dt * np.array(self.rotvec[i]) + frame += 1 + yield t, name, GMass, Radius, npl, np.c_[x, y, vx, vy], radmarker, origin + +for case in cases: + if case == 'supercat_off': + animfile = 'movies/supercat_off_axis.mp4' + titletext = "Supercatastrophic - Off Axis" + paramfile = 'param.supercatastrophic_off_axis.in' + elif case == 'supercat_head': + animfile = 'movies/supercat_headon.mp4' + titletext = "Supercatastrophic - Head on" + paramfile = 'param.supercatastrophic_headon.in' + elif case == 'disruption_off': + animfile = 'movies/disruption_off_axis.mp4' + titletext = "Disruption - Off Axis" + paramfile = 'param.disruption_off_axis.in' + elif case == 'disruption_head': + animfile = 'movies/disruption_headon.mp4' + titletext = "Disruption- Head on" + paramfile = 'param.disruption_headon.in' + elif case == 'merger': + animfile = 'movies/merger.mp4' + titletext = "Merger" + paramfile = 'param.merger.in' + else: + print(f'{case} is an unknown case') + exit(-1) + sim = swiftest.Simulation(param_file=paramfile) + sim.bin2xr() + ds = sim.ds + print('Making animation') + anim = AnimatedScatter(ds,sim.param) + print('Animation finished') + plt.close(fig='all') diff --git a/examples/symba_energy_momentum/disruption_headon.in b/examples/symba_energy_momentum/disruption_headon.in new file mode 100644 index 000000000..bc91bbdd0 --- /dev/null +++ b/examples/symba_energy_momentum/disruption_headon.in @@ -0,0 +1,13 @@ +2 +1 1e-07 0.0009 +7e-06 +1.0 -4.20E-05 0.0 +0.00 6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 6.0e4 !rot +2 7e-10 0.0004 +3.25e-06 +1.0 4.20E-05 0.0 +0.00 -6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 1.0e5 !rot diff --git a/examples/symba_energy_momentum/disruption_off_axis.in b/examples/symba_energy_momentum/disruption_off_axis.in new file mode 100644 index 000000000..792bb3a4a --- /dev/null +++ b/examples/symba_energy_momentum/disruption_off_axis.in @@ -0,0 +1,13 @@ +2 +1 1e-07 0.0009 +7e-06 +1.0 -4.20E-05 0.0 +0.00 6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 6.0e4 !rot +2 7e-10 0.0004 +3.25e-06 +1.0 4.20E-05 0.0 +-0.80 -6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 1.0e5 !rot diff --git a/examples/symba_energy_momentum/escape.in b/examples/symba_energy_momentum/escape.in new file mode 100644 index 000000000..911cfce8e --- /dev/null +++ b/examples/symba_energy_momentum/escape.in @@ -0,0 +1,13 @@ +2 +1 1e-07 0.0009 +7e-05 +99.9 0.0 0.0 +100.00 10.00 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 1000.0 !rot +2 1e-08 0.0004 +3.25e-05 +1.0 4.20E-05 0.0 +0.00 -6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 0.0 !rot diff --git a/examples/symba_energy_momentum/param.disruption_headon.in b/examples/symba_energy_momentum/param.disruption_headon.in new file mode 100644 index 000000000..4a291535e --- /dev/null +++ b/examples/symba_energy_momentum/param.disruption_headon.in @@ -0,0 +1,31 @@ +T0 0.0e0 +TSTOP 0.000100 ! simulation length in seconds = 100 years +DT 0.0000001 ! stepsize in seconds +CB_IN cb.in +PL_IN disruption_headon.in +TP_IN tp.in +IN_TYPE ASCII +ISTEP_OUT 1 ! output cadence every year +BIN_OUT bin.disruption_headon.dat +PARTICLE_OUT particle.disruption_headon.dat +OUT_TYPE REAL8 ! double precision real output +OUT_FORM XV ! osculating element output +OUT_STAT REPLACE +ISTEP_DUMP 1 ! system dump cadence +CHK_CLOSE yes ! check for planetary close encounters +CHK_RMIN 0.005 +CHK_RMAX 1e6 +CHK_EJECT -1.0 ! ignore this check +CHK_QMIN -1.0 ! ignore this check +ENC_OUT enc.disruption_headon.dat +EXTRA_FORCE no ! no extra user-defined forces +BIG_DISCARD no ! output all planets if anything discarded +RHILL_PRESENT yes ! Hill's sphere radii in input file +GMTINY 1.0e-16 +FRAGMENTATION yes +MU2KG 1.98908e30 +TU2S 3.1556925e7 +DU2M 1.49598e11 +ENERGY yes +ROTATION yes +SEED 8 -223172604 -194186007 -2119403444 -114322815 -526658307 1075354356 2043693954 575062362 diff --git a/examples/symba_energy_momentum/param.disruption_off_axis.in b/examples/symba_energy_momentum/param.disruption_off_axis.in new file mode 100644 index 000000000..0dfbae80a --- /dev/null +++ b/examples/symba_energy_momentum/param.disruption_off_axis.in @@ -0,0 +1,32 @@ +T0 0.0e0 +TSTOP 0.000100 ! simulation length in seconds = 100 years +DT 0.0000001 ! stepsize in seconds +CB_IN cb.in +PL_IN disruption_off_axis.in +TP_IN tp.in +IN_TYPE ASCII +ISTEP_OUT 1 ! output cadence every year +BIN_OUT bin.disruption_off_axis.dat +PARTICLE_OUT particle.disruption_off_axis.dat +OUT_TYPE REAL8 ! double precision real output +OUT_FORM XV ! osculating element output +OUT_STAT REPLACE +ISTEP_DUMP 1 ! system dump cadence +CHK_CLOSE yes ! check for planetary close encounters +CHK_RMIN 0.005 +CHK_RMAX 1e6 +CHK_EJECT -1.0 ! ignore this check +CHK_QMIN -1.0 ! ignore this check +ENC_OUT enc.disruption_off_axis.dat +DISCARD_OUT discard.disruption_off_axis.out +EXTRA_FORCE no ! no extra user-defined forces +BIG_DISCARD no ! output all planets if anything discarded +RHILL_PRESENT yes ! Hill's sphere radii in input file +GMTINY 1.0e-16 +FRAGMENTATION yes +MU2KG 1.98908e30 +TU2S 3.1556925e7 +DU2M 1.49598e11 +ENERGY yes +ROTATION yes +SEED 8 933097 -220886113 -118730874 233084005 32111237 -823335422 524551114 -61162322 diff --git a/examples/symba_energy_momentum/param.escape.in b/examples/symba_energy_momentum/param.escape.in new file mode 100644 index 000000000..90d118017 --- /dev/null +++ b/examples/symba_energy_momentum/param.escape.in @@ -0,0 +1,33 @@ +T0 0.0e0 +TSTOP 1e2 ! simulation length in seconds = 100 years +DT 1.00 ! stepsize in seconds +CB_IN cb.in +PL_IN escape.in +TP_IN tp.in +IN_TYPE ASCII +ISTEP_OUT 1 ! output cadence every year +BIN_OUT bin.escape.dat +PARTICLE_OUT particle.escape.dat +OUT_TYPE REAL8 ! double precision real output +OUT_FORM XV ! osculating element output +OUT_STAT REPLACE +ISTEP_DUMP 1 ! system dump cadence +J2 0.0 ! no J2 term +J4 0.0 ! no J4 term +CHK_CLOSE yes ! check for planetary close encounters +CHK_RMIN 0.00465047 ! check for close solar encounters in AU +CHK_RMAX 10000.0 ! discard outside of +CHK_EJECT -1.0 ! ignore this check +CHK_QMIN -1.0 ! ignore this check +ENC_OUT enc.escape.dat +EXTRA_FORCE no ! no extra user-defined forces +BIG_DISCARD no ! output all planets if anything discarded +RHILL_PRESENT no ! Hill's sphere radii in input file +GMTINY 1.0e-16 +FRAGMENTATION yes +MU2KG 1.98908e30 +TU2S 3.1556925e7 +DU2M 1.49598e11 +ENERGY yes +ROTATION yes +SEED 8 -1109809 -120983313 -335849874 123308005 -625127 322235652 -3405804 -113111354 diff --git a/examples/symba_energy_momentum/param.sun.in b/examples/symba_energy_momentum/param.sun.in new file mode 100644 index 000000000..a7748b19c --- /dev/null +++ b/examples/symba_energy_momentum/param.sun.in @@ -0,0 +1,33 @@ +!Parameter file for the SyMBA-RINGMOONS test +T0 0.0 +TSTOP 3.0e-2 +DT 1e-3 +CB_IN cb.in +PL_IN sun.in +TP_IN tp.in +IN_TYPE ASCII +ISTEP_OUT 1 +ISTEP_DUMP 1 +BIN_OUT bin.sun.dat +PARTICLE_OUT particle.sun.dat +OUT_TYPE REAL8 +OUT_FORM XV ! osculating element output +OUT_STAT REPLACE +ISTEP_DUMP 1 ! system dump cadence +CHK_CLOSE yes ! check for planetary close encounters +CHK_RMIN 0.005 +CHK_RMAX 1e2 +CHK_EJECT -1.0 ! ignore this check +CHK_QMIN -1.0 ! ignore this check +ENC_OUT enc.escape.dat +EXTRA_FORCE no ! no extra user-defined forces +BIG_DISCARD no ! output all planets if anything discarded +RHILL_PRESENT no ! Hill's sphere radii in input file +GMTINY 1.0e-16 +FRAGMENTATION yes +MU2KG 1.98908e30 +TU2S 3.1556925e7 +DU2M 1.49598e11 +ENERGY yes +ROTATION yes +SEED 8 1230834 2346113 123409874 -123121105 -767545 -534058022 343309814 -12535638 diff --git a/examples/symba_energy_momentum/param.supercatastrophic_headon.in b/examples/symba_energy_momentum/param.supercatastrophic_headon.in new file mode 100644 index 000000000..e9b60e7da --- /dev/null +++ b/examples/symba_energy_momentum/param.supercatastrophic_headon.in @@ -0,0 +1,31 @@ +T0 0.0e0 +TSTOP 0.000030 ! simulation length in seconds = 100 years +DT 0.0000001 ! stepsize in seconds +PL_IN supercatastrophic_headon.in +CB_IN cb.in +TP_IN tp.in +IN_TYPE ASCII +ISTEP_OUT 1 ! output cadence every year +BIN_OUT bin.supercatastrophic_headon.dat +PARTICLE_OUT particle.supercatastrophic_headon.dat +OUT_TYPE REAL8 ! double precision real output +OUT_FORM XV ! osculating element output +OUT_STAT REPLACE +ISTEP_DUMP 1 ! system dump cadence +CHK_CLOSE yes ! check for planetary close encounters +CHK_RMIN 0.005 +CHK_RMAX 1e6 +CHK_EJECT -1.0 ! ignore this check +CHK_QMIN -1.0 ! ignore this check +ENC_OUT enc.supercatastrophic_headon.dat +EXTRA_FORCE no ! no extra user-defined forces +BIG_DISCARD no ! output all planets if anything discarded +RHILL_PRESENT yes ! Hill's sphere radii in input file +GMTINY 1.0e-16 +FRAGMENTATION yes +MU2KG 1.98908e30 +TU2S 3.1556925e7 +DU2M 1.49598e11 +ENERGY yes +ROTATION yes +SEED 8 97 120384098 122231114 -1133345 112137 -239375422 120938114 -66674667 diff --git a/examples/symba_energy_momentum/param.supercatastrophic_off_axis.in b/examples/symba_energy_momentum/param.supercatastrophic_off_axis.in new file mode 100644 index 000000000..0bf836be5 --- /dev/null +++ b/examples/symba_energy_momentum/param.supercatastrophic_off_axis.in @@ -0,0 +1,31 @@ +T0 0.0e0 +TSTOP 0.000030 ! simulation length in seconds = 100 years +DT 0.0000001 ! stepsize in seconds +CB_IN cb.in +PL_IN supercatastrophic_off_axis.in +TP_IN tp.in +IN_TYPE ASCII +ISTEP_OUT 1 ! output cadence every year +BIN_OUT bin.supercatastrophic_off_axis.dat +PARTICLE_OUT particle.supercatastrophic_off_axis.dat +OUT_TYPE REAL8 ! double precision real output +OUT_FORM XV ! osculating element output +OUT_STAT REPLACE +ISTEP_DUMP 1 ! system dump cadence +CHK_CLOSE yes ! check for planetary close encounters +CHK_RMIN 0.005 +CHK_RMAX 1e6 +CHK_EJECT -1.0 ! ignore this check +CHK_QMIN -1.0 ! ignore this check +ENC_OUT enc.supercatastrophic_off_axis.dat +EXTRA_FORCE no ! no extra user-defined forces +BIG_DISCARD no ! output all planets if anything discarded +RHILL_PRESENT yes ! Hill's sphere radii in input file +GMTINY 1.0e-16 +FRAGMENTATION yes +MU2KG 1.98908e30 +TU2S 3.1556925e7 +DU2M 1.49598e11 +ENERGY yes +ROTATION yes +SEED 8 92823097 -121212113 -736464874 352424135 34555257 -113243092 5640304 -394697 diff --git a/examples/symba_energy_momentum/sun.in b/examples/symba_energy_momentum/sun.in new file mode 100644 index 000000000..2f3904e5d --- /dev/null +++ b/examples/symba_energy_momentum/sun.in @@ -0,0 +1,13 @@ +2 +1 2e-08 +3e-04 +5e-2 0.0 0.0 +0.00 10.00 0.0 +0.4 0.4 0.4 !Ip +100.0 100000.0 -2300.0 !rot +2 2e-08 +3e-06 +1.0 0.00E-05 0.0 +0.00 6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 2300.0 !rot diff --git a/examples/symba_energy_momentum/supercatastrophic_headon.in b/examples/symba_energy_momentum/supercatastrophic_headon.in new file mode 100644 index 000000000..6894837f9 --- /dev/null +++ b/examples/symba_energy_momentum/supercatastrophic_headon.in @@ -0,0 +1,13 @@ +2 +1 1e-07 0.0009 +7e-06 +1.0 -4.20E-05 0.0 +0.00 6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 -6.0e4 !rot +2 1e-08 0.0004 +3.25e-06 +1.0 4.20E-05 0.0 +0.00 -6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 1.0e5 !rot diff --git a/examples/symba_energy_momentum/supercatastrophic_off_axis.in b/examples/symba_energy_momentum/supercatastrophic_off_axis.in new file mode 100644 index 000000000..230ed071f --- /dev/null +++ b/examples/symba_energy_momentum/supercatastrophic_off_axis.in @@ -0,0 +1,13 @@ +2 +1 1e-07 0.0009 +7e-06 +1.0 -4.20E-05 0.0 +0.00 6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 -6.0e4 !rot +2 1e-08 0.0004 +3.25e-06 +1.0 4.20E-05 0.0 +1.00 -6.28 0.0 +0.4 0.4 0.4 !Ip +0.0 0.0 1.0e5 !rot diff --git a/examples/symba_energy_momentum/tp.in b/examples/symba_energy_momentum/tp.in new file mode 100644 index 000000000..573541ac9 --- /dev/null +++ b/examples/symba_energy_momentum/tp.in @@ -0,0 +1 @@ +0 diff --git a/examples/symba_swifter_comparison/1pl_1pl_encounter/init_cond.py b/examples/symba_swifter_comparison/1pl_1pl_encounter/init_cond.py index 245f5fae0..6547c2802 100755 --- a/examples/symba_swifter_comparison/1pl_1pl_encounter/init_cond.py +++ b/examples/symba_swifter_comparison/1pl_1pl_encounter/init_cond.py @@ -180,7 +180,7 @@ print(f'DU2M {DU2M}') print(f'TU2S {TU2S}') print(f'RHILL_PRESENT yes') -print(f'MTINY 1e-12') +print(f'GMTINY 1e-12') diff --git a/examples/symba_swifter_comparison/1pl_1pl_encounter/param.swiftest.in b/examples/symba_swifter_comparison/1pl_1pl_encounter/param.swiftest.in index 3050dea4a..c69ee07f9 100644 --- a/examples/symba_swifter_comparison/1pl_1pl_encounter/param.swiftest.in +++ b/examples/symba_swifter_comparison/1pl_1pl_encounter/param.swiftest.in @@ -30,4 +30,4 @@ MU2KG 1.988409870698051e+30 DU2M 149597870700.0 TU2S 31557600.0 RHILL_PRESENT yes -MTINY 1e-12 +GMTINY 1e-12 diff --git a/examples/symba_swifter_comparison/1pl_1tp_encounter/init_cond.py b/examples/symba_swifter_comparison/1pl_1tp_encounter/init_cond.py index 338b5d5a8..ac55abb2b 100755 --- a/examples/symba_swifter_comparison/1pl_1tp_encounter/init_cond.py +++ b/examples/symba_swifter_comparison/1pl_1tp_encounter/init_cond.py @@ -20,6 +20,7 @@ swiftest_cb = "cb.swiftest.in" swiftest_bin = "bin.swiftest.dat" swiftest_enc = "enc.swiftest.dat" +swiftest_dis = "discard.swiftest.dat" MU2KG = swiftest.MSun TU2S = swiftest.YR2S @@ -168,6 +169,7 @@ print(f'CHK_QMIN_COORD HELIO') print(f'CHK_QMIN_RANGE {rmin} {rmax}') print(f'ENC_OUT {swiftest_enc}') +print(f'DISCARD_OUT {swiftest_dis}') print(f'EXTRA_FORCE no') print(f'BIG_DISCARD no') print(f'ROTATION no') @@ -176,7 +178,7 @@ print(f'DU2M {DU2M}') print(f'TU2S {TU2S}') print(f'RHILL_PRESENT yes') -print(f'MTINY 1e-12') +print(f'GMTINY 1e-12') diff --git a/examples/symba_swifter_comparison/1pl_1tp_encounter/param.swiftest.in b/examples/symba_swifter_comparison/1pl_1tp_encounter/param.swiftest.in index a7f91ba33..9fb0bf743 100644 --- a/examples/symba_swifter_comparison/1pl_1tp_encounter/param.swiftest.in +++ b/examples/symba_swifter_comparison/1pl_1tp_encounter/param.swiftest.in @@ -20,6 +20,7 @@ CHK_QMIN 0.004650467260962157 CHK_QMIN_COORD HELIO CHK_QMIN_RANGE 0.004650467260962157 1000.0 ENC_OUT enc.swiftest.dat +DISCARD_OUT discard.swiftest.dat EXTRA_FORCE no BIG_DISCARD no ROTATION no @@ -28,4 +29,4 @@ MU2KG 1.988409870698051e+30 DU2M 149597870700.0 TU2S 31557600.0 RHILL_PRESENT yes -MTINY 1e-12 +GMTINY 1e-12 diff --git a/examples/symba_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb b/examples/symba_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb index 02d6b0bef..78c6cf2b0 100644 --- a/examples/symba_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb +++ b/examples/symba_swifter_comparison/1pl_1tp_encounter/swiftest_vs_swifter.ipynb @@ -81,8 +81,8 @@ { "data": { "text/plain": [ - "[,\n", - " ]" + "[,\n", + " ]" ] }, "execution_count": 6, @@ -484,7 +484,7 @@ " 0., 0., 0., nan])\n", "Coordinates:\n", " id float64 100.0\n", - " * time (y) (time (y)) float64 0.0 0.0006845 0.001369 ... 0.1342 0.1348 0.1355
    • " ], "text/plain": [ "\n", diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in b/examples/symba_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in index 2e8d49f62..81c636655 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/cb.swiftest.in @@ -1,5 +1,5 @@ 0 0.00029591220819207774 0.004650467260962157 -0.0 -0.0 +4.7535806948127355e-12 +-2.2473967953572827e-18 diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/init_cond.py b/examples/symba_swifter_comparison/8pl_16tp_encounters/init_cond.py index 18ef4ce48..546dcbb88 100755 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/init_cond.py +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/init_cond.py @@ -19,6 +19,7 @@ swiftest_cb = "cb.swiftest.in" swiftest_bin = "bin.swiftest.dat" swiftest_enc = "enc.swiftest.dat" +swiftest_dis = "discard.swiftest.dat" sim = swiftest.Simulation() @@ -38,7 +39,7 @@ sim.param['GR'] = 'NO' sim.param['CHK_CLOSE'] = 'YES' sim.param['RHILL_PRESENT'] = 'YES' -sim.param['MTINY'] = 1.0e-12 +sim.param['GMTINY'] = 1.0e-12 sim.param['MU2KG'] = swiftest.MSun sim.param['TU2S'] = swiftest.JD2S @@ -125,6 +126,7 @@ sim.param['CB_IN'] = swiftest_cb sim.param['BIN_OUT'] = swiftest_bin sim.param['ENC_OUT'] = swiftest_enc +sim.param['DISCARD_OUT'] = swiftest_dis sim.save(swiftest_input) sim.param['PL_IN'] = swifter_pl diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swifter.in b/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swifter.in index f9305cfa2..d87472e35 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swifter.in +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swifter.in @@ -22,5 +22,5 @@ EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES RHILL_PRESENT YES -J2 0.0 -J4 0.0 +J2 4.7535806948127355e-12 +J4 -2.2473967953572827e-18 diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swiftest.in b/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swiftest.in index e9ed6376c..f26f33592 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swiftest.in +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/param.swiftest.in @@ -13,6 +13,7 @@ TP_IN tp.in CB_IN cb.swiftest.in BIN_OUT bin.swiftest.dat ENC_OUT enc.swiftest.dat +DISCARD_OUT discard.swiftest.dat CHK_QMIN 0.004650467260962157 CHK_RMIN 0.004650467260962157 CHK_RMAX 1000.0 @@ -31,6 +32,4 @@ ROTATION NO TIDES NO ENERGY NO GR NO -YARKOVSKY NO -YORP NO -MTINY 1e-12 +GMTINY 1e-12 diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.in b/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.in index 86a616119..207dd84f6 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.in +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.in @@ -1,33 +1,33 @@ 8 -1 4.9125474498983623693e-11 0.0014751239400086721089 +1 4.9125474498983623693e-11 0.001475124456355905224 1.6306381826061645943e-05 --0.09861361766419070307 0.29750596935836171042 0.03335708456145129036 --0.032353632540864457612 -0.0078122718370876240157 0.0023293874953380202045 -2 7.243452483873646905e-10 0.0067590794275223005208 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-0.018820805516945871005 -0.023743802865467341506 -0.00021385162925667799668 +2 7.243452483873646905e-10 0.006759069616556246028 4.0453784346544178454e-05 --0.6439817957564198947 -0.3248550380869373866 0.032702713983447248558 -0.008969709495375973937 -0.018153139924556138673 -0.0007667345025597138231 -3 8.9970113821660187435e-10 0.010044873080337524463 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +0.012753121506668980284 -0.015678149412530151263 -0.0009510907726656827677 +3 8.9970113821660187435e-10 0.010044908171483009529 4.25875607065040958e-05 -0.59421674333603324847 -0.82331253628773626296 3.7129329104855261984e-05 -0.013670550280388280365 0.010004295439859960809 -5.226292361234363611e-07 -4 9.549535102761465607e-11 0.0072467054748629370034 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +0.012205130808798069983 0.0117727888369263504476 -6.0385404652521189453e-07 +4 9.549535102761465607e-11 0.0072466797341124641736 2.265740805092889601e-05 --1.592721551706784977 0.48166390206865000723 0.049163460846716633412 --0.0035287723306552309585 -0.01219974682608557931 -0.00016910795626524249315 -5 2.825345908631354893e-07 0.35527074967975702942 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.0027036789764029569086 -0.012421968497550240837 -0.00019400613558421780209 +5 2.825345908631354893e-07 0.35527079166215922855 0.00046732617030490929307 -4.119089774477131094 -2.8872942462256898644 -0.080165336328135106125 -0.004245402942744468111 0.0065414198811065849687 -0.00012215100047356211078 -6 8.459715183006415395e-08 0.4376562090257202473 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +0.0041683967523185880624 0.0065946899141205552256 -0.00012065009272080269359 +6 8.459715183006415395e-08 0.43765832419088212185 0.00038925687730393611812 -6.3629100567525149756 -7.649727796147929304 -0.12023019299387090186 -0.0039834472120812329868 0.0035613826786502411278 -0.00022039988214595340028 -7 1.2920249163736673626e-08 0.4695793205674148502 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +0.0039680130835247464163 0.0035798698934692090544 -0.00022010758050265331019 +7 1.2920249163736673626e-08 0.46960112247450473807 0.00016953449859497231466 -14.814154683311180349 13.052040295401360126 -0.14347198499748289868 --0.002625101393275708784 0.0027742356008832688187 4.416821810149910185e-05 -8 1.5243589003230834323e-08 0.7813388398513013378 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.0026297294662822792016 0.0027702756265410048361 4.4212949669357180555e-05 +8 1.5243589003230834323e-08 0.78136567314580814177 0.000164587904124493665 -29.564924658285640646 -4.579331535234244299 -0.5871109926822926095 -0.00046449847307956888343 0.003128345390031967918 -7.5036135696161668576e-05 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.00046181040300440859715 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swifter.in b/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swifter.in index 595cdc169..3179473c0 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swifter.in +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swifter.in @@ -2,35 +2,35 @@ 0 0.00029591220819207775568 0.0 0.0 0.0 0.0 0.0 0.0 -1 4.9125474498983623693e-11 0.0014751239400086721089 +1 4.9125474498983623693e-11 0.001475124456355905224 1.6306381826061645943e-05 --0.09861361766419070307 0.29750596935836171042 0.03335708456145129036 --0.032353632540864457612 -0.0078122718370876240157 0.0023293874953380202045 -2 7.243452483873646905e-10 0.0067590794275223005208 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-0.018820805516945871005 -0.023743802865467341506 -0.00021385162925667799668 +2 7.243452483873646905e-10 0.006759069616556246028 4.0453784346544178454e-05 --0.6439817957564198947 -0.3248550380869373866 0.032702713983447248558 -0.008969709495375973937 -0.018153139924556138673 -0.0007667345025597138231 -3 8.9970113821660187435e-10 0.010044873080337524463 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +0.012753121506668980284 -0.015678149412530151263 -0.0009510907726656827677 +3 8.9970113821660187435e-10 0.010044908171483009529 4.25875607065040958e-05 -0.59421674333603324847 -0.82331253628773626296 3.7129329104855261984e-05 -0.013670550280388280365 0.010004295439859960809 -5.226292361234363611e-07 -4 9.549535102761465607e-11 0.0072467054748629370034 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +0.012205130808798069983 0.0117727888369263504476 -6.0385404652521189453e-07 +4 9.549535102761465607e-11 0.0072466797341124641736 2.265740805092889601e-05 --1.592721551706784977 0.48166390206865000723 0.049163460846716633412 --0.0035287723306552309585 -0.01219974682608557931 -0.00016910795626524249315 -5 2.825345908631354893e-07 0.35527074967975702942 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.0027036789764029569086 -0.012421968497550240837 -0.00019400613558421780209 +5 2.825345908631354893e-07 0.35527079166215922855 0.00046732617030490929307 -4.119089774477131094 -2.8872942462256898644 -0.080165336328135106125 -0.004245402942744468111 0.0065414198811065849687 -0.00012215100047356211078 -6 8.459715183006415395e-08 0.4376562090257202473 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +0.0041683967523185880624 0.0065946899141205552256 -0.00012065009272080269359 +6 8.459715183006415395e-08 0.43765832419088212185 0.00038925687730393611812 -6.3629100567525149756 -7.649727796147929304 -0.12023019299387090186 -0.0039834472120812329868 0.0035613826786502411278 -0.00022039988214595340028 -7 1.2920249163736673626e-08 0.4695793205674148502 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +0.0039680130835247464163 0.0035798698934692090544 -0.00022010758050265331019 +7 1.2920249163736673626e-08 0.46960112247450473807 0.00016953449859497231466 -14.814154683311180349 13.052040295401360126 -0.14347198499748289868 --0.002625101393275708784 0.0027742356008832688187 4.416821810149910185e-05 -8 1.5243589003230834323e-08 0.7813388398513013378 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.0026297294662822792016 0.0027702756265410048361 4.4212949669357180555e-05 +8 1.5243589003230834323e-08 0.78136567314580814177 0.000164587904124493665 -29.564924658285640646 -4.579331535234244299 -0.5871109926822926095 -0.00046449847307956888343 0.003128345390031967918 -7.5036135696161668576e-05 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.00046181040300440859715 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in b/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in index 86a616119..207dd84f6 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/pl.swiftest.in @@ -1,33 +1,33 @@ 8 -1 4.9125474498983623693e-11 0.0014751239400086721089 +1 4.9125474498983623693e-11 0.001475124456355905224 1.6306381826061645943e-05 --0.09861361766419070307 0.29750596935836171042 0.03335708456145129036 --0.032353632540864457612 -0.0078122718370876240157 0.0023293874953380202045 -2 7.243452483873646905e-10 0.0067590794275223005208 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-0.018820805516945871005 -0.023743802865467341506 -0.00021385162925667799668 +2 7.243452483873646905e-10 0.006759069616556246028 4.0453784346544178454e-05 --0.6439817957564198947 -0.3248550380869373866 0.032702713983447248558 -0.008969709495375973937 -0.018153139924556138673 -0.0007667345025597138231 -3 8.9970113821660187435e-10 0.010044873080337524463 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +0.012753121506668980284 -0.015678149412530151263 -0.0009510907726656827677 +3 8.9970113821660187435e-10 0.010044908171483009529 4.25875607065040958e-05 -0.59421674333603324847 -0.82331253628773626296 3.7129329104855261984e-05 -0.013670550280388280365 0.010004295439859960809 -5.226292361234363611e-07 -4 9.549535102761465607e-11 0.0072467054748629370034 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +0.012205130808798069983 0.0117727888369263504476 -6.0385404652521189453e-07 +4 9.549535102761465607e-11 0.0072466797341124641736 2.265740805092889601e-05 --1.592721551706784977 0.48166390206865000723 0.049163460846716633412 --0.0035287723306552309585 -0.01219974682608557931 -0.00016910795626524249315 -5 2.825345908631354893e-07 0.35527074967975702942 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.0027036789764029569086 -0.012421968497550240837 -0.00019400613558421780209 +5 2.825345908631354893e-07 0.35527079166215922855 0.00046732617030490929307 -4.119089774477131094 -2.8872942462256898644 -0.080165336328135106125 -0.004245402942744468111 0.0065414198811065849687 -0.00012215100047356211078 -6 8.459715183006415395e-08 0.4376562090257202473 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +0.0041683967523185880624 0.0065946899141205552256 -0.00012065009272080269359 +6 8.459715183006415395e-08 0.43765832419088212185 0.00038925687730393611812 -6.3629100567525149756 -7.649727796147929304 -0.12023019299387090186 -0.0039834472120812329868 0.0035613826786502411278 -0.00022039988214595340028 -7 1.2920249163736673626e-08 0.4695793205674148502 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +0.0039680130835247464163 0.0035798698934692090544 -0.00022010758050265331019 +7 1.2920249163736673626e-08 0.46960112247450473807 0.00016953449859497231466 -14.814154683311180349 13.052040295401360126 -0.14347198499748289868 --0.002625101393275708784 0.0027742356008832688187 4.416821810149910185e-05 -8 1.5243589003230834323e-08 0.7813388398513013378 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.0026297294662822792016 0.0027702756265410048361 4.4212949669357180555e-05 +8 1.5243589003230834323e-08 0.78136567314580814177 0.000164587904124493665 -29.564924658285640646 -4.579331535234244299 -0.5871109926822926095 -0.00046449847307956888343 0.003128345390031967918 -7.5036135696161668576e-05 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.00046181040300440859715 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/swiftest_symba_vs_swifter_symba.ipynb b/examples/symba_swifter_comparison/8pl_16tp_encounters/swiftest_symba_vs_swifter_symba.ipynb index c3c42dd4f..76094351b 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/swiftest_symba_vs_swifter_symba.ipynb +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/swiftest_symba_vs_swifter_symba.ipynb @@ -104,7 +104,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -130,7 +130,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -163,7 +163,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -198,7 +198,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -588,15 +588,24 @@ " fill: currentColor;\n", "}\n", "
    <xarray.DataArray 'px' (id: 16)>\n",
-       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\n",
+       "array([ 0.0000000e+00,  0.0000000e+00,  4.4408921e-16,  0.0000000e+00,\n",
+       "        0.0000000e+00, -4.4408921e-16,  4.4408921e-16,  0.0000000e+00,\n",
+       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00,\n",
+       "        0.0000000e+00,  0.0000000e+00,  0.0000000e+00,  0.0000000e+00])\n",
        "Coordinates:\n",
        "  * id       (id) int64 101 102 103 104 105 106 107 ... 111 112 113 114 115 116\n",
-       "    time     float64 110.0
    " + " time float64 110.0" ], "text/plain": [ "\n", - "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\n", + "array([ 0.0000000e+00, 0.0000000e+00, 4.4408921e-16, 0.0000000e+00,\n", + " 0.0000000e+00, -4.4408921e-16, 4.4408921e-16, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n", + " 0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00])\n", "Coordinates:\n", " * id (id) int64 101 102 103 104 105 106 107 ... 111 112 113 114 115 116\n", " time float64 110.0" diff --git a/examples/symba_swifter_comparison/8pl_16tp_encounters/tp.in b/examples/symba_swifter_comparison/8pl_16tp_encounters/tp.in index ae7796698..c1e239467 100644 --- a/examples/symba_swifter_comparison/8pl_16tp_encounters/tp.in +++ b/examples/symba_swifter_comparison/8pl_16tp_encounters/tp.in @@ -1,49 +1,49 @@ 16 101 --0.09859055695785905182 0.2975290300646933339 0.03335708456145129036 --0.029750083068855306956 -0.0078122718370876240157 0.0023293874953380202045 +-0.30947664140174180325 0.16192347328838543885 0.041620272188990829754 +-0.01621725604493672035 -0.023743802865467341506 -0.00021385162925667799668 102 --0.09863667837052235432 0.29748290865203008693 0.03335708456145129036 --0.034957182012873608268 -0.0078122718370876240157 0.0023293874953380202045 +-0.30952276281440505024 0.16187735187572213635 0.041620272188990829754 +-0.021424354988955021661 -0.023743802865467341506 -0.00021385162925667799668 103 --0.6439245854659476631 -0.32479782779646521051 0.032702713983447248558 -0.0153169432007213678765 -0.018153139924556138673 -0.0007667345025597138231 +-0.55665652353468386693 -0.46068452244605162527 0.02580196630219121906 +0.019100355212014374223 -0.015678149412530151263 -0.0009510907726656827677 104 --0.6440390060468921263 -0.32491224837740956266 0.032702713983447248558 -0.002622475790030579998 -0.018153139924556138673 -0.0007667345025597138231 +-0.5567709441156283301 -0.4607989430269959774 0.02580196630219121906 +0.0064058878013235863447 -0.015678149412530151263 -0.0009510907726656827677 105 -0.59427697124197276235 -0.8232523083817967491 3.7129329104855261984e-05 -0.020564990514662154913 0.010004295439859960809 -5.226292361234363611e-07 +0.6979392465946233637 -0.7360158052852626698 3.261671020506711323e-05 +0.019099571043071944532 0.0117727888369263504476 -6.0385404652521189453e-07 106 -0.5941565154300937346 -0.82337276419367577684 3.7129329104855261984e-05 -0.0067761100461144049487 0.010004295439859960809 -5.226292361234363611e-07 +0.6978187907827443359 -0.73613626109714169754 3.261671020506711323e-05 +0.005310690574524194567 0.0117727888369263504476 -6.0385404652521189453e-07 107 --1.5926895092930311026 0.48169594448240382611 0.049163460846716633412 --0.00044929323243133797994 -0.01219974682608557931 -0.00016910795626524249315 +-1.6176294307533440886 0.38317575049123231423 0.04771055403546069218 +0.00037580012182093606998 -0.012421968497550240837 -0.00019400613558421780209 108 --1.5927535941205388514 0.48163185965489618834 0.049163460846716633412 --0.006608251428879123937 -0.01219974682608557931 -0.00016910795626524249315 +-1.6176935155808518374 0.38311166566372467646 0.04771055403546069218 +-0.005783158074626849887 -0.012421968497550240837 -0.00019400613558421780209 109 -4.119750673485228276 -2.8866333472175926822 -0.080165336328135106125 -0.041127620144391897894 0.0065414198811065849687 -0.00012215100047356211078 +4.1534063578978459574 -2.834088304936593694 -0.081136554176388195336 +0.041050613953966016978 0.0065946899141205552256 -0.00012065009272080269359 110 -4.118428875469033912 -2.8879551452337870465 -0.080165336328135106125 --0.032636814258902961672 0.0065414198811065849687 -0.00012215100047356211078 +4.152084559881651593 -2.8354101029527880584 -0.081136554176388195336 +-0.032713820449328842588 0.0065946899141205552256 -0.00012065009272080269359 111 -6.3634605491076454697 -7.64917730379279881 -0.12023019299387090186 -0.026096616095614821179 0.0035613826786502411278 -0.00022039988214595340028 +6.395266446455758924 -7.620612254932671803 -0.121992225877669294154 +0.026081181967058334609 0.0035798698934692090544 -0.00022010758050265331019 112 -6.3623595643973844815 -7.650278288503059798 -0.12023019299387090186 --0.01812972167145235694 0.0035613826786502411278 -0.00022039988214595340028 +6.394165461745497936 -7.621713239642932791 -0.121992225877669294154 +-0.01814515580000884351 0.0035798698934692090544 -0.00022010758050265331019 113 -14.814394441298382787 13.052280053388562564 -0.14347198499748289868 -0.010469662145386185101 0.0027742356008832688187 4.416821810149910185e-05 +14.793375114914683266 13.074458101351583039 -0.14311846037737518955 +0.0104650340723796142495 0.0027702756265410048361 4.4212949669357180555e-05 114 -14.813914925323977911 13.051800537414157688 -0.14347198499748289868 --0.015719864931937603536 0.0027742356008832688187 4.416821810149910185e-05 +14.79289559894027839 13.073978585377178163 -0.14311846037737518955 +-0.015724493004944172653 0.0027702756265410048361 4.4212949669357180555e-05 115 -29.565157420731857485 -4.579098772788029237 -0.5871109926822926095 -0.014900134286357700347 0.003128345390031967918 -7.5036135696161668576e-05 +29.568862657342247502 -4.5540701367497931074 -0.58771107137394917874 +0.0148974462162825404404 0.0031288137434451902125 -7.498349850432879627e-05 116 -29.564691895839423808 -4.5795642976804593616 -0.5871109926822926095 --0.0139711373401985618214 0.003128345390031967918 -7.5036135696161668576e-05 +29.568397132449813824 -4.554535661642223232 -0.58771107137394917874 +-0.013973825410273721728 0.0031288137434451902125 -7.498349850432879627e-05 diff --git a/examples/whm_gr_test/init_cond.py b/examples/whm_gr_test/init_cond.py index 8d197c6f4..09feca135 100755 --- a/examples/whm_gr_test/init_cond.py +++ b/examples/whm_gr_test/init_cond.py @@ -24,6 +24,7 @@ sim.param['CHK_EJECT'] = 1000.0 sim.param['OUT_FORM'] = "EL" sim.param['OUT_STAT'] = "UNKNOWN" +sim.param['RHILL_PRESENT'] = "YES" sim.param['GR'] = 'YES' bodyid = { diff --git a/examples/whm_gr_test/param.swifter.in b/examples/whm_gr_test/param.swifter.in index 789250f41..f1574759a 100644 --- a/examples/whm_gr_test/param.swifter.in +++ b/examples/whm_gr_test/param.swifter.in @@ -21,7 +21,7 @@ CHK_QMIN_RANGE 0.004650467260962157 1000.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES +RHILL_PRESENT YES C 63241.07708426628 J2 4.7535806948127355e-12 J4 -2.2473967953572827e-18 -RHILL_PRESENT YES diff --git a/examples/whm_gr_test/param.swiftest.in b/examples/whm_gr_test/param.swiftest.in index ace6f3cad..00b2c2546 100644 --- a/examples/whm_gr_test/param.swiftest.in +++ b/examples/whm_gr_test/param.swiftest.in @@ -25,6 +25,7 @@ DU2M 149597870700.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES +RHILL_PRESENT YES FRAGMENTATION NO ROTATION NO TIDES NO diff --git a/examples/whm_gr_test/pl.swifter.in b/examples/whm_gr_test/pl.swifter.in index 782e57140..0b02f19c8 100644 --- a/examples/whm_gr_test/pl.swifter.in +++ b/examples/whm_gr_test/pl.swifter.in @@ -2,35 +2,35 @@ 0 39.476926408897625196 0.0 0.0 0.0 0.0 0.0 0.0 -1 6.5537098095653139645e-06 0.0014751234419554511911 +1 6.5537098095653139645e-06 0.001475124456355905224 1.6306381826061645943e-05 -0.13267502226188271353 0.2786606257975073886 0.010601098875389479426 --11.331978934667442676 4.8184460126705647045 1.4332264599878684131 -2 9.663313399581537916e-05 0.00675908960945781479 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 +2 9.663313399581537916e-05 0.006759069616556246028 4.0453784346544178454e-05 --0.69398700025820403425 -0.19235393648106968723 0.03740673057980103272 -1.9245789988923785786 -7.1528261190002948057 -0.20922405362759749996 -3 0.000120026935827952453094 0.010044837538502923644 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 +3 0.000120026935827952453094 0.010044908171483009529 4.25875607065040958e-05 -0.49463573470256239073 -0.8874896493821613497 4.051630875713834232e-05 -5.386704768180099809 3.0357508899436080915 -0.00016218409216515533796 -4 1.2739802010675941456e-05 0.0072467236860282326973 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 +4 1.2739802010675941456e-05 0.0072466797341124641736 2.265740805092889601e-05 --1.5655322071100350456 0.56626121192188216824 0.050269397991054412533 --1.5477080637857006753 -4.370087697214287981 -0.05361768768801557225 -5 0.037692251088985676735 0.35527094075555771578 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 +5 0.037692251088985676735 0.35527079166215922855 0.00046732617030490929307 -4.0891378954287338487 -2.9329188614380639066 -0.07930573161132697946 -1.575024788882753283 2.3719591091996699917 -0.045089307261129988257 -6 0.011285899820091272997 0.43765464106459166412 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 +6 0.011285899820091272997 0.43765832419088212185 0.00038925687730393611812 -6.3349788609660162564 -7.674600716671800882 -0.11868650931385750502 -1.4598618704191345578 1.2948691245181617393 -0.080593167691228835176 -7 0.0017236589478267730203 0.46956055286931676728 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 +7 0.0017236589478267730203 0.46960112247450473807 0.00016953449859497231466 -14.832516206189200858 13.032608531076540714 -0.14378102535616668622 --0.9573374666934839659 1.014553546383260322 0.016118112341773867214 -8 0.0020336100526728302319 0.7813163071687303693 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 +8 0.0020336100526728302319 0.78136567314580814177 0.000164587904124493665 -29.561664938083289655 -4.6012285192418387325 -0.586585578731106283 -0.17051705220469790965 1.1424784769020628332 -0.027423757798549895085 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/whm_gr_test/pl.swiftest.in b/examples/whm_gr_test/pl.swiftest.in index 10d425453..84cae57a2 100644 --- a/examples/whm_gr_test/pl.swiftest.in +++ b/examples/whm_gr_test/pl.swiftest.in @@ -1,33 +1,33 @@ 8 -1 6.5537098095653139645e-06 +1 6.5537098095653139645e-06 0.001475124456355905224 1.6306381826061645943e-05 -0.13267502226188271353 0.2786606257975073886 0.010601098875389479426 --11.331978934667442676 4.8184460126705647045 1.4332264599878684131 -2 9.663313399581537916e-05 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 +2 9.663313399581537916e-05 0.006759069616556246028 4.0453784346544178454e-05 --0.69398700025820403425 -0.19235393648106968723 0.03740673057980103272 -1.9245789988923785786 -7.1528261190002948057 -0.20922405362759749996 -3 0.000120026935827952453094 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 +3 0.000120026935827952453094 0.010044908171483009529 4.25875607065040958e-05 -0.49463573470256239073 -0.8874896493821613497 4.051630875713834232e-05 -5.386704768180099809 3.0357508899436080915 -0.00016218409216515533796 -4 1.2739802010675941456e-05 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 +4 1.2739802010675941456e-05 0.0072466797341124641736 2.265740805092889601e-05 --1.5655322071100350456 0.56626121192188216824 0.050269397991054412533 --1.5477080637857006753 -4.370087697214287981 -0.05361768768801557225 -5 0.037692251088985676735 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 +5 0.037692251088985676735 0.35527079166215922855 0.00046732617030490929307 -4.0891378954287338487 -2.9329188614380639066 -0.07930573161132697946 -1.575024788882753283 2.3719591091996699917 -0.045089307261129988257 -6 0.011285899820091272997 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 +6 0.011285899820091272997 0.43765832419088212185 0.00038925687730393611812 -6.3349788609660162564 -7.674600716671800882 -0.11868650931385750502 -1.4598618704191345578 1.2948691245181617393 -0.080593167691228835176 -7 0.0017236589478267730203 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 +7 0.0017236589478267730203 0.46960112247450473807 0.00016953449859497231466 -14.832516206189200858 13.032608531076540714 -0.14378102535616668622 --0.9573374666934839659 1.014553546383260322 0.016118112341773867214 -8 0.0020336100526728302319 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 +8 0.0020336100526728302319 0.78136567314580814177 0.000164587904124493665 -29.561664938083289655 -4.6012285192418387325 -0.586585578731106283 -0.17051705220469790965 1.1424784769020628332 -0.027423757798549895085 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/whm_gr_test/swiftest_relativity.ipynb b/examples/whm_gr_test/swiftest_relativity.ipynb index 69bacdf51..bbc87d783 100644 --- a/examples/whm_gr_test/swiftest_relativity.ipynb +++ b/examples/whm_gr_test/swiftest_relativity.ipynb @@ -116,15 +116,15 @@ "Mean precession rate for Mercury long. peri. (arcsec/100 y)\n", "JPL Horizons : 571.3210506300043\n", "Swifter GR : 571.6183105524942\n", - "Swiftest GR : 571.61831053222\n", + "Swiftest GR : 571.5670367229116\n", "Obs - Swifter : -0.2972599224899675\n", - "Obs - Swiftest : -0.29725990221562437\n", - "Swiftest - Swifter: -2.0274342205084395e-08\n" + "Obs - Swiftest : -0.2459860929071831\n", + "Swiftest - Swifter: -0.05127382958278304\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] diff --git a/examples/whm_swifter_comparison/init_cond.py b/examples/whm_swifter_comparison/init_cond.py index cc86e7635..9f9b3f98d 100755 --- a/examples/whm_swifter_comparison/init_cond.py +++ b/examples/whm_swifter_comparison/init_cond.py @@ -20,6 +20,7 @@ sim.param['OUT_FORM'] = "XV" sim.param['OUT_STAT'] = "UNKNOWN" sim.param['GR'] = 'NO' +sim.param['RHILL_PRESENT'] = 'NO' bodyid = { "Sun": 0, diff --git a/examples/whm_swifter_comparison/param.swifter.in b/examples/whm_swifter_comparison/param.swifter.in index 417c3ab04..8ea0e8771 100644 --- a/examples/whm_swifter_comparison/param.swifter.in +++ b/examples/whm_swifter_comparison/param.swifter.in @@ -21,6 +21,6 @@ CHK_QMIN_RANGE 0.004650467260962157 1000.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES -RHILL_PRESENT YES +RHILL_PRESENT NO J2 4.7535806948127355e-12 J4 -2.2473967953572827e-18 diff --git a/examples/whm_swifter_comparison/param.swiftest.in b/examples/whm_swifter_comparison/param.swiftest.in index 13fdad2ec..d6b863f5d 100644 --- a/examples/whm_swifter_comparison/param.swiftest.in +++ b/examples/whm_swifter_comparison/param.swiftest.in @@ -25,7 +25,7 @@ DU2M 149597870700.0 EXTRA_FORCE NO BIG_DISCARD NO CHK_CLOSE YES -RHILL_PRESENT YES +RHILL_PRESENT NO FRAGMENTATION NO ROTATION NO TIDES NO diff --git a/examples/whm_swifter_comparison/pl.swifter.in b/examples/whm_swifter_comparison/pl.swifter.in index 946ff123b..f39e7af56 100644 --- a/examples/whm_swifter_comparison/pl.swifter.in +++ b/examples/whm_swifter_comparison/pl.swifter.in @@ -2,35 +2,35 @@ 0 39.476926408897625196 0.0 0.0 0.0 0.0 0.0 0.0 -1 6.5537098095653139645e-06 0.0014751242768086609319 +1 6.5537098095653139645e-06 1.6306381826061645943e-05 --0.21794225400065470044 0.24570059548519398995 0.040069659678364698274 --9.768342370075118952 -6.4098488749322373205 0.37225116289830816995 -2 9.663313399581537916e-05 0.0067590742435367571566 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 +2 9.663313399581537916e-05 4.0453784346544178454e-05 --0.60413504586259936247 -0.39527613440541492507 0.029436881824798030033 -3.992938767473374092 -6.2169034295501688922 -0.3157349287333398891 -3 0.000120026935827952453094 0.010044891628501106769 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 +3 0.000120026935827952453094 4.25875607065040958e-05 -0.6475137988388671717 -0.78146344078682306034 3.4954277703126252982e-05 -4.7364737841481480227 3.9858178826605781494 -0.000206181980282845843 -4 1.2739802010675941456e-05 0.0072466933032545104062 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 +4 1.2739802010675941456e-05 2.265740805092889601e-05 --1.6060166552595489531 0.43262604649099911658 0.048461907252935247647 --1.1388942318608360441 -4.4988235352611598648 -0.066344559364066134143 -5 0.037692251088985676735 0.3552707368190505097 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 +5 0.037692251088985676735 0.00046732617030490929307 -4.1359946230316175786 -2.8610749953481979801 -0.08065244615734604161 -1.536603427793050461 2.399023353553466048 -0.044342472584791124157 -6 0.011285899820091272997 0.4376572328164372643 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 +6 0.011285899820091272997 0.00038925687730393611812 -6.3788284394924916754 -7.635463758938534795 -0.121111501730720202974 -1.4521392831727842248 1.3041738917825064364 -0.08044788317293871613 -7 0.0017236589478267730203 0.46959013246222981483 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 +7 0.0017236589478267730203 0.00016953449859497231466 -14.803649648126269156 13.063133279359290029 -0.14329526741228329478 --0.9596636872292902537 1.0125665712568530355 0.016140607193432704789 -8 0.0020336100526728302319 0.78135207839715916734 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 +8 0.0020336100526728302319 0.000164587904124493665 -29.566779964594630314 -4.5668176855665958414 -0.58741108465859714904 -0.16916723445783939828 1.142713652049310879 -0.027397346380668001207 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/whm_swifter_comparison/pl.swiftest.in b/examples/whm_swifter_comparison/pl.swiftest.in index c13f0640d..b624d25ba 100644 --- a/examples/whm_swifter_comparison/pl.swiftest.in +++ b/examples/whm_swifter_comparison/pl.swiftest.in @@ -1,33 +1,33 @@ 8 -1 6.5537098095653139645e-06 0.0014751242768086609319 +1 6.5537098095653139645e-06 1.6306381826061645943e-05 --0.21794225400065470044 0.24570059548519398995 0.040069659678364698274 --9.768342370075118952 -6.4098488749322373205 0.37225116289830816995 -2 9.663313399581537916e-05 0.0067590742435367571566 +-0.30949970210807342674 0.1619004125820537876 0.041620272188990829754 +-6.8742992150644793847 -8.672423996611946485 -0.078109307586001638286 +2 9.663313399581537916e-05 4.0453784346544178454e-05 --0.60413504586259936247 -0.39527613440541492507 0.029436881824798030033 -3.992938767473374092 -6.2169034295501688922 -0.3157349287333398891 -3 0.000120026935827952453094 0.010044891628501106769 +-0.5567137338251560985 -0.46074173273652380134 0.02580196630219121906 +4.6580776303108450487 -5.726444072926637749 -0.3473859047161406309 +3 0.000120026935827952453094 4.25875607065040958e-05 -0.6475137988388671717 -0.78146344078682306034 3.4954277703126252982e-05 -4.7364737841481480227 3.9858178826605781494 -0.000206181980282845843 -4 1.2739802010675941456e-05 0.0072466933032545104062 +0.6978790186886838498 -0.73607603319120218366 3.261671020506711323e-05 +4.4579240279134950613 4.300011122687349501 -0.00022055769049333364448 +4 1.2739802010675941456e-05 2.265740805092889601e-05 --1.6060166552595489531 0.43262604649099911658 0.048461907252935247647 --1.1388942318608360441 -4.4988235352611598648 -0.066344559364066134143 -5 0.037692251088985676735 0.3552707368190505097 +-1.617661473167097963 0.38314370807747849534 0.04771055403546069218 +-0.98751874613118001086 -4.5371239937302254657 -0.07086074102213555221 +5 0.037692251088985676735 0.00046732617030490929307 -4.1359946230316175786 -2.8610749953481979801 -0.08065244615734604161 -1.536603427793050461 2.399023353553466048 -0.044342472584791124157 -6 0.011285899820091272997 0.4376572328164372643 +4.1527454588897487753 -2.8347492039446908763 -0.081136554176388195336 +1.5225069137843642898 2.4087104911325327961 -0.044067446366273183833 +6 0.011285899820091272997 0.00038925687730393611812 -6.3788284394924916754 -7.635463758938534795 -0.121111501730720202974 -1.4521392831727842248 1.3041738917825064364 -0.08044788317293871613 -7 0.0017236589478267730203 0.46959013246222981483 +6.39471595410062843 -7.621162747287802297 -0.121992225877669294154 +1.4493167787574136286 1.3075474785896286071 -0.08039429377859412155 +7 0.0017236589478267730203 0.00016953449859497231466 -14.803649648126269156 13.063133279359290029 -0.14329526741228329478 --0.9596636872292902537 1.0125665712568530355 0.016140607193432704789 -8 0.0020336100526728302319 0.78135207839715916734 +14.793135356927480828 13.074218343364380601 -0.14311846037737518955 +-0.9605086875596024784 1.0118431725941020164 0.016148779866732710198 +8 0.0020336100526728302319 0.000164587904124493665 -29.566779964594630314 -4.5668176855665958414 -0.58741108465859714904 -0.16916723445783939828 1.142713652049310879 -0.027397346380668001207 +29.568629894896030663 -4.5543028991960081697 -0.58771107137394917874 +0.16867624969736024011 1.1427992197933557251 -0.027387722828706092838 diff --git a/examples/whm_swifter_comparison/tp.swifter.in b/examples/whm_swifter_comparison/tp.swifter.in index 22ca5a6ca..8a66912f4 100644 --- a/examples/whm_swifter_comparison/tp.swifter.in +++ b/examples/whm_swifter_comparison/tp.swifter.in @@ -1,13 +1,13 @@ 4 101 -2.1437140623725170485 1.8307543455088179929 -0.33710883085786358393 --2.5169991736250634084 2.6269266483088493027 0.54674712095669365287 +2.1159283340247889704 1.8593322968487970837 -0.33108647801775120678 +-2.557303042640355446 2.5920133227445458545 0.5530693963730075664 102 -3.0507953356624089025 -0.9309107058567914761 0.38209550228666327998 -0.45214249601424874418 2.5995875558304815747 -1.8388641770977671949 +3.055528708824450046 -0.9023759798915096386 0.36193041623852567623 +0.4122422441588732561 2.6115158464246720372 -1.8437451126910543971 103 --0.30288545144121659103 -3.139125526168093927 0.7252151132548391166 -3.0919425994019995516 0.13633790246363267858 -0.15665049243950410883 +-0.26900389298636068203 -3.1374127668516589296 0.7234488489303841918 +3.0956076496295565968 0.17648254651685860603 -0.16591700615421532186 104 --1.9314729940131600827 -1.0389307897540689396 0.26607157142831372454 -2.2775049779995786108 -3.7157836040053666307 -0.16601542341215017115 +-1.9061083760262669262 -1.0793924233562111059 0.26419511130887440853 +2.3545884478521155142 -3.673223720899393644 -0.17666743480430943436 diff --git a/examples/whm_swifter_comparison/tp.swiftest.in b/examples/whm_swifter_comparison/tp.swiftest.in index 22ca5a6ca..8a66912f4 100644 --- a/examples/whm_swifter_comparison/tp.swiftest.in +++ b/examples/whm_swifter_comparison/tp.swiftest.in @@ -1,13 +1,13 @@ 4 101 -2.1437140623725170485 1.8307543455088179929 -0.33710883085786358393 --2.5169991736250634084 2.6269266483088493027 0.54674712095669365287 +2.1159283340247889704 1.8593322968487970837 -0.33108647801775120678 +-2.557303042640355446 2.5920133227445458545 0.5530693963730075664 102 -3.0507953356624089025 -0.9309107058567914761 0.38209550228666327998 -0.45214249601424874418 2.5995875558304815747 -1.8388641770977671949 +3.055528708824450046 -0.9023759798915096386 0.36193041623852567623 +0.4122422441588732561 2.6115158464246720372 -1.8437451126910543971 103 --0.30288545144121659103 -3.139125526168093927 0.7252151132548391166 -3.0919425994019995516 0.13633790246363267858 -0.15665049243950410883 +-0.26900389298636068203 -3.1374127668516589296 0.7234488489303841918 +3.0956076496295565968 0.17648254651685860603 -0.16591700615421532186 104 --1.9314729940131600827 -1.0389307897540689396 0.26607157142831372454 -2.2775049779995786108 -3.7157836040053666307 -0.16601542341215017115 +-1.9061083760262669262 -1.0793924233562111059 0.26419511130887440853 +2.3545884478521155142 -3.673223720899393644 -0.17666743480430943436 diff --git a/param.restart.in b/param.restart.in deleted file mode 100644 index e69de29bb..000000000 diff --git a/ps_maker.py b/ps_maker.py deleted file mode 100644 index 9297ab9a1..000000000 --- a/ps_maker.py +++ /dev/null @@ -1,89 +0,0 @@ -import rebound -import numpy as np - -def setupSimulation(): - sim = rebound.Simulation() - sim.units = ('AU', 'yr', 'Msun') - sim.integrator = "mercurius" - sim.dt = 0.008 - sim.testparticle_type = 1 - sim.move_to_com() - return sim - -sim = setupSimulation() -ps = sim.particles -G_auy = 4 * np.pi * np.pi #G in units of AU^3 year^-2 M_sun^-1 -M_Sun = 1 -M_Sun_to_g = 1.989e33 -M_Sun_to_kg = 1.989e30 -AU_cubed_to_cm_cubed = 3.348e39 -AU_cubed_to_km_cubed = 3.348e24 -year_to_seconds = 3.154e7 -Mtot_disk = 6.006e-6 #~3*M_earth - -OUTFILE = open('pl.in', 'w') - -sim.add( m=1.0, hash="sun") # SUN - Adds a particle of mass 1 - -N_fully = 2001 -N_semi = 0 - -d_bodies = 2.0 * AU_cubed_to_cm_cubed * (1/M_Sun_to_g) #Changes 2 g/cm^3 to 3366515.837 M_sun/AU^3 - -m_semi = Mtot_disk / (N_semi + 2*N_fully) -m_fully = 2 * m_semi - -r_semi = ((3*m_semi)/(4*np.pi*d_bodies))**(1/3) -r_fully = ((3*m_fully)/(4*np.pi*d_bodies))**(1/3) - -np.random.seed(1) - -def uniform(minimum, maximum): - return np.random.uniform()*(maximum-minimum)+minimum - -while sim.N < N_fully: - a_fully = uniform(0.5,1) - e_fully = uniform(0.0, 0.3) - inc_fully = uniform(0.0, 0.3) - O_fully = uniform(0,2*np.pi) - o_fully = uniform(0,2*np.pi) - M_fully = uniform(-np.pi, np.pi) - fully = rebound.Particle(simulation=sim,primary=sim.particles[0],m=m_fully, r=r_fully, a=a_fully, e=e_fully, inc=inc_fully, Omega=O_fully, omega=o_fully, M=M_fully) - sim.add(fully) - -while sim.N < (N_fully+N_semi): - a_semi = uniform(0.5,1) - e_semi = uniform(0.0, 0.3) - inc_semi = uniform(0.0, 0.3) - O_semi = uniform(0,2*np.pi) - o_semi = uniform(0,2*np.pi) - M_semi = uniform(-np.pi, np.pi) - semi = rebound.Particle(simulation=sim,primary=sim.particles[0],m=m_semi, r=r_semi, a=a_semi, e=e_semi, inc=inc_semi, Omega=O_semi, omega=o_semi, M=M_semi) - sim.add(semi) - -x = [ps[i].x for i in range(1, sim.N)] -y = [ps[i].y for i in range(1, sim.N)] -z = [ps[i].z for i in range(1, sim.N)] -vx = [ps[i].vx for i in range(1, sim.N)] -vy = [ps[i].vy for i in range(1, sim.N)] -vz = [ps[i].vz for i in range(1, sim.N)] -m = [ps[i].m for i in range(1, sim.N)] -r = [ps[i].r for i in range(1, sim.N)] -Rhill = [ps[i].a*((ps[i].m/(3*M_Sun))**(0.333333)) for i in range(1, sim.N)] - -with OUTFILE as output: - output.write("%s ! Solar System in unit system AU, M_sun, and years\n" %(sim.N)) - output.write("1 %s\n"%"{:10.8e}".format(M_Sun*G_auy)) - output.write(".0 .0 .0 ! x y z\n") - output.write(".0 .0 .0 !vx vy vz\n") - for i in range (0, (sim.N-1)): - output.write("%s %s %s ! ID / G*Mass / Rhill\n"%((i+2),"{:10.8e}".format(m[i]*G_auy),"{:10.8e}".format(Rhill[i]))) - output.write("%s ! Radius\n"%("{:10.8e}".format(r[i]))) - output.write("%s %s %s ! x y z\n"%("{:10.8e}".format(x[i]),"{:10.8e}".format(y[i]),"{:10.8e}".format(z[i]))) - output.write("%s %s %s ! vx vy vz\n"%("{:10.8e}".format(vx[i]),"{:10.8e}".format(vy[i]),"{:10.8e}".format(vz[i]))) - - - - - - diff --git a/python/swiftest/swiftest/io.py b/python/swiftest/swiftest/io.py index ce8b800ce..0492a05f8 100644 --- a/python/swiftest/swiftest/io.py +++ b/python/swiftest/swiftest/io.py @@ -24,6 +24,7 @@ def real2float(realstr): """ return float(realstr.replace('d', 'E').replace('D', 'E')) + def read_swiftest_param(param_file_name, param): """ Reads in a Swiftest param.in file and saves it as a dictionary @@ -64,7 +65,6 @@ def read_swiftest_param(param_file_name, param): param['CHK_RMAX'] = real2float(param['CHK_RMAX']) param['CHK_EJECT'] = real2float(param['CHK_EJECT']) param['CHK_QMIN'] = real2float(param['CHK_QMIN']) - param['MTINY'] = real2float(param['MTINY']) param['DU2M'] = real2float(param['DU2M']) param['MU2KG'] = real2float(param['MU2KG']) param['TU2S'] = real2float(param['TU2S']) @@ -73,15 +73,19 @@ def read_swiftest_param(param_file_name, param): param['CHK_CLOSE'] = param['CHK_CLOSE'].upper() param['RHILL_PRESENT'] = param['RHILL_PRESENT'].upper() param['FRAGMENTATION'] = param['FRAGMENTATION'].upper() + if param['FRAGMENTATION'] == 'YES' and param['PARTICLE_OUT'] == '': + param['PARTICLE_OUT'] = 'particle.dat' param['ROTATION'] = param['ROTATION'].upper() param['TIDES'] = param['TIDES'].upper() param['ENERGY'] = param['ENERGY'].upper() param['GR'] = param['GR'].upper() - param['YORP'] = param['YORP'].upper() + if 'GMTINY' in param: + param['GMTINY'] = real2float(param['GMTINY']) except IOError: print(f"{param_file_name} not found.") return param + def read_swifter_param(param_file_name): """ Reads in a Swifter param.in file and saves it as a dictionary @@ -165,6 +169,7 @@ def read_swifter_param(param_file_name): return param + def read_swift_param(param_file_name, startfile="swift.in"): """ Reads in a Swift param.in file and saves it as a dictionary @@ -251,6 +256,7 @@ def read_swift_param(param_file_name, startfile="swift.in"): return param + def write_swift_param(param, param_file_name): outfile = open(param_file_name, 'w') print(param['T0'], param['TSTOP'], param['DT'], file=outfile) @@ -262,6 +268,7 @@ def write_swift_param(param, param_file_name): outfile.close() return + def write_labeled_param(param, param_file_name): outfile = open(param_file_name, 'w') keylist = ['! VERSION', @@ -300,6 +307,7 @@ def write_labeled_param(param, param_file_name): outfile.close() return + def swifter_stream(f, param): """ Reads in a Swifter bin.dat file and returns a single frame of data as a datastream @@ -318,7 +326,7 @@ def swifter_stream(f, param): plid : int array IDs of massive bodies pvec : float array - (npl,N) - vector of N quantities or each particle (6 of XV/EL + Mass, Radius, etc) + (npl,N) - vector of N quantities or each particle (6 of XV/EL + GMass, Radius, etc) plab : string list Labels for the pvec data ntp : int @@ -376,7 +384,7 @@ def swifter_stream(f, param): tlab.append('omega') tlab.append('capm') plab = tlab.copy() - plab.append('Mass') + plab.append('GMass') plab.append('Radius') pvec = np.vstack([pvec, Mpl, Rpl]) @@ -401,11 +409,11 @@ def make_swiftest_labels(param): tlab.append('omega') tlab.append('capm') plab = tlab.copy() - plab.append('Mass') + plab.append('GMass') plab.append('Radius') if param['RHILL_PRESENT'] == 'YES': plab.append('Rhill') - clab = ['Mass', 'Radius', 'J_2', 'J_4'] + clab = ['GMass', 'Radius', 'J_2', 'J_4'] if param['ROTATION'] == 'YES': clab.append('Ip_x') clab.append('Ip_y') @@ -443,13 +451,13 @@ def swiftest_stream(f, param): cbid : int array ID of central body (always returns 0) cvec : float array - (npl,1) - vector of quantities for the massive body (Mass, Radius, J2, J4, etc) + (npl,1) - vector of quantities for the massive body (GMass, Radius, J2, J4, etc) npl : int Number of massive bodies plid : int array IDs of massive bodies pvec : float array - (npl,N) - vector of N quantities or each particle (6 of XV/EL + Mass, Radius, etc) + (npl,N) - vector of N quantities or each particle (6 of XV/EL + GMass, Radius, etc) plab : string list Labels for the pvec data ntp : int @@ -470,8 +478,7 @@ def swiftest_stream(f, param): npl = f.read_ints() ntp = f.read_ints() iout_form = f.read_reals('c') - #cbid = f.read_ints() - cbid = np.array([0]) + cbid = f.read_ints() Mcb = f.read_reals(np.float64) Rcb = f.read_reals(np.float64) J2cb = f.read_reals(np.float64) @@ -495,9 +502,9 @@ def swiftest_stream(f, param): p5 = f.read_reals(np.float64) p6 = f.read_reals(np.float64) Mpl = f.read_reals(np.float64) - Rpl = f.read_reals(np.float64) if param['RHILL_PRESENT'] == 'YES': Rhill = f.read_reals(np.float64) + Rpl = f.read_reals(np.float64) if param['ROTATION'] == 'YES': Ipplx = f.read_reals(np.float64) Ipply = f.read_reals(np.float64) @@ -545,6 +552,7 @@ def swiftest_stream(f, param): npl, plid, pvec.T, plab, \ ntp, tpid, tvec.T, tlab + def swifter2xr(param): """ Converts a Swifter binary data file into an xarray DataSet. @@ -587,6 +595,7 @@ def swifter2xr(param): print(f"Successfully converted {ds.sizes['time']} output frames.") return ds + def swiftest2xr(param): """ Converts a Swiftest binary data file into an xarray DataSet. @@ -605,26 +614,29 @@ def swiftest2xr(param): cb = [] pl = [] tp = [] - with FortranFile(param['BIN_OUT'], 'r') as f: - for t, cbid, cvec, clab, \ - npl, plid, pvec, plab, \ - ntp, tpid, tvec, tlab in swiftest_stream(f, param): - # Prepare frames by adding an extra axis for the time coordinate - cbframe = np.expand_dims(cvec, axis=0) - plframe = np.expand_dims(pvec, axis=0) - tpframe = np.expand_dims(tvec, axis=0) + try: + with FortranFile(param['BIN_OUT'], 'r') as f: + for t, cbid, cvec, clab, \ + npl, plid, pvec, plab, \ + ntp, tpid, tvec, tlab in swiftest_stream(f, param): + # Prepare frames by adding an extra axis for the time coordinate + cbframe = np.expand_dims(cvec, axis=0) + plframe = np.expand_dims(pvec, axis=0) + tpframe = np.expand_dims(tvec, axis=0) + + # Create xarray DataArrays out of each body type + cbxr = xr.DataArray(cbframe, dims=dims, coords={'time': t, 'id': cbid, 'vec': clab}) + plxr = xr.DataArray(plframe, dims=dims, coords={'time': t, 'id': plid, 'vec': plab}) + tpxr = xr.DataArray(tpframe, dims=dims, coords={'time': t, 'id': tpid, 'vec': tlab}) + + cb.append(cbxr) + pl.append(plxr) + tp.append(tpxr) + sys.stdout.write('\r' + f"Reading in time {t[0]:.3e}") + sys.stdout.flush() + except IOError: + print(f"Error encountered reading in {param['BIN_OUT']}") - # Create xarray DataArrays out of each body type - cbxr = xr.DataArray(cbframe, dims=dims, coords={'time': t, 'id': cbid, 'vec': clab}) - plxr = xr.DataArray(plframe, dims=dims, coords={'time': t, 'id': plid, 'vec': plab}) - tpxr = xr.DataArray(tpframe, dims=dims, coords={'time': t, 'id': tpid, 'vec': tlab}) - - cb.append(cbxr) - pl.append(plxr) - tp.append(tpxr) - sys.stdout.write('\r' + f"Reading in time {t[0]:.3e}") - sys.stdout.flush() - cbda = xr.concat(cb, dim='time') plda = xr.concat(pl, dim='time') tpda = xr.concat(tp, dim='time') @@ -635,8 +647,75 @@ def swiftest2xr(param): print('\nCreating Dataset') ds = xr.combine_by_coords([cbds, plds, tpds]) print(f"Successfully converted {ds.sizes['time']} output frames.") + if param['PARTICLE_OUT'] != "": + ds = swiftest_particle_2xr(ds, param) + return ds + +def swiftest_particle_stream(f): + """ + Reads in a Swiftest particle.dat file and returns a single frame of particle data as a datastream + + Parameters + ---------- + f : file object + param : dict + + Yields + ------- + plid : int + ID of massive bodie + origin_type : string + The origin type for the body (Initial conditions, disruption, supercatastrophic, hit and run, etc) + origin_xh : float array + The origin heliocentric position vector + origin_vh : float array + The origin heliocentric velocity vector + """ + while True: # Loop until you read the end of file + try: + # Read multi-line header + plid = f.read_ints() # Try first part of the header + except: + break + origin_rec = f.read_record(np.dtype('a32'), np.dtype((' 0, drop=True) - pl = pl.where(np.invert(np.isnan(pl['Mass'])), drop=True).drop_vars(['J_2', 'J_4']) - tp = frame.where(np.isnan(frame['Mass']), drop=True).drop_vars(['Mass', 'Radius', 'J_2', 'J_4']) + pl = pl.where(np.invert(np.isnan(pl['GMass'])), drop=True).drop_vars(['J_2', 'J_4']) + tp = frame.where(np.isnan(frame['GMass']), drop=True).drop_vars(['GMass', 'Radius', 'J_2', 'J_4']) - GMSun = np.double(cb['Mass']) + GMSun = np.double(cb['GMass']) RSun = np.double(cb['Radius']) J2 = np.double(cb['J_2']) J4 = np.double(cb['J_4']) @@ -681,9 +760,9 @@ def swiftest_xr2infile(ds, param, framenum=-1): for i in pl.id: pli = pl.sel(id=i) if param['RHILL_PRESENT'] == 'YES': - print(i.values, pli['Mass'].values, pli['Rhill'].values, file=plfile) + print(i.values, pli['GMass'].values, pli['Rhill'].values, file=plfile) else: - print(i.values, pli['Mass'].values, file=plfile) + print(i.values, pli['GMass'].values, file=plfile) print(pli['Radius'].values, file=plfile) print(pli['px'].values, pli['py'].values, pli['pz'].values, file=plfile) print(pli['vx'].values, pli['vy'].values, pli['vz'].values, file=plfile) @@ -717,7 +796,7 @@ def swiftest_xr2infile(ds, param, framenum=-1): vx = pl['vx'].values vy = pl['vy'].values vz = pl['vz'].values - mass = pl['Mass'].values + Gmass = pl['GMass'].values radius = pl['Radius'].values plfile.write_record(npl) @@ -728,7 +807,7 @@ def swiftest_xr2infile(ds, param, framenum=-1): plfile.write_record(vx) plfile.write_record(vy) plfile.write_record(vz) - plfile.write_record(mass) + plfile.write_record(Gmass) if param['RHILL_PRESENT'] == 'YES': rhill = pl['Rhill'].values plfile.write_record(rhill) @@ -775,28 +854,27 @@ def swifter_xr2infile(ds, param, framenum=-1): frame = ds.isel(time=framenum) cb = frame.where(frame.id == 0, drop=True) pl = frame.where(frame.id > 0, drop=True) - pl = pl.where(np.invert(np.isnan(pl['Mass'])), drop=True).drop_vars(['J_2', 'J_4']) - tp = frame.where(np.isnan(frame['Mass']), drop=True).drop_vars(['Mass', 'Radius', 'J_2', 'J_4']) + pl = pl.where(np.invert(np.isnan(pl['GMass'])), drop=True).drop_vars(['J_2', 'J_4']) + tp = frame.where(np.isnan(frame['GMass']), drop=True).drop_vars(['GMass', 'Radius', 'J_2', 'J_4']) - GMSun = np.double(cb['Mass']) + GMSun = np.double(cb['GMass']) RSun = np.double(cb['Radius']) param['J2'] = np.double(cb['J_2']) param['J4'] = np.double(cb['J_4']) - param['RHILL_PRESENT'] = "YES" if param['IN_TYPE'] == 'ASCII': # Swiftest Central body file plfile = open(param['PL_IN'], 'w') print(pl.id.count().values + 1, file=plfile) - print(cb.id.values[0], cb['Mass'].values[0], file=plfile) + print(cb.id.values[0], cb['GMass'].values[0], file=plfile) print('0.0 0.0 0.0', file=plfile) print('0.0 0.0 0.0', file=plfile) for i in pl.id: pli = pl.sel(id=i) if param['RHILL_PRESENT'] == "YES": - print(i.values, pli['Mass'].values, pli['Rhill'].values, file=plfile) + print(i.values, pli['GMass'].values, pli['Rhill'].values, file=plfile) else: - print(i.values, pli['Mass'].values, file=plfile) + print(i.values, pli['GMass'].values, file=plfile) if param['CHK_CLOSE'] == "YES": print(pli['Radius'].values, file=plfile) print(pli['px'].values, pli['py'].values, pli['pz'].values, file=plfile) @@ -902,7 +980,7 @@ def swift2swifter(swift_param, plname="", tpname="", conversion_questions={}): intxt = conversion_questions.get('BIG_DISCARD', None) if not intxt: - intxt = input("BIG_DISCARD: include data for all bodies > MTINY for each discard record? (y/N)> ") + intxt = input("BIG_DISCARD: include data for all bodies > GMTINY for each discard record? (y/N)> ") if intxt.upper() == 'Y': swifter_param['BIG_DISCARD'] = 'YES' else: @@ -1217,11 +1295,11 @@ def swifter2swiftest(swifter_param, plname="", tpname="", cbname="", conversion_ print(f"Cannot write to file {swiftest_param['CB_IN']}") return swifter_param - MTINY = conversion_questions.get('MTINY', None) - if not MTINY: - MTINY = input(f"Value of MTINY if this is a SyMBA simulation (enter nothing if this is not a SyMBA parameter file)> ") - if MTINY != '' and real2float(MTINY.strip()) > 0: - swiftest_param['MTINY'] = real2float(MTINY.strip()) + GMTINY = conversion_questions.get('GMTINY', None) + if not GMTINY: + GMTINY = input(f"Value of GMTINY if this is a SyMBA simulation (enter nothing if this is not a SyMBA parameter file)> ") + if GMTINY != '' and real2float(GMTINY.strip()) > 0: + swiftest_param['GMTINY'] = real2float(GMTINY.strip()) # Remove the unneeded parameters if 'C' in swiftest_param: @@ -1229,7 +1307,6 @@ def swifter2swiftest(swifter_param, plname="", tpname="", cbname="", conversion_ swiftest_param.pop('C', None) swiftest_param.pop('J2', None) swiftest_param.pop('J4', None) - swiftest_param.pop('RHILL_PRESENT', None) swiftest_param['DISCARD_OUT'] = conversion_questions.get('DISCARD_OUT', '') if not swiftest_param['DISCARD_OUT']: @@ -1237,6 +1314,10 @@ def swifter2swiftest(swifter_param, plname="", tpname="", cbname="", conversion_ if swiftest_param['DISCARD_OUT'] == '': swiftest_param['DISCARD_OUT'] = "discard.out" + swiftest_param['PARTICLE_OUT'] = conversion_questions.get('PARTICLE_OUT', '') + if not swiftest_param['PARTICLE_OUT']: + swiftest_param['PARTICLE_OUT'] = input("PARTICLE_OUT: Particle info file name (Only used by SyMBA): []> ") + swiftest_param['! VERSION'] = "Swiftest parameter file converted from Swifter" return swiftest_param @@ -1268,7 +1349,8 @@ def swift2swiftest(swift_param, plname="", tpname="", cbname="", conversion_ques def swiftest2swifter_param(swiftest_param, J2=0.0, J4=0.0): swifter_param = swiftest_param CBIN = swifter_param.pop("CB_IN", None) - MTINY = swifter_param.pop("MTINY", None) + GMTINY = swifter_param.pop("GMTINY", None) + DISCARD_OUT = swifter_param.pop("DISCARD_OUT", None) MU2KG = swifter_param.pop("MU2KG", 1.0) DU2M = swifter_param.pop("DU2M", 1.0) TU2S = swifter_param.pop("TU2S", 1.0) @@ -1280,7 +1362,6 @@ def swiftest2swifter_param(swiftest_param, J2=0.0, J4=0.0): tmp = swifter_param.pop(key, None) swifter_param['J2'] = J2 swifter_param['J4'] = J4 - swifter_param['CHK_CLOSE'] = "YES" if swifter_param['OUT_STAT'] == "REPLACE": swifter_param['OUT_STAT'] = "UNKNOWN" swifter_param['! VERSION'] = "Swifter parameter file converted from Swiftest" diff --git a/python/swiftest/swiftest/simulation_class.py b/python/swiftest/swiftest/simulation_class.py index 670b72a60..fc5075ab9 100644 --- a/python/swiftest/swiftest/simulation_class.py +++ b/python/swiftest/swiftest/simulation_class.py @@ -37,6 +37,8 @@ def __init__(self, codename="Swiftest", param_file=""): 'TU2S': constants.JD2S, 'DU2M': constants.AU2M, 'EXTRA_FORCE': "NO", + 'DISCARD_OUT': "discard.out", + 'PARTICLE_OUT' : "", 'BIG_DISCARD': "NO", 'CHK_CLOSE': "YES", 'RHILL_PRESENT': "YES", @@ -45,15 +47,13 @@ def __init__(self, codename="Swiftest", param_file=""): 'TIDES': "NO", 'ENERGY': "NO", 'GR': "NO", - 'YARKOVSKY': "NO", - 'YORP': "NO", - 'MTINY' : "0.0" } self.codename = codename if param_file != "" : self.read_param(param_file, codename) return + def add(self, plname, date=date.today().isoformat(), idval=None): """ Adds a solar system body to an existing simulation DataSet. @@ -71,6 +71,7 @@ def add(self, plname, date=date.today().isoformat(), idval=None): self.ds = init_cond.solar_system_horizons(plname, idval, self.param, date, self.ds) return + def read_param(self, param_file, codename="Swiftest"): if codename == "Swiftest": self.param = io.read_swiftest_param(param_file, self.param) @@ -86,6 +87,7 @@ def read_param(self, param_file, codename="Swiftest"): self.codename = "Unknown" return + def write_param(self, param_file, param=None): if param is None: param = self.param @@ -99,6 +101,7 @@ def write_param(self, param_file, param=None): print('Cannot process unknown code type. Call the read_param method with a valid code name. Valid options are "Swiftest", "Swifter", or "Swift".') return + def convert(self, param_file, newcodename="Swiftest", plname="pl.swiftest.in", tpname="tp.swiftest.in", cbname="cb.swiftest.in", conversion_questions={}): """ Converts simulation input files from one code type to another (Swift, Swifter, or Swiftest). Returns the old parameter configuration. @@ -132,6 +135,7 @@ def convert(self, param_file, newcodename="Swiftest", plname="pl.swiftest.in", t print(f"Conversion from {self.codename} to {newcodename} is not supported.") return oldparam + def bin2xr(self): if self.codename == "Swiftest": self.ds = io.swiftest2xr(self.param) @@ -145,6 +149,7 @@ def bin2xr(self): print('Cannot process unknown code type. Call the read_param method with a valid code name. Valid options are "Swiftest", "Swifter", or "Swift".') return + def follow(self, codestyle="Swifter"): if self.ds is None: self.bin2xr() @@ -165,10 +170,13 @@ def follow(self, codestyle="Swifter"): ifol = None nskp = None fol = tool.follow_swift(self.ds, ifol=ifol, nskp=nskp) + else: + fol = None print('follow.out written') return fol + def save(self, param_file, framenum=-1, codename="Swiftest"): if codename == "Swiftest": io.swiftest_xr2infile(self.ds, self.param, framenum) diff --git a/python/swiftest/swiftest/tool.py b/python/swiftest/swiftest/tool.py index 741dc0f1b..a96610bc2 100644 --- a/python/swiftest/swiftest/tool.py +++ b/python/swiftest/swiftest/tool.py @@ -2,15 +2,17 @@ import numpy as np import os import glob -from pyslalib import slalib import xarray as xr """ Functions that recreate the Swift/Swifter tool programs """ -def sla_dranrm(angle): - func = np.vectorize(slalib.sla_dranrm) - return xr.apply_ufunc(func, angle) +def wrap_angle(angle): + while np.any(angle >= 2 * np.pi): + angle[angle >= 2 * np.pi] -= 2 * np.pi + while np.any(angle < 0.0): + angle[angle < 0.0] += 2 * np.pi + return angle def follow_swift(ds, ifol=None, nskp=None): """ @@ -36,11 +38,11 @@ def follow_swift(ds, ifol=None, nskp=None): ifol = int(intxt) print(f"Following particle {ifol}") if ifol < 0: # Negative numbers are planets - fol = ds.where(np.invert(np.isnan(ds['Mass'])), drop=True) + fol = ds.where(np.invert(np.isnan(ds['GMass'])), drop=True) fol = fol.where(np.invert(np.isnan(fol['a'])), drop=True) # Remove times where this body doesn't exist (but this also gets rid of the central body) fol = fol.isel(id = -ifol - 2) # Take 1 off for 0-indexed arrays in Python, and take 1 more off because the central body is gone elif ifol > 0: # Positive numbers are test particles - fol = ds.where(np.isnan(ds['Mass']), drop=True).drop_vars(['Mass', 'Radius']) + fol = ds.where(np.isnan(ds['GMass']), drop=True).drop_vars(['GMass', 'Radius']) fol = fol.where(np.invert(np.isnan(fol['a'])), drop=True) fol = fol.isel(id = ifol - 1) # Take 1 off for 0-indexed arrays in Python @@ -51,7 +53,7 @@ def follow_swift(ds, ifol=None, nskp=None): dr = 180.0 / np.pi fol['obar'] = fol['capom'] + fol['omega'] fol['obar'] = fol['obar'].fillna(0) - fol['obar'] = sla_dranrm(fol['obar']) + fol['obar'] = wrap_angle(fol['obar']) fol['obar'] = fol['obar'] * dr fol['inc'] = fol['inc'] * dr fol['capom'] = fol['capom'] * dr diff --git a/src/discard/discard.f90 b/src/discard/discard.f90 index be377e49e..9c8044c61 100644 --- a/src/discard/discard.f90 +++ b/src/discard/discard.f90 @@ -12,15 +12,29 @@ module subroutine discard_system(self, param) class(swiftest_nbody_system), intent(inout) :: self !! Swiftest system object class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters ! Internals - logical :: lany_discards + logical :: lany_discards, lpl_discards, ltp_discards, lpl_check, ltp_check - associate(system => self, tp => self%tp, pl => self%pl) - lany_discards = .false. - call pl%discard(system, param) - call tp%discard(system, param) - if (tp%nbody > 0) lany_discards = lany_discards .or. any(tp%ldiscard(:)) - if (pl%nbody > 0) lany_discards = lany_discards .or. any(pl%ldiscard(:)) - if (lany_discards) call system%write_discard(param) + lpl_check = allocated(self%pl_discards) + ltp_check = allocated(self%tp_discards) + + associate(system => self, tp => self%tp, pl => self%pl, tp_discards => self%tp_discards, pl_discards => self%pl_discards) + lpl_discards = .false. + ltp_discards = .false. + if (lpl_check) then + call pl%discard(system, param) + lpl_discards = (pl_discards%nbody > 0) + end if + + if (ltp_check) then + call tp%discard(system, param) + ltp_discards = (tp_discards%nbody > 0) + end if + + if (lpl_discards .or. ltp_discards) call system%write_discard(param) + if (lpl_discards .and. param%lenergy) call self%conservation_report(param, lterminal=.true.) + if (lpl_check) call pl_discards%setup(0,param) + if (ltp_check) call tp_discards%setup(0,param) + end associate return @@ -57,6 +71,8 @@ module subroutine discard_tp(self, system, param) class(swiftest_tp), intent(inout) :: self !! Swiftest test particle object class(swiftest_nbody_system), intent(inout) :: system !! Swiftest nbody system object class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameter + ! Internals + logical, dimension(:), allocatable :: ldiscard associate(tp => self, ntp => self%nbody, cb => system%cb, pl => system%pl, npl => system%pl%nbody) if ((ntp == 0) .or. (npl ==0)) return @@ -70,7 +86,10 @@ module subroutine discard_tp(self, system, param) if ((param%rmin >= 0.0_DP) .or. (param%rmax >= 0.0_DP) .or. (param%rmaxu >= 0.0_DP)) call discard_cb_tp(tp, system, param) if (param%qmin >= 0.0_DP) call discard_peri_tp(tp, system, param) if (param%lclose) call discard_pl_tp(tp, system, param) - if (any(tp%ldiscard)) call tp%spill(system%tp_discards, tp%ldiscard, ldestructive=.true.) + if (any(tp%ldiscard)) then + allocate(ldiscard, source=tp%ldiscard) + call tp%spill(system%tp_discards, ldiscard, ldestructive=.true.) + end if end associate return diff --git a/src/fragmentation/fragmentation.f90 b/src/fragmentation/fragmentation.f90 index 460060183..73cef6240 100644 --- a/src/fragmentation/fragmentation.f90 +++ b/src/fragmentation/fragmentation.f90 @@ -10,22 +10,22 @@ module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, use, intrinsic :: ieee_exceptions implicit none ! Arguments - class(swiftest_nbody_system), intent(inout) :: system - class(swiftest_parameters), intent(in) :: param - integer(I4B), dimension(:), intent(in) :: family - real(DP), dimension(:,:), intent(inout) :: x, v, L_spin, Ip - real(DP), dimension(:), intent(inout) :: mass, radius - integer(I4B), intent(inout) :: nfrag - real(DP), dimension(:), allocatable, intent(inout) :: m_frag, rad_frag - real(DP), dimension(:,:), allocatable, intent(inout) :: Ip_frag - real(DP), dimension(:,:), allocatable, intent(inout) :: xb_frag, vb_frag, rot_frag - logical, intent(out) :: lfailure ! Answers the question: Should this have been a merger instead? - real(DP), intent(inout) :: Qloss + class(swiftest_nbody_system), intent(inout) :: system !! Swiftest nbody system object + class(swiftest_parameters), intent(in) :: param !! Current run configuration parameters + integer(I4B), dimension(:), intent(in) :: family !! Index of bodies involved in the collision + real(DP), dimension(:,:), intent(inout) :: x, v, L_spin, Ip !! Two-body equivalent position, vector, spin momentum, and rotational inertia values for the collision + real(DP), dimension(:), intent(inout) :: mass, radius !! Two-body equivalent mass and radii for the bodies in the collision + integer(I4B), intent(inout) :: nfrag !! Number of fragments to generate + real(DP), dimension(:), allocatable, intent(inout) :: m_frag, rad_frag !! Distribution of fragment mass and radii + real(DP), dimension(:,:), allocatable, intent(inout) :: Ip_frag !! Fragment rotational inertia vectors + real(DP), dimension(:,:), allocatable, intent(inout) :: xb_frag, vb_frag, rot_frag !! Fragment barycentric position, barycentric velocity, and rotation vectors + real(DP), intent(inout) :: Qloss !! Energy lost during the collision + logical, intent(out) :: lfailure !! Answers the question: Should this have been a merger instead? ! Internals - real(DP) :: mscale, rscale, vscale, tscale, Lscale, Escale ! Scale factors that reduce quantities to O(~1) in the collisional system + real(DP) :: mscale, dscale, vscale, tscale, Lscale, Escale ! Scale factors that reduce quantities to O(~1) in the collisional system real(DP) :: mtot real(DP), dimension(NDIM) :: xcom, vcom - integer(I4B) :: ii + integer(I4B) :: ii, npl_new logical, dimension(:), allocatable :: lexclude real(DP), dimension(NDIM, 2) :: rot, L_orb real(DP), dimension(:,:), allocatable :: x_frag, v_frag, v_r_unit, v_t_unit, v_h_unit @@ -42,10 +42,12 @@ module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, integer(I4B), parameter :: NFRAG_MIN = 7 !! The minimum allowable number of fragments (set to 6 because that's how many unknowns are needed in the tangential velocity calculation) real(DP) :: r_max_start, r_max_start_old, r_max, f_spin real(DP), parameter :: Ltol = 10 * epsilon(1.0_DP) - real(DP), parameter :: Etol = 1e-10_DP + real(DP), parameter :: Etol = 1e-9_DP integer(I4B), parameter :: MAXTRY = 3000 integer(I4B), parameter :: TANTRY = 3 logical, dimension(size(IEEE_ALL)) :: fpe_halting_modes, fpe_quiet_modes + class(swiftest_nbody_system), allocatable :: tmpsys + class(swiftest_parameters), allocatable :: tmpparam if (nfrag < NFRAG_MIN) then write(*,*) "symba_frag_pos needs at least ",NFRAG_MIN," fragments, but only ",nfrag," were given." @@ -58,29 +60,24 @@ module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, call ieee_set_halting_mode(IEEE_ALL,fpe_quiet_modes) f_spin = 0.05_DP - mscale = 1.0_DP - rscale = 1.0_DP - vscale = 1.0_DP - tscale = 1.0_DP - Lscale = 1.0_DP - Escale = 1.0_DP - - associate(npl => system%pl%nbody, status => system%pl%status) - allocate(lexclude(npl)) - where (status(1:npl) == INACTIVE) ! Safety check in case one of the included bodies has been previously deactivated - lexclude(1:npl) = .true. - elsewhere - lexclude(1:npl) = .false. - end where - end associate allocate(x_frag, source=xb_frag) allocate(v_frag, source=vb_frag) + associate(pl => system%pl, npl => system%pl%nbody) + npl_new = npl + nfrag + allocate(lexclude(npl_new)) + lexclude(1:npl) = pl%status(1:npl) == INACTIVE + lexclude(npl+1:npl_new) = .true. + end associate + call set_scale_factors() call define_coordinate_system() + call construct_temporary_system() + + ! Calculate the initial energy of the system without the collisional family call calculate_system_energy(linclude_fragments=.false.) - + r_max_start = norm2(x(:,2) - x(:,1)) try = 1 lfailure = .false. @@ -91,7 +88,15 @@ module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, ke_avg_deficit = 0.0_DP subtry = 1 do + ! Initialize the fragments with 0 velocity and spin so we can divide up the balance between the tangential, radial, and spin components while conserving momentum + xb_frag(:,:) = 0.0_DP + vb_frag(:,:) = 0.0_DP + rot_frag(:,:) = 0.0_DP + v_t_mag(:) = 0.0_DP + v_r_mag(:) = 0.0_DP call set_fragment_position_vectors() + call calculate_system_energy(linclude_fragments=.true.) + ke_frag_budget = -dEtot - Qloss call set_fragment_tan_vel(lfailure) ke_avg_deficit = ke_avg_deficit - ke_radial subtry = subtry + 1 @@ -99,21 +104,23 @@ module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, !write(*,*) 'Trying new arrangement' end do ke_avg_deficit = ke_avg_deficit / subtry - if (lfailure) write(*,*) 'Failed to find tangential velocities' + !if (lfailure) write(*,*) 'Failed to find tangential velocities' if (.not.lfailure) then + call calculate_system_energy(linclude_fragments=.true.) + ke_radial = -dEtot - Qloss call set_fragment_radial_velocities(lfailure) - if (lfailure) write(*,*) 'Failed to find radial velocities' + ! if (lfailure) write(*,*) 'Failed to find radial velocities' if (.not.lfailure) then call calculate_system_energy(linclude_fragments=.true.) - !write(*,*) 'Qloss : ',Qloss - !write(*,*) '-dEtot: ',-dEtot - !write(*,*) 'delta : ',abs((dEtot + Qloss)) + ! write(*,*) 'Qloss : ',Qloss + ! write(*,*) '-dEtot: ',-dEtot + ! write(*,*) 'delta : ',abs((dEtot + Qloss)) if ((abs(dEtot + Qloss) > Etol) .or. (dEtot > 0.0_DP)) then - write(*,*) 'Failed due to high energy error: ',dEtot, abs(dEtot + Qloss) / Etol + !write(*,*) 'Failed due to high energy error: ',dEtot, abs(dEtot + Qloss) / Etol lfailure = .true. else if (abs(dLmag) / Lmag_before > Ltol) then - write(*,*) 'Failed due to high angular momentum error: ', dLmag / Lmag_before + !write(*,*) 'Failed due to high angular momentum error: ', dLmag / Lmag_before lfailure = .true. end if end if @@ -123,717 +130,774 @@ module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, call restructure_failed_fragments() try = try + 1 end do - write(*, "(' -------------------------------------------------------------------------------------')") - write(*, "(' Final diagnostic')") - write(*, "(' -------------------------------------------------------------------------------------')") - if (lfailure) then - write(*,*) "symba_frag_pos failed after: ",try," tries" - do ii = 1, nfrag - vb_frag(:, ii) = vcom(:) - end do - else - write(*,*) "symba_frag_pos succeeded after: ",try," tries" - write(*, "(' dL_tot should be very small' )") - write(*,fmtlabel) ' dL_tot |', dLmag / Lmag_before - write(*, "(' dE_tot should be negative and equal to Qloss' )") - write(*,fmtlabel) ' dE_tot |', dEtot / abs(Etot_before) - write(*,fmtlabel) ' Qloss |', -Qloss / abs(Etot_before) - write(*,fmtlabel) ' dE - Qloss |', (Etot_after - Etot_before + Qloss) / abs(Etot_before) - end if - write(*, "(' -------------------------------------------------------------------------------------')") - call restore_scale_factors() + call calculate_system_energy(linclude_fragments=.true.) + + ! write(*, "(' -------------------------------------------------------------------------------------')") + ! write(*, "(' Final diagnostic')") + ! write(*, "(' -------------------------------------------------------------------------------------')") + ! if (lfailure) then + ! write(*,*) "symba_frag_pos failed after: ",try," tries" + ! do ii = 1, nfrag + ! vb_frag(:, ii) = vcom(:) + ! end do + ! else + ! write(*,*) "symba_frag_pos succeeded after: ",try," tries" + ! write(*, "(' dL_tot should be very small' )") + ! write(*,fmtlabel) ' dL_tot |', dLmag / Lmag_before + ! write(*, "(' dE_tot should be negative and equal to Qloss' )") + ! write(*,fmtlabel) ' dE_tot |', dEtot / abs(Etot_before) + ! write(*,fmtlabel) ' Qloss |', -Qloss / abs(Etot_before) + ! write(*,fmtlabel) ' dE - Qloss |', (Etot_after - Etot_before + Qloss) / abs(Etot_before) + ! end if + ! write(*, "(' -------------------------------------------------------------------------------------')") + call ieee_set_halting_mode(IEEE_ALL,fpe_halting_modes) ! Save the current halting modes so we can turn them off temporarily return contains - ! Because of the complexity of this procedure, we have chosen to break it up into a series of nested subroutines. - - subroutine set_scale_factors() - !! author: David A. Minton - !! - !! Scales dimenional quantities to ~O(1) with respect to the collisional system. This scaling makes it easier for the non-linear minimization - !! to converge on a solution - implicit none - integer(I4B) :: i - - ! Find the center of mass of the collisional system - mtot = sum(mass(:)) - xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot - vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot - - ! Set scale factors - !! Because of the implied G, mass is actually G*mass with units of distance**3 / time**2 - Escale = 0.5_DP * (mass(1) * dot_product(v(:,1), v(:,1)) + mass(2) * dot_product(v(:,2), v(:,2))) - rscale = sum(radius(:)) - mscale = sqrt(Escale * rscale) - vscale = sqrt(Escale / mscale) - tscale = rscale / vscale - Lscale = mscale * rscale * vscale - - xcom(:) = xcom(:) / rscale - vcom(:) = vcom(:) / vscale - - mtot = mtot / mscale - mass = mass / mscale - radius = radius / rscale - x = x / rscale - v = v / vscale - L_spin = L_spin / Lscale - do i = 1, 2 - rot(:,i) = L_spin(:,i) / (mass(i) * radius(i)**2 * Ip(3, i)) - end do + ! Because of the complexity of this procedure, we have chosen to break it up into a series of nested subroutines. + subroutine set_scale_factors() + !! author: David A. Minton + !! + !! Scales dimenional quantities to ~O(1) with respect to the collisional system. This scaling makes it easier for the non-linear minimization + !! to converge on a solution + implicit none + integer(I4B) :: i + + ! Find the center of mass of the collisional system + mtot = sum(mass(:)) + xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot + vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot + + ! Set scale factors + dscale = sum(radius(:)) + mscale = mtot + vscale = (mass(1) * norm2(v(:,1) - vcom(:)) + mass(2) * norm2(v(:,2) - vcom(:))) / mtot + tscale = dscale / vscale + Lscale = mscale * dscale * vscale + Escale = mscale * vscale**2 + + xcom(:) = xcom(:) / dscale + vcom(:) = vcom(:) / vscale + + mtot = mtot / mscale + mass = mass / mscale + radius = radius / dscale + x = x / dscale + v = v / vscale + L_spin = L_spin / Lscale + do i = 1, 2 + rot(:,i) = L_spin(:,i) / (mass(i) * radius(i)**2 * Ip(3, i)) + end do - m_frag = m_frag / mscale - rad_frag = rad_frag / rscale - Qloss = Qloss / Escale + m_frag = m_frag / mscale + rad_frag = rad_frag / dscale + Qloss = Qloss / Escale - return - end subroutine set_scale_factors - - subroutine restore_scale_factors() - !! author: David A. Minton - !! - !! Restores dimenional quantities back to the system units - implicit none - integer(I4B) :: i - - call ieee_set_halting_mode(IEEE_ALL,.false.) - ! Restore scale factors - xcom(:) = xcom(:) * rscale - vcom(:) = vcom(:) * vscale - - mtot = mtot * mscale - mass = mass * mscale - radius = radius * rscale - x = x * rscale - v = v * vscale - L_spin = L_spin * Lscale - do i = 1, 2 - rot(:,i) = L_spin(:,i) * (mass(i) * radius(i)**2 * Ip(3, i)) - end do + return + end subroutine set_scale_factors - m_frag = m_frag * mscale - rad_frag = rad_frag * rscale - rot_frag = rot_frag / tscale - x_frag = x_frag * rscale - v_frag = v_frag * vscale - Qloss = Qloss * Escale - do i = 1, nfrag - xb_frag(:, i) = x_frag(:, i) + xcom(:) - vb_frag(:, i) = v_frag(:, i) + vcom(:) - end do + subroutine restore_scale_factors() + !! author: David A. Minton + !! + !! Restores dimenional quantities back to the system units + implicit none + integer(I4B) :: i + + call ieee_set_halting_mode(IEEE_ALL,.false.) + ! Restore scale factors + xcom(:) = xcom(:) * dscale + vcom(:) = vcom(:) * vscale + + mtot = mtot * mscale + mass = mass * mscale + radius = radius * dscale + x = x * dscale + v = v * vscale + L_spin = L_spin * Lscale + do i = 1, 2 + rot(:,i) = L_spin(:,i) * (mass(i) * radius(i)**2 * Ip(3, i)) + end do - Etot_before = Etot_before * Escale - pe_before = pe_before * Escale - ke_spin_before = ke_spin_before * Escale - ke_orbit_before = ke_orbit_before * Escale - Ltot_before = Ltot_before * Lscale - Lmag_before = Lmag_before * Lscale - Etot_after = Etot_after * Escale - pe_after = pe_after * Escale - ke_spin_after = ke_spin_after * Escale - ke_orbit_after = ke_orbit_after * Escale - Ltot_after = Ltot_after * Lscale - Lmag_after = Lmag_after * Lscale - - mscale = 1.0_DP - rscale = 1.0_DP - vscale = 1.0_DP - tscale = 1.0_DP - Lscale = 1.0_DP - Escale = 1.0_DP + m_frag = m_frag * mscale + rad_frag = rad_frag * dscale + rot_frag = rot_frag / tscale + x_frag = x_frag * dscale + v_frag = v_frag * vscale + Qloss = Qloss * Escale - return - end subroutine restore_scale_factors - - subroutine define_coordinate_system() - !! author: David A. Minton - !! - !! Defines the collisional coordinate system, including the unit vectors of both the system and individual fragments. - implicit none - integer(I4B) :: i - real(DP), dimension(NDIM) :: x_cross_v, xc, vc, delta_r, delta_v - real(DP) :: r_col_norm, v_col_norm - - allocate(rmag(nfrag)) - allocate(rotmag(nfrag)) - allocate(v_r_mag(nfrag)) - allocate(v_t_mag(nfrag)) - allocate(v_r_unit(NDIM,nfrag)) - allocate(v_t_unit(NDIM,nfrag)) - allocate(v_h_unit(NDIM,nfrag)) - - rmag(:) = 0.0_DP - rotmag(:) = 0.0_DP - v_r_mag(:) = 0.0_DP - v_t_mag(:) = 0.0_DP - v_r_unit(:,:) = 0.0_DP - v_t_unit(:,:) = 0.0_DP - v_h_unit(:,:) = 0.0_DP - - L_orb(:, :) = 0.0_DP - ! Compute orbital angular momentum of pre-impact system - do i = 1, 2 - xc(:) = x(:, i) - xcom(:) - vc(:) = v(:, i) - vcom(:) - x_cross_v(:) = xc(:) .cross. vc(:) - L_orb(:, i) = mass(i) * x_cross_v(:) - end do + do i = 1, nfrag + xb_frag(:, i) = x_frag(:, i) + xcom(:) + vb_frag(:, i) = v_frag(:, i) + vcom(:) + end do - ! Compute orbital angular momentum of pre-impact system. This will be the normal vector to the collision fragment plane - L_frag_tot(:) = L_spin(:, 1) + L_spin(:, 2) + L_orb(:, 1) + L_orb(:, 2) + Etot_before = Etot_before * Escale + pe_before = pe_before * Escale + ke_spin_before = ke_spin_before * Escale + ke_orbit_before = ke_orbit_before * Escale + Ltot_before = Ltot_before * Lscale + Lmag_before = Lmag_before * Lscale + Etot_after = Etot_after * Escale + pe_after = pe_after * Escale + ke_spin_after = ke_spin_after * Escale + ke_orbit_after = ke_orbit_after * Escale + Ltot_after = Ltot_after * Lscale + Lmag_after = Lmag_after * Lscale + + dLmag = norm2(Ltot_after(:) - Ltot_before(:)) + dEtot = Etot_after - Etot_before + + call tmpsys%rescale(tmpparam, mscale**(-1), dscale**(-1), tscale**(-1)) + + mscale = 1.0_DP + dscale = 1.0_DP + vscale = 1.0_DP + tscale = 1.0_DP + Lscale = 1.0_DP + Escale = 1.0_DP + + return + end subroutine restore_scale_factors - delta_v(:) = v(:, 2) - v(:, 1) - v_col_norm = norm2(delta_v(:)) - delta_r(:) = x(:, 2) - x(:, 1) - r_col_norm = norm2(delta_r(:)) - ! We will initialize fragments on a plane defined by the pre-impact system, with the z-axis aligned with the angular momentum vector - ! and the y-axis aligned with the pre-impact distance vector. - y_col_unit(:) = delta_r(:) / r_col_norm - z_col_unit(:) = L_frag_tot(:) / norm2(L_frag_tot) - ! The cross product of the y- by z-axis will give us the x-axis - x_col_unit(:) = y_col_unit(:) .cross. z_col_unit(:) + subroutine define_coordinate_system() + !! author: David A. Minton + !! + !! Defines the collisional coordinate system, including the unit vectors of both the system and individual fragments. + implicit none + integer(I4B) :: i + real(DP), dimension(NDIM) :: x_cross_v, xc, vc, delta_r, delta_v + real(DP) :: r_col_norm, v_col_norm + + allocate(rmag(nfrag)) + allocate(rotmag(nfrag)) + allocate(v_r_mag(nfrag)) + allocate(v_t_mag(nfrag)) + allocate(v_r_unit(NDIM,nfrag)) + allocate(v_t_unit(NDIM,nfrag)) + allocate(v_h_unit(NDIM,nfrag)) + + rmag(:) = 0.0_DP + rotmag(:) = 0.0_DP + v_r_mag(:) = 0.0_DP + v_t_mag(:) = 0.0_DP + v_r_unit(:,:) = 0.0_DP + v_t_unit(:,:) = 0.0_DP + v_h_unit(:,:) = 0.0_DP + + L_orb(:, :) = 0.0_DP + ! Compute orbital angular momentum of pre-impact system + do i = 1, 2 + xc(:) = x(:, i) - xcom(:) + vc(:) = v(:, i) - vcom(:) + x_cross_v(:) = xc(:) .cross. vc(:) + L_orb(:, i) = mass(i) * x_cross_v(:) + end do + + ! Compute orbital angular momentum of pre-impact system. This will be the normal vector to the collision fragment plane + L_frag_tot(:) = L_spin(:, 1) + L_spin(:, 2) + L_orb(:, 1) + L_orb(:, 2) + + delta_v(:) = v(:, 2) - v(:, 1) + v_col_norm = norm2(delta_v(:)) + delta_r(:) = x(:, 2) - x(:, 1) + r_col_norm = norm2(delta_r(:)) + + ! We will initialize fragments on a plane defined by the pre-impact system, with the z-axis aligned with the angular momentum vector + ! and the y-axis aligned with the pre-impact distance vector. + y_col_unit(:) = delta_r(:) / r_col_norm + z_col_unit(:) = L_frag_tot(:) / norm2(L_frag_tot) + ! The cross product of the y- by z-axis will give us the x-axis + x_col_unit(:) = y_col_unit(:) .cross. z_col_unit(:) + + return + end subroutine define_coordinate_system + + + subroutine construct_temporary_system() + !! Author: David A. Minton + !! + !! Constructs a temporary internal system consisting of active bodies and additional fragments. This internal temporary system is used to calculate system energy with and without fragments + !! and optionally including fragments. + implicit none + ! Internals + logical, dimension(:), allocatable :: lexclude_tmp + + associate(pl => system%pl, npl => system%pl%nbody, cb => system%cb) + if (size(lexclude) /= npl + nfrag) then + allocate(lexclude_tmp(npl_new)) + lexclude_tmp(1:npl) = lexclude(1:npl) + call move_alloc(lexclude_tmp, lexclude) + end if + where (pl%status(1:npl) == INACTIVE) ! Safety check in case one of the included bodies has been previously deactivated + lexclude(1:npl) = .true. + elsewhere + lexclude(1:npl) = .false. + end where + lexclude(npl+1:npl_new) = .true. + if (allocated(tmpparam)) deallocate(tmpparam) + allocate(tmpparam, source=param) + call setup_construct_system(tmpsys, param) + call tmpsys%tp%setup(0, param) + deallocate(tmpsys%cb) + allocate(tmpsys%cb, source=cb) + call tmpsys%pl%setup(npl + nfrag, tmpparam) + call tmpsys%pl%fill(pl, .not.lexclude) + call tmpsys%rescale(tmpparam, mscale, dscale, tscale) + + end associate return - end subroutine define_coordinate_system - - subroutine calculate_system_energy(linclude_fragments) - !! Author: David A. Minton - !! - !! Calculates total system energy, including all bodies in the pl list that do not have a corresponding value of the lexclude array that is true - !! and optionally including fragments. - implicit none - ! Arguments - logical, intent(in) :: linclude_fragments - ! Internals - integer(I4B) :: i, npl_new, nplm - logical, dimension(:), allocatable :: ltmp - logical :: lk_plpl - class(swiftest_nbody_system), allocatable :: tmpsys - - ! Because we're making a copy of symba_pl with the excludes/fragments appended, we need to deallocate the - ! big k_plpl array and recreate it when we're done, otherwise we run the risk of blowing up the memory by - ! allocating two of these ginormous arrays simulteouously. This is not particularly efficient, but as this - ! subroutine should be called relatively infrequently, it shouldn't matter too much. - !if (allocated(pl%k_plpl)) deallocate(pl%k_plpl) - - ! Build the internal planet list out of the non-excluded bodies and optionally with fragments appended. This - ! will get passed to the energy calculation subroutine so that energy is computed exactly the same way is it - ! is in the main program. - associate(pl => system%pl, npl => system%pl%nbody, cb => system%cb) - lk_plpl = allocated(pl%k_plpl) - if (lk_plpl) deallocate(pl%k_plpl) - if (linclude_fragments) then ! Temporarily expand the planet list to feed it into symba_energy - lexclude(family(:)) = .true. - npl_new = npl + nfrag - else - npl_new = npl - end if - call setup_construct_system(tmpsys, param) - deallocate(tmpsys%cb) - allocate(tmpsys%cb, source=cb) - allocate(ltmp(npl)) - ltmp(:) = .true. - call tmpsys%pl%setup(npl_new, param) - call tmpsys%pl%fill(pl, ltmp) - deallocate(ltmp) - - if (linclude_fragments) then ! Append the fragments if they are included - ! Energy calculation requires the fragments to be in the system barcyentric frame, s + end subroutine construct_temporary_system + + + subroutine add_fragments_to_tmpsys() + !! Author: David A. Minton + !! + !! Adds fragments to the temporary system pl object + implicit none + ! Internals + integer(I4B) :: i + + associate(pl => system%pl, npl => system%pl%nbody) + tmpsys%pl%mass(npl+1:npl_new) = m_frag(1:nfrag) + tmpsys%pl%Gmass(npl+1:npl_new) = m_frag(1:nfrag) * tmpparam%GU tmpsys%pl%radius(npl+1:npl_new) = rad_frag(1:nfrag) - tmpsys%pl%xb(:,npl+1:npl_new) = xb_frag(:,1:nfrag) - tmpsys%pl%vb(:,npl+1:npl_new) = vb_frag(:,1:nfrag) - tmpsys%pl%status(npl+1:npl_new) = COLLISION - if (param%lrotation) then + do concurrent (i = 1:nfrag) + tmpsys%pl%xb(:,npl+i) = xb_frag(:,i) + tmpsys%pl%vb(:,npl+i) = vb_frag(:,i) + tmpsys%pl%xh(:,npl+i) = xb_frag(:,i) - tmpsys%cb%xb(:) + tmpsys%pl%vh(:,npl+i) = vb_frag(:,i) - tmpsys%cb%vb(:) + end do + if (tmpparam%lrotation) then tmpsys%pl%Ip(:,npl+1:npl_new) = Ip_frag(:,1:nfrag) tmpsys%pl%rot(:,npl+1:npl_new) = rot_frag(:,1:nfrag) end if - call tmpsys%pl%b2h(tmpsys%cb) - allocate(ltmp(npl_new)) - ltmp(1:npl) = lexclude(1:npl) - ltmp(npl+1:npl_new) = .false. - call move_alloc(ltmp, lexclude) - end if + ! Disable the collisional family for subsequent energy calculations and coordinate shifts + lexclude(family(:)) = .true. + lexclude(npl+1:npl_new) = .false. + where(lexclude(:)) + tmpsys%pl%status(:) = INACTIVE + elsewhere + tmpsys%pl%status(:) = ACTIVE + end where + + end associate + + return + end subroutine add_fragments_to_tmpsys + + + subroutine calculate_system_energy(linclude_fragments) + !! Author: David A. Minton + !! + !! Calculates total system energy, including all bodies in the pl list that do not have a corresponding value of the lexclude array that is true + !! and optionally including fragments. + implicit none + ! Arguments + logical, intent(in) :: linclude_fragments + ! Internals + integer(I4B) :: i, nplm + logical, dimension(:), allocatable :: lexclude_tmp + logical :: lk_plpl + + ! Because we're making a copy of symba_pl with the excludes/fragments appended, we need to deallocate the + ! big k_plpl array and recreate it when we're done, otherwise we run the risk of blowing up the memory by + ! allocating two of these ginormous arrays simulteouously. This is not particularly efficient, but as this + ! subroutine should be called relatively infrequently, it shouldn't matter too much. + + ! Build the internal planet list out of the non-excluded bodies and optionally with fragments appended. This + ! will get passed to the energy calculation subroutine so that energy is computed exactly the same way is it + ! is in the main program. This will temporarily expand the planet list in a temporary system object called tmpsys to feed it into symba_energy + associate(pl => system%pl, npl => system%pl%nbody, cb => system%cb) + + where (lexclude(1:npl_new)) + tmpsys%pl%status(1:npl_new) = INACTIVE + elsewhere + tmpsys%pl%status(1:npl_new) = ACTIVE + end where - where (lexclude(1:npl_new)) - tmpsys%pl%status(1:npl_new) = INACTIVE - end where - - select type(plwksp => tmpsys%pl) - class is (symba_pl) - select type(param) - class is (symba_parameters) - plwksp%nplm = count(plwksp%Gmass > param%mtiny / mscale) + select type(plwksp => tmpsys%pl) + class is (symba_pl) + select type(param) + class is (symba_parameters) + plwksp%nplm = count(plwksp%Gmass > param%Gmtiny / mscale) + end select end select - end select - call tmpsys%pl%eucl_index() - call tmpsys%get_energy_and_momentum(param) - - ! Restore the big array - deallocate(tmpsys%pl%k_plpl) - select type(pl) - class is (symba_pl) - select type(param) - class is (symba_parameters) - nplm = count(pl%mass > param%mtiny) + + lk_plpl = allocated(pl%k_plpl) + if (lk_plpl) deallocate(pl%k_plpl) + + call tmpsys%pl%eucl_index() + + call tmpsys%get_energy_and_momentum(param) + + ! Restore the big array + deallocate(tmpsys%pl%k_plpl) + select type(pl) + class is (symba_pl) + select type(param) + class is (symba_parameters) + pl%nplm = count(pl%Gmass > param%Gmtiny) + end select end select - end select - if (lk_plpl) call pl%eucl_index() - - ! Calculate the current fragment energy and momentum balances - if (linclude_fragments) then - Ltot_after(:) = tmpsys%Lorbit(:) + tmpsys%Lspin(:) - Lmag_after = norm2(Ltot_after(:)) - ke_orbit_after = tmpsys%ke_orbit - ke_spin_after = tmpsys%ke_spin - pe_after = tmpsys%pe - Etot_after = ke_orbit_after + ke_spin_after + pe_after - dEtot = Etot_after - Etot_before - dLmag = norm2(Ltot_after(:) - Ltot_before(:)) - else - Ltot_before(:) = tmpsys%Lorbit(:) + tmpsys%Lspin(:) - Lmag_before = norm2(Ltot_before(:)) - ke_orbit_before = tmpsys%ke_orbit - ke_spin_before = tmpsys%ke_spin - pe_before = tmpsys%pe - Etot_before = ke_orbit_before + ke_spin_before + pe_before - end if - end associate - return - end subroutine calculate_system_energy - - subroutine shift_vector_to_origin(m_frag, vec_frag) - !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton - !! - !! Adjusts the position or velocity of the fragments as needed to align them with the origin - implicit none - ! Arguments - real(DP), dimension(:), intent(in) :: m_frag !! Fragment masses - real(DP), dimension(:,:), intent(inout) :: vec_frag !! Fragment positions or velocities in the center of mass frame - - ! Internals - real(DP), dimension(NDIM) :: mvec_frag, COM_offset - integer(I4B) :: i - - mvec_frag(:) = 0.0_DP - - do i = 1, nfrag - mvec_frag = mvec_frag(:) + vec_frag(:,i) * m_frag(i) - end do - COM_offset(:) = -mvec_frag(:) / mtot - do i = 1, nfrag - vec_frag(:, i) = vec_frag(:, i) + COM_offset(:) - end do - return - end subroutine shift_vector_to_origin - - subroutine set_fragment_position_vectors() - !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton - !! - !! Initializes the orbits of the fragments around the center of mass. The fragments are initially placed on a plane defined by the - !! pre-impact angular momentum. They are distributed on an ellipse surrounding the center of mass. - !! The initial positions do not conserve energy or momentum, so these need to be adjusted later. - - implicit none - real(DP) :: dis, rad - real(DP), dimension(NDIM) :: L_sigma - logical, dimension(:), allocatable :: loverlap - integer(I4B) :: i, j - - allocate(loverlap(nfrag)) - - ! Place the fragments into a region that is big enough that we should usually not have overlapping bodies - ! An overlapping bodies will collide in the next time step, so it's not a major problem if they do (it just slows the run down) - r_max = r_max_start - rad = sum(radius(:)) - - ! We will treat the first two fragments of the list as special cases. They get initialized the maximum distances apart along the original impactor distance vector. - ! This is done because in a regular disruption, the first body is the largest, the second the second largest, and the rest are smaller equal-mass fragments. - - call random_number(x_frag(:,3:nfrag)) - loverlap(:) = .true. - do while (any(loverlap(3:nfrag))) - x_frag(:, 1) = x(:, 1) - xcom(:) - x_frag(:, 2) = x(:, 2) - xcom(:) - r_max = r_max + 0.1_DP * rad - do i = 3, nfrag - if (loverlap(i)) then - call random_number(x_frag(:,i)) - x_frag(:, i) = 2 * (x_frag(:, i) - 0.5_DP) * r_max + if (lk_plpl) call pl%eucl_index() + + ! Calculate the current fragment energy and momentum balances + if (linclude_fragments) then + Ltot_after(:) = tmpsys%Lorbit(:) + tmpsys%Lspin(:) + Lmag_after = norm2(Ltot_after(:)) + ke_orbit_after = tmpsys%ke_orbit + ke_spin_after = tmpsys%ke_spin + pe_after = tmpsys%pe + Etot_after = ke_orbit_after + ke_spin_after + pe_after + dEtot = Etot_after - Etot_before + dLmag = norm2(Ltot_after(:) - Ltot_before(:)) + else + Ltot_before(:) = tmpsys%Lorbit(:) + tmpsys%Lspin(:) + Lmag_before = norm2(Ltot_before(:)) + ke_orbit_before = tmpsys%ke_orbit + ke_spin_before = tmpsys%ke_spin + pe_before = tmpsys%pe + Etot_before = ke_orbit_before + ke_spin_before + pe_before end if + end associate + + return + end subroutine calculate_system_energy + + + subroutine shift_vector_to_origin(m_frag, vec_frag) + !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton + !! + !! Adjusts the position or velocity of the fragments as needed to align them with the origin + implicit none + ! Arguments + real(DP), dimension(:), intent(in) :: m_frag !! Fragment masses + real(DP), dimension(:,:), intent(inout) :: vec_frag !! Fragment positions or velocities in the center of mass frame + + ! Internals + real(DP), dimension(NDIM) :: mvec_frag, COM_offset + integer(I4B) :: i + + mvec_frag(:) = 0.0_DP + + do i = 1, nfrag + mvec_frag = mvec_frag(:) + vec_frag(:,i) * m_frag(i) + end do + COM_offset(:) = -mvec_frag(:) / mtot + do i = 1, nfrag + vec_frag(:, i) = vec_frag(:, i) + COM_offset(:) end do - loverlap(:) = .false. - do j = 1, nfrag - do i = j + 1, nfrag - dis = norm2(x_frag(:,j) - x_frag(:,i)) - loverlap(i) = loverlap(i) .or. (dis <= (rad_frag(i) + rad_frag(j))) + + return + end subroutine shift_vector_to_origin + + + subroutine set_fragment_position_vectors() + !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton + !! + !! Initializes the orbits of the fragments around the center of mass. The fragments are initially placed on a plane defined by the + !! pre-impact angular momentum. They are distributed on an ellipse surrounding the center of mass. + !! The initial positions do not conserve energy or momentum, so these need to be adjusted later. + + implicit none + real(DP) :: dis, rad + real(DP), dimension(NDIM) :: L_sigma + logical, dimension(:), allocatable :: loverlap + integer(I4B) :: i, j + + allocate(loverlap(nfrag)) + + ! Place the fragments into a region that is big enough that we should usually not have overlapping bodies + ! An overlapping bodies will collide in the next time step, so it's not a major problem if they do (it just slows the run down) + r_max = r_max_start + rad = sum(radius(:)) + + ! We will treat the first two fragments of the list as special cases. They get initialized the maximum distances apart along the original impactor distance vector. + ! This is done because in a regular disruption, the first body is the largest, the second the second largest, and the rest are smaller equal-mass fragments. + + call random_number(x_frag(:,3:nfrag)) + loverlap(:) = .true. + do while (any(loverlap(3:nfrag))) + x_frag(:, 1) = x(:, 1) - xcom(:) + x_frag(:, 2) = x(:, 2) - xcom(:) + r_max = r_max + 0.1_DP * rad + do i = 3, nfrag + if (loverlap(i)) then + call random_number(x_frag(:,i)) + x_frag(:, i) = 2 * (x_frag(:, i) - 0.5_DP) * r_max + end if + end do + loverlap(:) = .false. + do j = 1, nfrag + do i = j + 1, nfrag + dis = norm2(x_frag(:,j) - x_frag(:,i)) + loverlap(i) = loverlap(i) .or. (dis <= (rad_frag(i) + rad_frag(j))) + end do end do end do - end do - call shift_vector_to_origin(m_frag, x_frag) - - do i = 1, nfrag - rmag(i) = norm2(x_frag(:, i)) - v_r_unit(:, i) = x_frag(:, i) / rmag(i) - call random_number(L_sigma(:)) ! Randomize the tangential velocity direction. This helps to ensure that the tangential velocity doesn't completely line up with the angular momentum vector, - ! otherwise we can get an ill-conditioned system - v_h_unit(:, i) = z_col_unit(:) + 2e-1_DP * (L_sigma(:) - 0.5_DP) - v_h_unit(:, i) = v_h_unit(:, i) / norm2(v_h_unit(:, i)) - v_t_unit(:, i) = v_h_unit(:, i) .cross. v_r_unit(:, i) - xb_frag(:,i) = x_frag(:,i) + xcom(:) - end do + call shift_vector_to_origin(m_frag, x_frag) + + do i = 1, nfrag + rmag(i) = norm2(x_frag(:, i)) + v_r_unit(:, i) = x_frag(:, i) / rmag(i) + call random_number(L_sigma(:)) ! Randomize the tangential velocity direction. This helps to ensure that the tangential velocity doesn't completely line up with the angular momentum vector, + ! otherwise we can get an ill-conditioned system + v_h_unit(:, i) = z_col_unit(:) + 2e-1_DP * (L_sigma(:) - 0.5_DP) + v_h_unit(:, i) = v_h_unit(:, i) / norm2(v_h_unit(:, i)) + v_t_unit(:, i) = v_h_unit(:, i) .cross. v_r_unit(:, i) + xb_frag(:,i) = x_frag(:,i) + xcom(:) + end do + + call add_fragments_to_tmpsys() + + xcom(:) = 0.0_DP + do i = 1, nfrag + xcom(:) = xcom(:) + m_frag(i) * xb_frag(:,i) + end do + xcom(:) = xcom(:) / mtot - return - end subroutine set_fragment_position_vectors - - subroutine set_fragment_tan_vel(lerr) - !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton - !! - !! Adjusts the tangential velocities and spins of a collection of fragments such that they conserve angular momentum without blowing the fragment kinetic energy budget. - !! This procedure works in several stages, with a goal to solve the angular and linear momentum constraints on the fragments, while still leaving a positive balance of - !! our fragment kinetic energy (ke_frag_budget) that we can put into the radial velocity distribution. - !! - !! The first thing we'll try to do is solve for the tangential velocities of the first 6 fragments, using angular and linear momentum as constraints and an initial - !! tangential velocity distribution for the remaining bodies (if there are any) that distributes their angular momentum equally between them. - !! If that doesn't work and we blow our kinetic energy budget, we will attempt to find a tangential velocity distribution that minimizes the kinetic energy while - !! conserving momentum. - !! - !! A failure will trigger a restructuring of the fragments so we will try new values of the radial position distribution. - implicit none - ! Arguments - logical, intent(out) :: lerr - ! Internals - integer(I4B) :: i - real(DP), parameter :: TOL = 1e-4_DP - real(DP), dimension(:), allocatable :: v_t_initial - type(lambda_obj) :: spinfunc - type(lambda_obj_err) :: objective_function - real(DP), dimension(NDIM) :: L_frag_spin, L_remainder, Li, rot_L, rot_ke - - ! Initialize the fragments with 0 velocity and spin so we can divide up the balance between the tangential, radial, and spin components while conserving momentum - lerr = .false. - vb_frag(:,:) = 0.0_DP - rot_frag(:,:) = 0.0_DP - v_t_mag(:) = 0.0_DP - v_r_mag(:) = 0.0_DP - - call calculate_system_energy(linclude_fragments=.true.) - ke_frag_budget = -dEtot - Qloss - !write(*,*) '***************************************************' - !write(*,*) 'Original dis : ',norm2(x(:,2) - x(:,1)) - !write(*,*) 'r_max : ',r_max - !write(*,*) 'f_spin : ',f_spin - !write(*,*) '***************************************************' - !write(*,*) 'Energy balance so far: ' - !write(*,*) 'ke_frag_budget : ',ke_frag_budget - !write(*,*) 'ke_orbit_before: ',ke_orbit_before - !write(*,*) 'ke_orbit_after : ',ke_orbit_after - !write(*,*) 'ke_spin_before : ',ke_spin_before - !write(*,*) 'ke_spin_after : ',ke_spin_after - !write(*,*) 'pe_before : ',pe_before - !write(*,*) 'pe_after : ',pe_after - !write(*,*) 'Qloss : ',Qloss - !write(*,*) '***************************************************' - if (ke_frag_budget < 0.0_DP) then - write(*,*) 'Negative ke_frag_budget: ',ke_frag_budget - r_max_start = r_max_start / 2 - lerr = .true. return - end if + end subroutine set_fragment_position_vectors - allocate(v_t_initial, mold=v_t_mag) - L_frag_spin(:) = 0.0_DP - ke_frag_spin = 0.0_DP - ! Start the first two bodies with the same rotation as the original two impactors, then distribute the remaining angular momentum among the rest - do i = 1, 2 - rot_frag(:, i) = rot(:, i) - L_frag_spin(:) = L_frag_spin(:) + m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i) * rot_frag(:, i) - end do - L_frag_orb(:) = L_frag_tot(:) - L_frag_spin(:) - L_frag_spin(:) = 0.0_DP - do i = 1, nfrag - ! Convert a fraction (f_spin) of either the remaining angular momentum or kinetic energy budget into spin, whichever gives the smaller rotation so as not to blow any budgets - rot_ke(:) = sqrt(2 * f_spin * ke_frag_budget / (nfrag * m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i))) * L_frag_orb(:) / norm2(L_frag_orb(:)) - rot_L(:) = f_spin * L_frag_orb(:) / (nfrag * m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i)) - if (norm2(rot_ke) < norm2(rot_L)) then - rot_frag(:,i) = rot_frag(:, i) + rot_ke(:) - else - rot_frag(:, i) = rot_frag(:, i) + rot_L(:) + subroutine set_fragment_tan_vel(lerr) + !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton + !! + !! Adjusts the tangential velocities and spins of a collection of fragments such that they conserve angular momentum without blowing the fragment kinetic energy budget. + !! This procedure works in several stages, with a goal to solve the angular and linear momentum constraints on the fragments, while still leaving a positive balance of + !! our fragment kinetic energy (ke_frag_budget) that we can put into the radial velocity distribution. + !! + !! The first thing we'll try to do is solve for the tangential velocities of the first 6 fragments, using angular and linear momentum as constraints and an initial + !! tangential velocity distribution for the remaining bodies (if there are any) that distributes their angular momentum equally between them. + !! If that doesn't work and we blow our kinetic energy budget, we will attempt to find a tangential velocity distribution that minimizes the kinetic energy while + !! conserving momentum. + !! + !! A failure will trigger a restructuring of the fragments so we will try new values of the radial position distribution. + implicit none + ! Arguments + logical, intent(out) :: lerr + ! Internals + integer(I4B) :: i + real(DP), parameter :: TOL = 1e-4_DP + real(DP), dimension(:), allocatable :: v_t_initial + real(DP), dimension(nfrag) :: kefrag + type(lambda_obj) :: spinfunc + type(lambda_obj_err) :: objective_function + real(DP), dimension(NDIM) :: L_frag_spin, L_remainder, Li, rot_L, rot_ke + + lerr = .false. + + if (ke_frag_budget < 0.0_DP) then + write(*,*) 'Negative ke_frag_budget: ',ke_frag_budget + r_max_start = r_max_start / 2 + lerr = .true. + return end if - L_frag_spin(:) = L_frag_spin(:) + m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i) * rot_frag(:, i) - ke_frag_spin = ke_frag_spin + m_frag(i) * Ip_frag(3, i) * rad_frag(i)**2 * dot_product(rot_frag(:, i), rot_frag(:, i)) - end do - ke_frag_spin = 0.5_DP * ke_frag_spin - ! Convert a fraction of the pre-impact angular momentum into fragment spin angular momentum - L_frag_orb(:) = L_frag_tot(:) - L_frag_spin(:) - L_remainder(:) = L_frag_orb(:) - ! Next we will solve for the tangential component of the velocities that both conserves linear momentum and uses the remaining angular momentum not used in spin. - ! This will be done using a linear solver that solves for the tangential velocities of the first 6 fragments, constrained by the linear and angular momentum vectors, - ! which is embedded in a non-linear minimizer that will adjust the tangential velocities of the remaining i>6 fragments to minimize kinetic energy for a given momentum solution - ! The initial conditions fed to the minimizer for the fragments will be the remaining angular momentum distributed between the fragments. - do i = 1, nfrag - v_t_initial(i) = norm2(L_remainder(:)) / ((nfrag - i + 1) * m_frag(i) * norm2(x_frag(:,i))) - Li(:) = m_frag(i) * x_frag(:,i) .cross. v_t_initial(i) * v_t_unit(:, i) - L_remainder(:) = L_remainder(:) - Li(:) - end do - ! Find the local kinetic energy minimum for the system that conserves linear and angular momentum - objective_function = lambda_obj(tangential_objective_function, lerr) - v_t_mag(7:nfrag) = util_minimize_bfgs(objective_function, nfrag-6, v_t_initial(7:nfrag), TOL, lerr) - ! Now that the KE-minimized values of the i>6 fragments are found, calculate the momentum-conserving solution for tangential velociteis - v_t_initial(7:nfrag) = v_t_mag(7:nfrag) - v_t_mag(1:nfrag) = solve_fragment_tan_vel(v_t_mag_input=v_t_initial(7:nfrag), lerr=lerr) - - ! Perform one final shift of the radial velocity vectors to align with the center of mass of the collisional system (the origin) - vb_frag(:,1:nfrag) = vmag_to_vb(v_r_mag(1:nfrag), v_r_unit(:,1:nfrag), v_t_mag(1:nfrag), v_t_unit(:,1:nfrag), m_frag(1:nfrag), vcom(:)) - ! Now do a kinetic energy budget check to make sure we are still within the budget. - ke_frag_orbit = 0.0_DP - do i = 1, nfrag - v_frag(:, i) = vb_frag(:, i) - vcom(:) - ke_frag_orbit = ke_frag_orbit + m_frag(i) * dot_product(vb_frag(:, i), vb_frag(:, i)) - end do - ke_frag_orbit = 0.5_DP * ke_frag_orbit - ke_radial = ke_frag_budget - ke_frag_orbit - ke_frag_spin + allocate(v_t_initial, mold=v_t_mag) - ! If we are over the energy budget, flag this as a failure so we can try again - lerr = (ke_radial < 0.0_DP) - !write(*,*) 'Tangential' - !write(*,*) 'ke_frag_budget: ',ke_frag_budget - !write(*,*) 'ke_frag_orbit : ',ke_frag_orbit - !write(*,*) 'ke_frag_spin : ',ke_frag_spin - !write(*,*) 'ke_radial : ',ke_radial + L_frag_spin(:) = 0.0_DP + ke_frag_spin = 0.0_DP + ! Start the first two bodies with the same rotation as the original two impactors, then distribute the remaining angular momentum among the rest + do i = 1, 2 + rot_frag(:, i) = rot(:, i) + L_frag_spin(:) = L_frag_spin(:) + m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i) * rot_frag(:, i) + end do + L_frag_orb(:) = L_frag_tot(:) - L_frag_spin(:) + L_frag_spin(:) = 0.0_DP + do i = 1, nfrag + ! Convert a fraction (f_spin) of either the remaining angular momentum or kinetic energy budget into spin, whichever gives the smaller rotation so as not to blow any budgets + rot_ke(:) = sqrt(2 * f_spin * ke_frag_budget / (nfrag * m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i))) * L_frag_orb(:) / norm2(L_frag_orb(:)) + rot_L(:) = f_spin * L_frag_orb(:) / (nfrag * m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i)) + if (norm2(rot_ke) < norm2(rot_L)) then + rot_frag(:,i) = rot_frag(:, i) + rot_ke(:) + else + rot_frag(:, i) = rot_frag(:, i) + rot_L(:) + end if + L_frag_spin(:) = L_frag_spin(:) + m_frag(i) * rad_frag(i)**2 * Ip_frag(3, i) * rot_frag(:, i) + ke_frag_spin = ke_frag_spin + m_frag(i) * Ip_frag(3, i) * rad_frag(i)**2 * dot_product(rot_frag(:, i), rot_frag(:, i)) + end do + ke_frag_spin = 0.5_DP * ke_frag_spin + ! Convert a fraction of the pre-impact angular momentum into fragment spin angular momentum + L_frag_orb(:) = L_frag_tot(:) - L_frag_spin(:) + L_remainder(:) = L_frag_orb(:) + ! Next we will solve for the tangential component of the velocities that both conserves linear momentum and uses the remaining angular momentum not used in spin. + ! This will be done using a linear solver that solves for the tangential velocities of the first 6 fragments, constrained by the linear and angular momentum vectors, + ! which is embedded in a non-linear minimizer that will adjust the tangential velocities of the remaining i>6 fragments to minimize kinetic energy for a given momentum solution + ! The initial conditions fed to the minimizer for the fragments will be the remaining angular momentum distributed between the fragments. + do i = 1, nfrag + v_t_initial(i) = norm2(L_remainder(:)) / ((nfrag - i + 1) * m_frag(i) * norm2(x_frag(:,i))) + Li(:) = m_frag(i) * x_frag(:,i) .cross. v_t_initial(i) * v_t_unit(:, i) + L_remainder(:) = L_remainder(:) - Li(:) + end do - return + ! Find the local kinetic energy minimum for the system that conserves linear and angular momentum + objective_function = lambda_obj(tangential_objective_function, lerr) + v_t_mag(7:nfrag) = util_minimize_bfgs(objective_function, nfrag-6, v_t_initial(7:nfrag), TOL, lerr) + ! Now that the KE-minimized values of the i>6 fragments are found, calculate the momentum-conserving solution for tangential velociteis + v_t_initial(7:nfrag) = v_t_mag(7:nfrag) + v_t_mag(1:nfrag) = solve_fragment_tan_vel(v_t_mag_input=v_t_initial(7:nfrag), lerr=lerr) + + ! Perform one final shift of the radial velocity vectors to align with the center of mass of the collisional system (the origin) + vb_frag(:,1:nfrag) = vmag_to_vb(v_r_mag(1:nfrag), v_r_unit(:,1:nfrag), v_t_mag(1:nfrag), v_t_unit(:,1:nfrag), m_frag(1:nfrag), vcom(:)) + call add_fragments_to_tmpsys() + + ! Now do a kinetic energy budget check to make sure we are still within the budget. + kefrag = 0.0_DP + do concurrent(i = 1:nfrag) + v_frag(:, i) = vb_frag(:, i) - vcom(:) + kefrag(i) = m_frag(i) * dot_product(vb_frag(:, i), vb_frag(:, i)) + end do + ke_frag_orbit = 0.5_DP * sum(kefrag(:)) + ke_radial = ke_frag_budget - ke_frag_orbit - ke_frag_spin + + ! If we are over the energy budget, flag this as a failure so we can try again + lerr = (ke_radial < 0.0_DP) + ! write(*,*) 'Tangential' + ! write(*,*) 'Failure? ',lerr + ! write(*,*) 'ke_frag_budget: ',ke_frag_budget + ! write(*,*) 'ke_frag_spin : ',ke_frag_spin + ! write(*,*) 'ke_tangential : ',ke_frag_orbit + ! write(*,*) 'ke_remainder : ',ke_radial - end subroutine set_fragment_tan_vel - - function tangential_objective_function(v_t_mag_input, lerr) result(fval) - !! Author: David A. Minton - !! - !! Objective function for evaluating how close our fragment velocities get to minimizing KE error from our required value - implicit none - ! Arguments - real(DP), dimension(:), intent(in) :: v_t_mag_input !! Unknown tangential component of velocity vector set previously by angular momentum constraint - logical, intent(out) :: lerr !! Error flag - ! Result - real(DP) :: fval - ! Internals - integer(I4B) :: i - real(DP), dimension(:,:), allocatable :: v_shift - real(DP), dimension(:), allocatable :: v_t_new - real(DP) :: keo - - lerr = .false. - - allocate(v_shift(NDIM, nfrag)) - allocate(v_t_new(nfrag)) - - v_t_new(:) = solve_fragment_tan_vel(v_t_mag_input=v_t_mag_input(:), lerr=lerr) - v_shift(:,:) = vmag_to_vb(v_r_mag, v_r_unit, v_t_new, v_t_unit, m_frag, vcom) - - keo = 0.0_DP - do i = 1, nfrag - keo = keo + m_frag(i) * dot_product(v_shift(:, i), v_shift(:, i)) - end do - keo = 0.5_DP * keo - fval = keo - lerr = .false. - return - end function tangential_objective_function - - function solve_fragment_tan_vel(lerr, v_t_mag_input) result(v_t_mag_output) - !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton - !! - !! Adjusts the positions, velocities, and spins of a collection of fragments such that they conserve angular momentum - implicit none - ! Arguments - logical, intent(out) :: lerr !! Error flag - real(DP), dimension(:), optional, intent(in) :: v_t_mag_input !! Unknown tangential velocities for fragments 7:nfrag - ! Internals - integer(I4B) :: i - ! Result - real(DP), dimension(:), allocatable :: v_t_mag_output - - real(DP), dimension(2 * NDIM, 2 * NDIM) :: A ! LHS of linear equation used to solve for momentum constraint in Gauss elimination code - real(DP), dimension(2 * NDIM) :: b ! RHS of linear equation used to solve for momentum constraint in Gauss elimination code - real(DP), dimension(NDIM) :: L_lin_others, L_orb_others, L, vtmp - - v_frag(:,:) = 0.0_DP - lerr = .false. - - ! We have 6 constraint equations (2 vector constraints in 3 dimensions each) - ! The first 3 are that the linear momentum of the fragments is zero with respect to the collisional barycenter - ! The second 3 are that the sum of the angular momentum of the fragments is conserved from the pre-impact state - L_lin_others(:) = 0.0_DP - L_orb_others(:) = 0.0_DP - do i = 1, nfrag - if (i <= 2 * NDIM) then ! The tangential velocities of the first set of bodies will be the unknowns we will solve for to satisfy the constraints - A(1:3, i) = m_frag(i) * v_t_unit(:, i) - L(:) = v_r_unit(:, i) .cross. v_t_unit(:, i) - A(4:6, i) = m_frag(i) * rmag(i) * L(:) - else if (present(v_t_mag_input)) then - vtmp(:) = v_t_mag_input(i - 6) * v_t_unit(:, i) - L_lin_others(:) = L_lin_others(:) + m_frag(i) * vtmp(:) - L(:) = x_frag(:, i) .cross. vtmp(:) - L_orb_others(:) = L_orb_others(:) + m_frag(i) * L(:) - end if - end do - b(1:3) = -L_lin_others(:) - b(4:6) = L_frag_orb(:) - L_orb_others(:) - allocate(v_t_mag_output(nfrag)) - v_t_mag_output(1:6) = util_solve_linear_system(A, b, 6, lerr) - if (present(v_t_mag_input)) v_t_mag_output(7:nfrag) = v_t_mag_input(:) - - return - end function solve_fragment_tan_vel - - subroutine set_fragment_radial_velocities(lerr) - !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton - !! - !! - !! Adjust the fragment velocities to set the fragment orbital kinetic energy. This will minimize the difference between the fragment kinetic energy and the energy budget - implicit none - ! Arguments - logical, intent(out) :: lerr - ! Internals - real(DP), parameter :: TOL = 1e-10_DP - integer(I4B) :: i, j - real(DP), dimension(:), allocatable :: v_r_initial, v_r_sigma - real(DP), dimension(:,:), allocatable :: v_r - type(lambda_obj) :: objective_function - - ! Set the "target" ke_orbit_after (the value of the orbital kinetic energy that the fragments ought to have) - - allocate(v_r_initial, source=v_r_mag) - ! Initialize radial velocity magnitudes with a random value that is approximately 10% of that found by distributing the kinetic energy equally - allocate(v_r_sigma, source=v_r_mag) - call random_number(v_r_sigma(1:nfrag)) - v_r_sigma(1:nfrag) = sqrt(1.0_DP + 2 * (v_r_sigma(1:nfrag) - 0.5_DP) * 1e-4_DP) - v_r_initial(1:nfrag) = v_r_sigma(1:nfrag) * sqrt(abs(ke_radial) / (2 * m_frag(1:nfrag) * nfrag)) - - ! Initialize the lambda function using a structure constructor that calls the init method - ! Minimize the ke objective function using the BFGS optimizer - objective_function = lambda_obj(radial_objective_function) - v_r_mag = util_minimize_bfgs(objective_function, nfrag, v_r_initial, TOL, lerr) - ! Shift the radial velocity vectors to align with the center of mass of the collisional system (the origin) - vb_frag(:,1:nfrag) = vmag_to_vb(v_r_mag(1:nfrag), v_r_unit(:,1:nfrag), v_t_mag(1:nfrag), v_t_unit(:,1:nfrag), m_frag(1:nfrag), vcom(:)) - do i = 1, nfrag - v_frag(:, i) = vb_frag(:, i) - vcom(:) - end do - ke_frag_orbit = 0.0_DP - do i = 1, nfrag - ke_frag_orbit = ke_frag_orbit + m_frag(i) * dot_product(vb_frag(:, i), vb_frag(:, i)) - end do - ke_frag_orbit = 0.5_DP * ke_frag_orbit - !write(*,*) 'Radial' - !write(*,*) 'Failure? ',lerr - !write(*,*) 'ke_frag_budget: ',ke_frag_budget - !write(*,*) 'ke_frag_orbit : ',ke_frag_orbit - !write(*,*) 'ke_frag_spin : ',ke_frag_spin - !write(*,*) 'ke_remainder : ',ke_frag_budget - (ke_frag_orbit + ke_frag_spin) - lerr = .false. + return + end subroutine set_fragment_tan_vel - return - end subroutine set_fragment_radial_velocities - - function radial_objective_function(v_r_mag_input) result(fval) - !! Author: David A. Minton - !! - !! Objective function for evaluating how close our fragment velocities get to minimizing KE error from our required value - implicit none - ! Arguments - real(DP), dimension(:), intent(in) :: v_r_mag_input !! Unknown radial component of fragment velocity vector - ! Result - real(DP) :: fval !! The objective function result, which is the square of the difference between the calculated fragment kinetic energy and our target - !! Minimizing this brings us closer to our objective - ! Internals - integer(I4B) :: i - real(DP), dimension(:,:), allocatable :: v_shift - - allocate(v_shift, mold=vb_frag) - v_shift(:,:) = vmag_to_vb(v_r_mag_input, v_r_unit, v_t_mag, v_t_unit, m_frag, vcom) - fval = 2 * ke_frag_budget - do i = 1, nfrag - fval = fval - m_frag(i) * (Ip_frag(3, i) * rad_frag(i)**2 * dot_product(rot_frag(:, i), rot_frag(:, i)) + dot_product(v_shift(:, i), v_shift(:, i))) - end do - ! The following ensures that fval = 0 is a local minimum, which is what the BFGS method is searching for - fval = (fval / (2 * ke_radial))**2 - return + function tangential_objective_function(v_t_mag_input, lerr) result(fval) + !! Author: David A. Minton + !! + !! Objective function for evaluating how close our fragment velocities get to minimizing KE error from our required value + implicit none + ! Arguments + real(DP), dimension(:), intent(in) :: v_t_mag_input !! Unknown tangential component of velocity vector set previously by angular momentum constraint + logical, intent(out) :: lerr !! Error flag + ! Result + real(DP) :: fval + ! Internals + integer(I4B) :: i + real(DP), dimension(NDIM,nfrag) :: v_shift + real(DP), dimension(nfrag) :: v_t_new, kearr + real(DP) :: keo - end function radial_objective_function - - function vmag_to_vb(v_r_mag, v_r_unit, v_t_mag, v_t_unit, m_frag, vcom) result(vb) - !! Author: David A. Minton - !! - !! Converts radial and tangential velocity magnitudes into barycentric velocity - implicit none - ! Arguments - real(DP), dimension(:), intent(in) :: v_r_mag !! Unknown radial component of fragment velocity vector - real(DP), dimension(:), intent(in) :: v_t_mag !! Tangential component of velocity vector set previously by angular momentum constraint - real(DP), dimension(:,:), intent(in) :: v_r_unit, v_t_unit !! Radial and tangential unit vectors for each fragment - real(DP), dimension(:), intent(in) :: m_frag !! Fragment masses - real(DP), dimension(:), intent(in) :: vcom !! Barycentric velocity of collisional system center of mass - ! Result - real(DP), dimension(:,:), allocatable :: vb - ! Internals - integer(I4B) :: i - - allocate(vb, mold=v_r_unit) - ! Make sure the velocity magnitude stays positive - do i = 1, nfrag - vb(:,i) = abs(v_r_mag(i)) * v_r_unit(:, i) - end do - ! In order to keep satisfying the kinetic energy constraint, we must shift the origin of the radial component of the velocities to the center of mass - call shift_vector_to_origin(m_frag, vb) - - do i = 1, nfrag - vb(:, i) = vb(:, i) + v_t_mag(i) * v_t_unit(:, i) + vcom(:) - end do + lerr = .false. - end function vmag_to_vb - - subroutine restructure_failed_fragments() - !! Author: David A. Minton - !! - !! We failed to find a set of positions and velocities that satisfy all the constraints, and so we will alter the fragments and try again. - implicit none - integer(I4B) :: i - real(DP), dimension(:), allocatable :: m_frag_new, rad_frag_new - real(DP), dimension(:,:), allocatable :: xb_frag_new, vb_frag_new, Ip_frag_new, rot_frag_new - real(DP) :: delta_r, delta_r_max - real(DP), parameter :: ke_avg_deficit_target = 0.0_DP - - ! Introduce a bit of noise in the radius determination so we don't just flip flop between similar failed positions - call random_number(delta_r_max) - delta_r_max = sum(radius(:)) * (1.0_DP + 2e-1_DP * (delta_r_max - 0.5_DP)) - if (try > 2) then - ! Linearly interpolate the last two failed solution ke deficits to find a new distance value to try - delta_r = (r_max_start - r_max_start_old) * (ke_avg_deficit_target - ke_avg_deficit_old) / (ke_avg_deficit - ke_avg_deficit_old) - if (abs(delta_r) > delta_r_max) delta_r = sign(delta_r_max, delta_r) - else - delta_r = delta_r_max - end if - r_max_start_old = r_max_start - r_max_start = r_max_start + delta_r ! The larger lever arm can help if the problem is in the angular momentum step - if (f_spin > epsilon(1.0_DP)) then - f_spin = f_spin / 2 - else - f_spin = 0.0_DP - end if - end subroutine restructure_failed_fragments + v_t_new(:) = solve_fragment_tan_vel(v_t_mag_input=v_t_mag_input(:), lerr=lerr) + v_shift(:,:) = vmag_to_vb(v_r_mag, v_r_unit, v_t_new, v_t_unit, m_frag, vcom) + kearr = 0.0_DP + do concurrent(i = 1:nfrag) + kearr(i) = m_frag(i) * dot_product(v_shift(:, i), v_shift(:, i)) + end do + keo = 0.5_DP * sum(kearr(:)) + fval = keo + lerr = .false. - end subroutine fragmentation_initialize + return + end function tangential_objective_function + + + function solve_fragment_tan_vel(lerr, v_t_mag_input) result(v_t_mag_output) + !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton + !! + !! Adjusts the positions, velocities, and spins of a collection of fragments such that they conserve angular momentum + implicit none + ! Arguments + logical, intent(out) :: lerr !! Error flag + real(DP), dimension(:), optional, intent(in) :: v_t_mag_input !! Unknown tangential velocities for fragments 7:nfrag + ! Internals + integer(I4B) :: i + ! Result + real(DP), dimension(:), allocatable :: v_t_mag_output + + real(DP), dimension(2 * NDIM, 2 * NDIM) :: A ! LHS of linear equation used to solve for momentum constraint in Gauss elimination code + real(DP), dimension(2 * NDIM) :: b ! RHS of linear equation used to solve for momentum constraint in Gauss elimination code + real(DP), dimension(NDIM) :: L_lin_others, L_orb_others, L, vtmp + + v_frag(:,:) = 0.0_DP + lerr = .false. + + ! We have 6 constraint equations (2 vector constraints in 3 dimensions each) + ! The first 3 are that the linear momentum of the fragments is zero with respect to the collisional barycenter + ! The second 3 are that the sum of the angular momentum of the fragments is conserved from the pre-impact state + L_lin_others(:) = 0.0_DP + L_orb_others(:) = 0.0_DP + do i = 1, nfrag + if (i <= 2 * NDIM) then ! The tangential velocities of the first set of bodies will be the unknowns we will solve for to satisfy the constraints + A(1:3, i) = m_frag(i) * v_t_unit(:, i) + L(:) = v_r_unit(:, i) .cross. v_t_unit(:, i) + A(4:6, i) = m_frag(i) * rmag(i) * L(:) + else if (present(v_t_mag_input)) then + vtmp(:) = v_t_mag_input(i - 6) * v_t_unit(:, i) + L_lin_others(:) = L_lin_others(:) + m_frag(i) * vtmp(:) + L(:) = x_frag(:, i) .cross. vtmp(:) + L_orb_others(:) = L_orb_others(:) + m_frag(i) * L(:) + end if + end do + b(1:3) = -L_lin_others(:) + b(4:6) = L_frag_orb(:) - L_orb_others(:) + allocate(v_t_mag_output(nfrag)) + v_t_mag_output(1:6) = util_solve_linear_system(A, b, 6, lerr) + if (present(v_t_mag_input)) v_t_mag_output(7:nfrag) = v_t_mag_input(:) + + return + end function solve_fragment_tan_vel + + + subroutine set_fragment_radial_velocities(lerr) + !! Author: Jennifer L.L. Pouplin, Carlisle A. Wishard, and David A. Minton + !! + !! + !! Adjust the fragment velocities to set the fragment orbital kinetic energy. This will minimize the difference between the fragment kinetic energy and the energy budget + implicit none + ! Arguments + logical, intent(out) :: lerr + ! Internals + real(DP), parameter :: TOL = 1e-10_DP + integer(I4B) :: i, j + real(DP), dimension(:), allocatable :: v_r_initial, v_r_sigma + real(DP), dimension(:,:), allocatable :: v_r + real(DP), dimension(nfrag) :: kearr, kespinarr + type(lambda_obj) :: objective_function + + ! Set the "target" ke_orbit_after (the value of the orbital kinetic energy that the fragments ought to have) + + allocate(v_r_initial, source=v_r_mag) + ! Initialize radial velocity magnitudes with a random value that is approximately 10% of that found by distributing the kinetic energy equally + allocate(v_r_sigma, source=v_r_mag) + call random_number(v_r_sigma(1:nfrag)) + v_r_sigma(1:nfrag) = sqrt(1.0_DP + 2 * (v_r_sigma(1:nfrag) - 0.5_DP) * 1e-4_DP) + v_r_initial(1:nfrag) = v_r_sigma(1:nfrag) * sqrt(abs(2 * ke_radial) / (m_frag(1:nfrag) * nfrag)) + + ! Initialize the lambda function using a structure constructor that calls the init method + ! Minimize the ke objective function using the BFGS optimizer + objective_function = lambda_obj(radial_objective_function) + v_r_mag = util_minimize_bfgs(objective_function, nfrag, v_r_initial, TOL, lerr) + ! Shift the radial velocity vectors to align with the center of mass of the collisional system (the origin) + vb_frag(:,1:nfrag) = vmag_to_vb(v_r_mag(1:nfrag), v_r_unit(:,1:nfrag), v_t_mag(1:nfrag), v_t_unit(:,1:nfrag), m_frag(1:nfrag), vcom(:)) + do i = 1, nfrag + v_frag(:, i) = vb_frag(:, i) - vcom(:) + end do + call add_fragments_to_tmpsys() + + do concurrent(i = 1:nfrag) + kearr(i) = m_frag(i) * dot_product(vb_frag(:, i), vb_frag(:, i)) + kespinarr(i) = m_frag(i) * Ip_frag(3, i) * rad_frag(i)**2 * dot_product(rot_frag(:,i), rot_frag(:,i)) + end do + ke_frag_orbit = 0.5_DP * sum(kearr(:)) + ke_frag_spin = 0.5_DP * sum(kespinarr(:)) + ! write(*,*) 'Radial' + ! write(*,*) 'Failure? ',lerr + ! write(*,*) 'ke_frag_budget: ',ke_frag_budget + ! write(*,*) 'ke_frag_spin : ',ke_frag_spin + ! write(*,*) 'ke_frag_orbit : ',ke_frag_orbit + ! write(*,*) 'ke_remainder : ',ke_frag_budget - (ke_frag_orbit + ke_frag_spin) + lerr = .false. + + return + end subroutine set_fragment_radial_velocities + + + function radial_objective_function(v_r_mag_input) result(fval) + !! Author: David A. Minton + !! + !! Objective function for evaluating how close our fragment velocities get to minimizing KE error from our required value + implicit none + ! Arguments + real(DP), dimension(:), intent(in) :: v_r_mag_input !! Unknown radial component of fragment velocity vector + ! Result + real(DP) :: fval !! The objective function result, which is the square of the difference between the calculated fragment kinetic energy and our target + !! Minimizing this brings us closer to our objective + ! Internals + integer(I4B) :: i + real(DP), dimension(:,:), allocatable :: v_shift + real(DP), dimension(nfrag) :: kearr + real(DP) :: keo + + allocate(v_shift, mold=vb_frag) + v_shift(:,:) = vmag_to_vb(v_r_mag_input, v_r_unit, v_t_mag, v_t_unit, m_frag, vcom) + do concurrent(i = 1:nfrag) + kearr(i) = m_frag(i) * (Ip_frag(3, i) * rad_frag(i)**2 * dot_product(rot_frag(:, i), rot_frag(:, i)) + dot_product(v_shift(:, i), v_shift(:, i))) + end do + keo = 2 * ke_frag_budget - sum(kearr(:)) + ! The following ensures that fval = 0 is a local minimum, which is what the BFGS method is searching for + fval = (keo / (2 * ke_radial))**2 + + return + end function radial_objective_function + + + function vmag_to_vb(v_r_mag, v_r_unit, v_t_mag, v_t_unit, m_frag, vcom) result(vb) + !! Author: David A. Minton + !! + !! Converts radial and tangential velocity magnitudes into barycentric velocity + implicit none + ! Arguments + real(DP), dimension(:), intent(in) :: v_r_mag !! Unknown radial component of fragment velocity vector + real(DP), dimension(:), intent(in) :: v_t_mag !! Tangential component of velocity vector set previously by angular momentum constraint + real(DP), dimension(:,:), intent(in) :: v_r_unit, v_t_unit !! Radial and tangential unit vectors for each fragment + real(DP), dimension(:), intent(in) :: m_frag !! Fragment masses + real(DP), dimension(:), intent(in) :: vcom !! Barycentric velocity of collisional system center of mass + ! Result + real(DP), dimension(:,:), allocatable :: vb + ! Internals + integer(I4B) :: i + + allocate(vb, mold=v_r_unit) + ! Make sure the velocity magnitude stays positive + do i = 1, nfrag + vb(:,i) = abs(v_r_mag(i)) * v_r_unit(:, i) + end do + ! In order to keep satisfying the kinetic energy constraint, we must shift the origin of the radial component of the velocities to the center of mass + call shift_vector_to_origin(m_frag, vb) + + do i = 1, nfrag + vb(:, i) = vb(:, i) + v_t_mag(i) * v_t_unit(:, i) + vcom(:) + end do + return + end function vmag_to_vb + + + subroutine restructure_failed_fragments() + !! Author: David A. Minton + !! + !! We failed to find a set of positions and velocities that satisfy all the constraints, and so we will alter the fragments and try again. + implicit none + integer(I4B) :: i + real(DP), dimension(:), allocatable :: m_frag_new, rad_frag_new + real(DP), dimension(:,:), allocatable :: xb_frag_new, vb_frag_new, Ip_frag_new, rot_frag_new + real(DP) :: delta_r, delta_r_max + real(DP), parameter :: ke_avg_deficit_target = 0.0_DP + + ! Introduce a bit of noise in the radius determination so we don't just flip flop between similar failed positions + call random_number(delta_r_max) + delta_r_max = sum(radius(:)) * (1.0_DP + 2e-1_DP * (delta_r_max - 0.5_DP)) + if (try > 2) then + ! Linearly interpolate the last two failed solution ke deficits to find a new distance value to try + delta_r = (r_max_start - r_max_start_old) * (ke_avg_deficit_target - ke_avg_deficit_old) / (ke_avg_deficit - ke_avg_deficit_old) + if (abs(delta_r) > delta_r_max) delta_r = sign(delta_r_max, delta_r) + else + delta_r = delta_r_max + end if + r_max_start_old = r_max_start + r_max_start = r_max_start + delta_r ! The larger lever arm can help if the problem is in the angular momentum step + if (f_spin > epsilon(1.0_DP)) then + f_spin = f_spin / 2 + else + f_spin = 0.0_DP + end if + + return + end subroutine restructure_failed_fragments + end subroutine fragmentation_initialize module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, vb2, den1, den2, regime, Mlr, Mslr, mtiny, Qloss) diff --git a/src/io/io.f90 b/src/io/io.f90 index 42cc8ddd9..a80d54893 100644 --- a/src/io/io.f90 +++ b/src/io/io.f90 @@ -31,14 +31,15 @@ module subroutine io_conservation_report(self, param, lterminal) Euntracked => self%Euntracked, Eorbit_orig => param%Eorbit_orig, Mtot_orig => param%Mtot_orig, & Ltot_orig => param%Ltot_orig(:), Lmag_orig => param%Lmag_orig, Lorbit_orig => param%Lorbit_orig(:), Lspin_orig => param%Lspin_orig(:), & lfirst => param%lfirstenergy) - if (lfirst) then - if (param%out_stat == "OLD") then - open(unit = EGYIU, file = ENERGY_FILE, form = "formatted", status = "old", action = "write", position = "append") - else - open(unit = EGYIU, file = ENERGY_FILE, form = "formatted", status = "replace", action = "write") + if (param%energy_out /= "") then + if (lfirst .and. (param%out_stat /= "OLD")) then + open(unit = EGYIU, file = param%energy_out, form = "formatted", status = "replace", action = "write") + else + open(unit = EGYIU, file = param%energy_out, form = "formatted", status = "old", action = "write", position = "append") write(EGYIU,EGYHEADER) end if end if + call pl%h2b(cb) call system%get_energy_and_momentum(param) ke_orbit_now = system%ke_orbit ke_spin_now = system%ke_spin @@ -58,8 +59,10 @@ module subroutine io_conservation_report(self, param, lterminal) lfirst = .false. end if - write(EGYIU,EGYFMT) param%t, Eorbit_now, Ecollisions, Ltot_now, Mtot_now - flush(EGYIU) + if (param%energy_out /= "") then + write(EGYIU,EGYFMT) param%t, Eorbit_now, Ecollisions, Ltot_now, Mtot_now + close(EGYIU) + end if if (.not.lfirst .and. lterminal) then Lmag_now = norm2(Ltot_now) Lerror = norm2(Ltot_now - Ltot_orig) / Lmag_orig @@ -126,7 +129,7 @@ module subroutine io_dump_param(self, param_file_name) end subroutine io_dump_param - module subroutine io_dump_swiftest(self, param, msg) + module subroutine io_dump_swiftest(self, param) !! author: David A. Minton !! !! Dump massive body data to files @@ -137,7 +140,6 @@ module subroutine io_dump_swiftest(self, param, msg) ! Arguments class(swiftest_base), intent(inout) :: self !! Swiftest base object class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), optional, intent(in) :: msg !! Message to display with dump operation ! Internals integer(I4B) :: ierr !! Error code integer(I4B),parameter :: LUN = 7 !! Unit number for dump file @@ -165,7 +167,7 @@ module subroutine io_dump_swiftest(self, param, msg) end subroutine io_dump_swiftest - module subroutine io_dump_system(self, param, msg) + module subroutine io_dump_system(self, param) !! author: David A. Minton !! !! Dumps the state of the system to files in case the simulation is interrupted. @@ -175,35 +177,52 @@ module subroutine io_dump_system(self, param, msg) ! Arguments class(swiftest_nbody_system), intent(inout) :: self !! Swiftest system object class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), optional, intent(in) :: msg !! Message to display with dump operation ! Internals class(swiftest_parameters), allocatable :: dump_param !! Local parameters variable used to parameters change input file names !! to dump file-specific values without changing the user-defined values integer(I4B), save :: idx = 1 !! Index of current dump file. Output flips between 2 files for extra security !! in case the program halts during writing character(len=:), allocatable :: param_file_name - real(DP) :: tfrac - - allocate(dump_param, source=param) - param_file_name = trim(adjustl(DUMP_PARAM_FILE(idx))) - dump_param%incbfile = trim(adjustl(DUMP_CB_FILE(idx))) - dump_param%inplfile = trim(adjustl(DUMP_PL_FILE(idx))) - dump_param%intpfile = trim(adjustl(DUMP_TP_FILE(idx))) - dump_param%out_form = XV - dump_param%out_stat = 'APPEND' - dump_param%T0 = param%t - call dump_param%dump(param_file_name) - - call self%cb%dump(dump_param) - if (self%pl%nbody > 0) call self%pl%dump(dump_param) - if (self%tp%nbody > 0) call self%tp%dump(dump_param) - - idx = idx + 1 - if (idx > NDUMPFILES) idx = 1 - - ! Print the status message (format code passed in from main driver) - tfrac = (param%t - param%t0) / (param%tstop - param%t0) - write(*,msg) param%t, tfrac, self%pl%nbody, self%tp%nbody + real(DP) :: deltawall, wallperstep, tfrac + integer(I8B) :: clock_count, count_rate, count_max + character(*), parameter :: statusfmt = '("Time = ", ES12.5, "; fraction done = ", F6.3, "; Number of active pl, tp = ", I5, ", ", I5)' + character(len=*), parameter :: walltimefmt = '(" Wall time (s): ", es12.5, "; Wall time/step in this interval (s): ", es12.5)' + logical, save :: lfirst = .true. + real(DP), save :: start, finish + + if (lfirst) then + call system_clock(clock_count, count_rate, count_max) + start = clock_count / (count_rate * 1.0_DP) + finish = start + lfirst = .false. + else + allocate(dump_param, source=param) + param_file_name = trim(adjustl(DUMP_PARAM_FILE(idx))) + dump_param%incbfile = trim(adjustl(DUMP_CB_FILE(idx))) + dump_param%inplfile = trim(adjustl(DUMP_PL_FILE(idx))) + dump_param%intpfile = trim(adjustl(DUMP_TP_FILE(idx))) + dump_param%out_form = XV + dump_param%out_stat = 'APPEND' + dump_param%T0 = param%t + call dump_param%dump(param_file_name) + + call self%cb%dump(dump_param) + if (self%pl%nbody > 0) call self%pl%dump(dump_param) + if (self%tp%nbody > 0) call self%tp%dump(dump_param) + + idx = idx + 1 + if (idx > NDUMPFILES) idx = 1 + + tfrac = (param%t - param%t0) / (param%tstop - param%t0) + + call system_clock(clock_count, count_rate, count_max) + deltawall = clock_count / (count_rate * 1.0_DP) - finish + wallperstep = deltawall / param%istep_dump + finish = clock_count / (count_rate * 1.0_DP) + end if + write(*, statusfmt) param%t, tfrac, self%pl%nbody, self%tp%nbody + write(*, walltimefmt) finish - start, wallperstep + if (param%lenergy) call self%conservation_report(param, lterminal=.true.) return @@ -421,6 +440,8 @@ module subroutine io_param_reader(self, unit, iotype, v_list, iostat, iomsg) param%enc_out = param_value case ("DISCARD_OUT") param%discard_out = param_value + case ("ENERGY_OUT") + param%energy_out = param_value case ("EXTRA_FORCE") call io_toupper(param_value) if (param_value == "YES" .or. param_value == 'T') param%lextra_force = .true. @@ -493,7 +514,7 @@ module subroutine io_param_reader(self, unit, iotype, v_list, iostat, iomsg) read(param_value, *) param%Ecollisions case("EUNTRACKED") read(param_value, *) param%Euntracked - case ("NPLMAX", "NTPMAX", "MTINY", "PARTICLE_FILE", "FRAGMENTATION", "SEED", "YARKOVSKY", "YORP") ! Ignore SyMBA-specific, not-yet-implemented, or obsolete input parameters + case ("NPLMAX", "NTPMAX", "GMTINY", "PARTICLE_OUT", "FRAGMENTATION", "SEED", "YARKOVSKY", "YORP") ! Ignore SyMBA-specific, not-yet-implemented, or obsolete input parameters case default write(iomsg,*) "Unknown parameter -> ",param_name iostat = -1 @@ -535,6 +556,7 @@ module subroutine io_param_reader(self, unit, iotype, v_list, iostat, iomsg) iostat = -1 return end if + param%lrestart = (param%out_stat == "APPEND") if (param%outfile /= "") then if ((param%out_type /= REAL4_TYPE) .and. (param%out_type /= REAL8_TYPE) .and. & (param%out_type /= SWIFTER_REAL4_TYPE) .and. (param%out_type /= SWIFTER_REAL8_TYPE)) then @@ -552,6 +574,7 @@ module subroutine io_param_reader(self, unit, iotype, v_list, iostat, iomsg) iostat = -1 return end if + end if if (param%qmin > 0.0_DP) then if ((param%qmin_coord /= "HELIO") .and. (param%qmin_coord /= "BARY")) then @@ -795,19 +818,22 @@ module subroutine io_read_body_in(self, param) self%Gmass(i) = real(val, kind=DP) self%mass(i) = real(val / param%GU, kind=DP) if (param%lclose) read(iu, *, iostat=ierr, err=100) self%radius(i) - if (param%lrotation) then - read(iu, iostat=ierr, err=100) self%Ip(:, i) - read(iu, iostat=ierr, err=100) self%rot(:, i) - end if - if (param%ltides) then - read(iu, iostat=ierr, err=100) self%k2(i) - read(iu, iostat=ierr, err=100) self%Q(i) - end if class is (swiftest_tp) read(iu, *, iostat=ierr, err=100) self%id(i) end select read(iu, *, iostat=ierr, err=100) self%xh(1, i), self%xh(2, i), self%xh(3, i) read(iu, *, iostat=ierr, err=100) self%vh(1, i), self%vh(2, i), self%vh(3, i) + select type (self) + class is (swiftest_pl) + if (param%lrotation) then + read(iu, *, iostat=ierr, err=100) self%Ip(1, i), self%Ip(2, i), self%Ip(3, i) + read(iu, *, iostat=ierr, err=100) self%rot(1, i), self%rot(2, i), self%rot(3, i) + end if + if (param%ltides) then + read(iu, *, iostat=ierr, err=100) self%k2(i) + read(iu, *, iostat=ierr, err=100) self%Q(i) + end if + end select self%status(i) = ACTIVE self%lmask(i) = .true. end do @@ -859,13 +885,17 @@ module subroutine io_read_cb_in(self, param) is_ascii = (param%in_type == 'ASCII') if (is_ascii) then open(unit = iu, file = param%incbfile, status = 'old', form = 'FORMATTED', iostat = ierr) - !read(iu, *, iostat = ierr) self%id + read(iu, *, iostat = ierr) self%id read(iu, *, iostat = ierr) val self%Gmass = real(val, kind=DP) self%mass = real(val / param%GU, kind=DP) read(iu, *, iostat = ierr) self%radius read(iu, *, iostat = ierr) self%j2rp2 read(iu, *, iostat = ierr) self%j4rp4 + if (param%lrotation) then + read(iu, *, iostat = ierr) self%Ip(1), self%Ip(2), self%Ip(3) + read(iu, *, iostat = ierr) self%rot(1), self%rot(2), self%rot(3) + end if else open(unit = iu, file = param%incbfile, status = 'old', form = 'UNFORMATTED', iostat = ierr) call self%read_frame(iu, param, XV, ierr) @@ -881,7 +911,6 @@ module subroutine io_read_cb_in(self, param) end subroutine io_read_cb_in - function io_read_encounter(t, name1, name2, mass1, mass2, radius1, radius2, & xh1, xh2, vh1, vh2, enc_out, out_type) result(ierr) !! author: David A. Minton @@ -978,7 +1007,7 @@ module subroutine io_read_frame_body(self, iu, param, form, ierr) read(iu, iostat=ierr, err=100) pl%Gmass(:) pl%mass(:) = pl%Gmass(:) / param%GU if (param%lrhill_present) read(iu, iostat=ierr, err=100) pl%rhill(:) - read(iu, iostat=ierr, err=100) pl%radius(:) + if (param%lclose) read(iu, iostat=ierr, err=100) pl%radius(:) if (param%lrotation) then read(iu, iostat=ierr, err=100) pl%rot(1, :) read(iu, iostat=ierr, err=100) pl%rot(2, :) @@ -1341,15 +1370,15 @@ module subroutine io_write_frame_body(self, iu, param) select type(pl => self) class is (swiftest_pl) ! Additional output if the passed polymorphic object is a massive body write(iu) pl%Gmass(1:n) - write(iu) pl%rhill(1:n) - write(iu) pl%radius(1:n) + if (param%lrhill_present) write(iu) pl%rhill(1:n) + if (param%lclose) write(iu) pl%radius(1:n) if (param%lrotation) then - write(iu) pl%rot(1, 1:n) - write(iu) pl%rot(2, 1:n) - write(iu) pl%rot(3, 1:n) write(iu) pl%Ip(1, 1:n) write(iu) pl%Ip(2, 1:n) write(iu) pl%Ip(3, 1:n) + write(iu) pl%rot(1, 1:n) + write(iu) pl%rot(2, 1:n) + write(iu) pl%rot(3, 1:n) end if if (param%ltides) then write(iu) pl%k2(1:n) @@ -1383,12 +1412,12 @@ module subroutine io_write_frame_cb(self, iu, param) write(iu) cb%j2rp2 write(iu) cb%j4rp4 if (param%lrotation) then - write(iu) cb%rot(1) - write(iu) cb%rot(2) - write(iu) cb%rot(3) write(iu) cb%Ip(1) write(iu) cb%Ip(2) write(iu) cb%Ip(3) + write(iu) cb%rot(1) + write(iu) cb%rot(2) + write(iu) cb%rot(3) end if if (param%ltides) then write(iu) cb%k2 diff --git a/src/main/swiftest_driver.f90 b/src/main/swiftest_driver.f90 index 55eb1bc89..5e28452e0 100644 --- a/src/main/swiftest_driver.f90 +++ b/src/main/swiftest_driver.f90 @@ -17,20 +17,14 @@ program swiftest_driver integer(I8B) :: iloop !! Loop counter integer(I8B) :: idump !! Dump cadence counter integer(I8B) :: iout !! Output cadence counter - !integer(I8B), parameter :: LOOPMAX = huge(iloop) !! Maximum loop value before resetting integer(I8B) :: nloops !! Number of steps to take in the simulation - real(DP) :: start_wall_time !! Wall clock time at start of execution - real(DP) :: finish_wall_time !! Wall clock time when execution has finished integer(I4B) :: iu !! Unit number of binary file - character(*),parameter :: statusfmt = '("Time = ", ES12.5, "; fraction done = ", F6.3, "; ' // & - 'Number of active pl, tp = ", I5, ", ", I5)' ierr = io_get_args(integrator, param_file_name) if (ierr /= 0) then write(*,*) 'Error reading in arguments from the command line' call util_exit(FAILURE) end if - !$ start_wall_time = omp_get_wtime() !> Read in the user-defined parameters file and the initial conditions of the system select case(integrator) case(symba) @@ -39,21 +33,26 @@ program swiftest_driver allocate(swiftest_parameters :: param) end select param%integrator = integrator + call setup_construct_system(nbody_system, param) call param%read_from_file(param_file_name) + associate(t => param%t, & t0 => param%t0, & dt => param%dt, & tstop => param%tstop, & istep_out => param%istep_out, & istep_dump => param%istep_dump) + call nbody_system%initialize(param) t = t0 iloop = 0 iout = istep_out idump = istep_dump - nloops = ceiling(tstop / dt) + nloops = ceiling(tstop / dt, kind=I8B) if (istep_out > 0) call nbody_system%write_frame(iu, param) + call nbody_system%dump(param) + !> Define the maximum number of threads nthreads = 1 ! In the *serial* case !$ nthreads = omp_get_max_threads() ! In the *parallel* case @@ -83,18 +82,13 @@ program swiftest_driver if (istep_dump > 0) then idump = idump - 1 if (idump == 0) then - call nbody_system%dump(param, statusfmt) + call nbody_system%dump(param) idump = istep_dump end if end if - !if (t >= tstop) exit end do - - !> Dump the final state of the system to file - !call nbody_system%dump(param, t, dt, statusfmt) - !$ finish_wall_time = omp_get_wtime() - !$ write(*,*) 'Time: ', finish_wall_time - start_wall_time end associate + call util_exit(SUCCESS) stop diff --git a/src/modules/rmvs_classes.f90 b/src/modules/rmvs_classes.f90 index 4f7255237..6ffb7ba1b 100644 --- a/src/modules/rmvs_classes.f90 +++ b/src/modules/rmvs_classes.f90 @@ -163,7 +163,7 @@ module subroutine rmvs_util_append_pl(self, source, lsource_mask) implicit none class(rmvs_pl), intent(inout) :: self !! RMVS massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine rmvs_util_append_pl module subroutine rmvs_util_append_tp(self, source, lsource_mask) @@ -171,7 +171,7 @@ module subroutine rmvs_util_append_tp(self, source, lsource_mask) implicit none class(rmvs_tp), intent(inout) :: self !! RMVS test particle object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine rmvs_util_append_tp module subroutine rmvs_util_fill_pl(self, inserts, lfill_list) diff --git a/src/modules/swiftest_classes.f90 b/src/modules/swiftest_classes.f90 index 2455e77f2..2e4bff8a2 100644 --- a/src/modules/swiftest_classes.f90 +++ b/src/modules/swiftest_classes.f90 @@ -45,7 +45,7 @@ module swiftest_classes real(QP) :: DU2M = -1.0_QP !! Converts distance unit to centimeters real(DP) :: GU = -1.0_DP !! Universal gravitational constant in the system units real(DP) :: inv_c2 = -1.0_DP !! Inverse speed of light squared in the system units - character(STRMAX) :: ennergy_out = "" !! Name of output energy and momentum report file + character(STRMAX) :: energy_out = "" !! Name of output energy and momentum report file ! Logical flags to turn on or off various features of the code logical :: lrhill_present = .false. !! Hill radii are given as an input rather than calculated by the code (can be used to inflate close encounter regions manually) @@ -64,13 +64,14 @@ module swiftest_classes real(DP), dimension(NDIM) :: Ltot_orig = 0.0_DP !! Initial total angular momentum vector real(DP), dimension(NDIM) :: Lorbit_orig = 0.0_DP !! Initial orbital angular momentum real(DP), dimension(NDIM) :: Lspin_orig = 0.0_DP !! Initial spin angular momentum vector - real(DP), dimension(NDIM) :: Ltot = 0.0_DP !! System angular momentum vector - real(DP), dimension(NDIM) :: Lescape = 0.0_DP !! Angular momentum of bodies that escaped the system (used for bookeeping) - real(DP) :: Mescape = 0.0_DP !! Mass of bodies that escaped the system (used for bookeeping) - real(DP) :: Ecollisions = 0.0_DP !! Energy lost from system due to collisions - real(DP) :: Euntracked = 0.0_DP !! Energy gained from system due to escaped bodies + real(DP), dimension(NDIM) :: Ltot = 0.0_DP !! System angular momentum vector + real(DP), dimension(NDIM) :: Lescape = 0.0_DP !! Angular momentum of bodies that escaped the system (used for bookeeping) + real(DP) :: Mescape = 0.0_DP !! Mass of bodies that escaped the system (used for bookeeping) + real(DP) :: Ecollisions = 0.0_DP !! Energy lost from system due to collisions + real(DP) :: Euntracked = 0.0_DP !! Energy gained from system due to escaped bodies logical :: lfirstenergy = .true. !! This is the first time computing energe logical :: lfirstkick = .true. !! Initiate the first kick in a symplectic step + logical :: lrestart = .false. !! Indicates whether or not this is a restarted run ! Future features not implemented or in development logical :: lgr = .false. !! Turn on GR @@ -275,6 +276,7 @@ module swiftest_classes class(swiftest_pl), allocatable :: pl !! Massive body data structure class(swiftest_tp), allocatable :: tp !! Test particle data structure class(swiftest_tp), allocatable :: tp_discards !! Discarded test particle data structure + class(swiftest_pl), allocatable :: pl_discards !! Discarded massive body particle data structure real(DP) :: Gmtot = 0.0_DP !! Total system mass - used for barycentric coordinate conversion real(DP) :: ke_orbit = 0.0_DP !! System orbital kinetic energy real(DP) :: ke_spin = 0.0_DP !! System spin kinetic energy @@ -305,6 +307,8 @@ module swiftest_classes procedure :: step_spin => tides_step_spin_system !! Steps the spins of the massive & central bodies due to tides. procedure :: set_msys => util_set_msys !! Sets the value of msys from the masses of system bodies. procedure :: get_energy_and_momentum => util_get_energy_momentum_system !! Calculates the total system energy and momentum + procedure :: rescale => util_rescale_system !! Rescales the system into a new set of units + procedure :: validate_ids => util_valid_id_system !! Validate the numerical ids passed to the system and save the maximum value end type swiftest_nbody_system type :: swiftest_encounter @@ -456,26 +460,26 @@ module subroutine eucl_dist_index_plpl(self) module subroutine fragmentation_initialize(system, param, family, x, v, L_spin, Ip, mass, radius, & nfrag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, Qloss, lfailure) implicit none - class(swiftest_nbody_system), intent(inout) :: system - class(swiftest_parameters), intent(in) :: param - integer(I4B), dimension(:), intent(in) :: family - real(DP), dimension(:,:), intent(inout) :: x, v, L_spin, Ip - real(DP), dimension(:), intent(inout) :: mass, radius - integer(I4B), intent(inout) :: nfrag - real(DP), dimension(:), allocatable, intent(inout) :: m_frag, rad_frag - real(DP), dimension(:,:), allocatable, intent(inout) :: Ip_frag - real(DP), dimension(:,:), allocatable, intent(inout) :: xb_frag, vb_frag, rot_frag - logical, intent(out) :: lfailure ! Answers the question: Should this have been a merger instead? - real(DP), intent(inout) :: Qloss + class(swiftest_nbody_system), intent(inout) :: system !! Swiftest nbody system object + class(swiftest_parameters), intent(in) :: param !! Current run configuration parameters + integer(I4B), dimension(:), intent(in) :: family !! Index of bodies involved in the collision + real(DP), dimension(:,:), intent(inout) :: x, v, L_spin, Ip !! Two-body equivalent position, vector, spin momentum, and rotational inertia values for the collision + real(DP), dimension(:), intent(inout) :: mass, radius !! Two-body equivalent mass and radii for the bodies in the collision + integer(I4B), intent(inout) :: nfrag !! Number of fragments to generate + real(DP), dimension(:), allocatable, intent(inout) :: m_frag, rad_frag !! Distribution of fragment mass and radii + real(DP), dimension(:,:), allocatable, intent(inout) :: Ip_frag !! Fragment rotational inertia vectors + real(DP), dimension(:,:), allocatable, intent(inout) :: xb_frag, vb_frag, rot_frag !! Fragment barycentric position, barycentric velocity, and rotation vectors + real(DP), intent(inout) :: Qloss !! Energy lost during the collision + logical, intent(out) :: lfailure !! Answers the question: Should this have been a merger instead? end subroutine fragmentation_initialize module subroutine fragmentation_regime(Mcb, m1, m2, rad1, rad2, xh1, xh2, vb1, vb2, den1, den2, regime, Mlr, Mslr, mtiny, Qloss) implicit none - integer(I4B), intent(out) :: regime - real(DP), intent(out) :: Mlr, Mslr - real(DP), intent(in) :: Mcb, m1, m2, rad1, rad2, den1, den2, mtiny - real(DP), dimension(:), intent(in) :: xh1, xh2, vb1, vb2 - real(DP), intent(out) :: Qloss !! The residual energy after the collision + integer(I4B), intent(out) :: regime + real(DP), intent(out) :: Mlr, Mslr + real(DP), intent(in) :: Mcb, m1, m2, rad1, rad2, den1, den2, mtiny + real(DP), dimension(:), intent(in) :: xh1, xh2, vb1, vb2 + real(DP), intent(out) :: Qloss !! Energy lost during the collision end subroutine fragmentation_regime module pure subroutine gr_kick_getaccb_ns_body(self, system, param) @@ -546,18 +550,16 @@ module subroutine io_dump_param(self, param_file_name) character(len=*), intent(in) :: param_file_name !! Parameter input file name (i.e. param.in) end subroutine io_dump_param - module subroutine io_dump_swiftest(self, param, msg) + module subroutine io_dump_swiftest(self, param) implicit none class(swiftest_base), intent(inout) :: self !! Swiftest base object class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), optional, intent(in) :: msg !! Message to display with dump operation end subroutine io_dump_swiftest - module subroutine io_dump_system(self, param, msg) + module subroutine io_dump_system(self, param) implicit none class(swiftest_nbody_system), intent(inout) :: self !! Swiftest system object class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), optional, intent(in) :: msg !! Message to display with dump operation end subroutine io_dump_system module function io_get_args(integrator, param_file_name) result(ierr) @@ -829,39 +831,44 @@ end subroutine user_kick_getacch_body end interface interface util_append - module subroutine util_append_arr_char_string(arr, source, lsource_mask) + module subroutine util_append_arr_char_string(arr, source, nold, nsrc, lsource_mask) implicit none character(len=STRMAX), dimension(:), allocatable, intent(inout) :: arr !! Destination array character(len=STRMAX), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_arr_char_string - module subroutine util_append_arr_DP(arr, source, lsource_mask) + module subroutine util_append_arr_DP(arr, source, nold, nsrc, lsource_mask) implicit none real(DP), dimension(:), allocatable, intent(inout) :: arr !! Destination array real(DP), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_arr_DP - module subroutine util_append_arr_DPvec(arr, source, lsource_mask) + module subroutine util_append_arr_DPvec(arr, source, nold, nsrc, lsource_mask) implicit none real(DP), dimension(:,:), allocatable, intent(inout) :: arr !! Destination array real(DP), dimension(:,:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_arr_DPvec - module subroutine util_append_arr_I4B(arr, source, lsource_mask) + module subroutine util_append_arr_I4B(arr, source, nold, nsrc, lsource_mask) implicit none integer(I4B), dimension(:), allocatable, intent(inout) :: arr !! Destination array integer(I4B), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_arr_I4B - module subroutine util_append_arr_logical(arr, source, lsource_mask) + module subroutine util_append_arr_logical(arr, source, nold, nsrc, lsource_mask) implicit none logical, dimension(:), allocatable, intent(inout) :: arr !! Destination array logical, dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_arr_logical end interface @@ -869,22 +876,22 @@ end subroutine util_append_arr_logical module subroutine util_append_body(self, source, lsource_mask) implicit none class(swiftest_body), intent(inout) :: self !! Swiftest body object - class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + class(swiftest_body), intent(in) :: source !! Source object to append + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_body module subroutine util_append_pl(self, source, lsource_mask) implicit none class(swiftest_pl), intent(inout) :: self !! Swiftest massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_pl module subroutine util_append_tp(self, source, lsource_mask) implicit none class(swiftest_tp), intent(inout) :: self !! Swiftest test particle object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine util_append_tp module subroutine util_coord_b2h_pl(self, cb) @@ -982,6 +989,13 @@ end subroutine util_fill_arr_logical end interface interface + module subroutine util_rescale_system(self, param, mscale, dscale, tscale) + implicit none + class(swiftest_nbody_system), intent(inout) :: self !! Swiftest nbody system object + class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters. Returns with new values of the scale vactors and GU + real(DP), intent(in) :: mscale, dscale, tscale !! Scale factors for mass, distance, and time units, respectively. + end subroutine util_rescale_system + module function util_minimize_bfgs(f, N, x0, eps, lerr) result(x1) use lambda_function implicit none @@ -1001,38 +1015,6 @@ module subroutine util_peri_tp(self, system, param) end subroutine util_peri_tp end interface - interface util_solve_linear_system - module function util_solve_linear_system_d(A,b,n,lerr) result(x) - implicit none - integer(I4B), intent(in) :: n - real(DP), dimension(:,:), intent(in) :: A - real(DP), dimension(:), intent(in) :: b - logical, intent(out) :: lerr - real(DP), dimension(n) :: x - end function util_solve_linear_system_d - - module function util_solve_linear_system_q(A,b,n,lerr) result(x) - implicit none - integer(I4B), intent(in) :: n - real(QP), dimension(:,:), intent(in) :: A - real(QP), dimension(:), intent(in) :: b - logical, intent(out) :: lerr - real(QP), dimension(n) :: x - end function util_solve_linear_system_q - end interface - - interface - module function util_solve_rkf45(f, y0in, t1, dt0, tol) result(y1) - use lambda_function - implicit none - class(lambda_obj), intent(inout) :: f !! lambda function object that has been initialized to be a function of derivatives. The object will return with components lastarg and lasteval set - real(DP), dimension(:), intent(in) :: y0in !! Initial value at t=0 - real(DP), intent(in) :: t1 !! Final time - real(DP), intent(in) :: dt0 !! Initial step size guess - real(DP), intent(in) :: tol !! Tolerance on solution - real(DP), dimension(:), allocatable :: y1 !! Final result - end function util_solve_rkf45 - end interface interface util_resize module subroutine util_resize_arr_char_string(arr, nnew) @@ -1140,6 +1122,39 @@ module subroutine util_set_rhill_approximate(self,cb) end subroutine util_set_rhill_approximate end interface + interface util_solve_linear_system + module function util_solve_linear_system_d(A,b,n,lerr) result(x) + implicit none + integer(I4B), intent(in) :: n + real(DP), dimension(:,:), intent(in) :: A + real(DP), dimension(:), intent(in) :: b + logical, intent(out) :: lerr + real(DP), dimension(n) :: x + end function util_solve_linear_system_d + + module function util_solve_linear_system_q(A,b,n,lerr) result(x) + implicit none + integer(I4B), intent(in) :: n + real(QP), dimension(:,:), intent(in) :: A + real(QP), dimension(:), intent(in) :: b + logical, intent(out) :: lerr + real(QP), dimension(n) :: x + end function util_solve_linear_system_q + end interface + + interface + module function util_solve_rkf45(f, y0in, t1, dt0, tol) result(y1) + use lambda_function + implicit none + class(lambda_obj), intent(inout) :: f !! lambda function object that has been initialized to be a function of derivatives. The object will return with components lastarg and lasteval set + real(DP), dimension(:), intent(in) :: y0in !! Initial value at t=0 + real(DP), intent(in) :: t1 !! Final time + real(DP), intent(in) :: dt0 !! Initial step size guess + real(DP), intent(in) :: tol !! Tolerance on solution + real(DP), dimension(:), allocatable :: y1 !! Final result + end function util_solve_rkf45 + end interface + interface util_sort module subroutine util_sort_i4b(arr) implicit none @@ -1291,11 +1306,11 @@ module subroutine util_spill_tp(self, discards, lspill_list, ldestructive) logical, intent(in) :: ldestructive !! Logical flag indicating whether or not this operation should alter the keeps array or not end subroutine util_spill_tp - module subroutine util_valid(pl, tp) + module subroutine util_valid_id_system(self, param) implicit none - class(swiftest_pl), intent(in) :: pl - class(swiftest_tp), intent(in) :: tp - end subroutine util_valid + class(swiftest_nbody_system), intent(inout) :: self !! Swiftest nbody system object + class(swiftest_parameters), intent(in) :: param !! Current run configuration parameters + end subroutine util_valid_id_system module subroutine util_version() implicit none diff --git a/src/modules/symba_classes.f90 b/src/modules/symba_classes.f90 index 0e66ebf7c..4628202f8 100644 --- a/src/modules/symba_classes.f90 +++ b/src/modules/symba_classes.f90 @@ -18,8 +18,8 @@ module symba_classes integer(I4B), parameter :: PARTICLEUNIT = 44 !! File unit number for the binary particle info output file type, extends(swiftest_parameters) :: symba_parameters - character(STRMAX) :: particle_file = PARTICLE_OUTFILE !! Name of output particle information file - real(DP) :: MTINY = -1.0_DP !! Smallest mass that is fully gravitating + character(STRMAX) :: particle_out = PARTICLE_OUTFILE !! Name of output particle information file + real(DP) :: GMTINY = -1.0_DP !! Smallest mass that is fully gravitating integer(I4B), dimension(:), allocatable :: seed !! Random seeds logical :: lfragmentation = .false. !! Do fragmentation modeling instead of simple merger. contains @@ -27,33 +27,17 @@ module symba_classes procedure :: writer => symba_io_param_writer end type symba_parameters - !******************************************************************************************************************************** - ! symba_cb class definitions and method interfaces - !******************************************************************************************************************************* - !> SyMBA central body particle class - type, extends(helio_cb) :: symba_cb - real(DP) :: M0 = 0.0_DP !! Initial mass of the central body - real(DP) :: dM = 0.0_DP !! Change in mass of the central body - real(DP) :: R0 = 0.0_DP !! Initial radius of the central body - real(DP) :: dR = 0.0_DP !! Change in the radius of the central body - contains - end type symba_cb - !******************************************************************************************************************************** ! symba_particle_info class definitions and method interfaces !******************************************************************************************************************************* !> Class definition for the particle origin information object. This object is used to track time, location, and collisional regime !> of fragments produced in collisional events. - type, extends(swiftest_base) :: symba_particle_info + type :: symba_particle_info + sequence character(len=32) :: origin_type !! String containing a description of the origin of the particle (e.g. Initial Conditions, Supercatastrophic, Disruption, etc.) real(DP) :: origin_time !! The time of the particle's formation real(DP), dimension(NDIM) :: origin_xh !! The heliocentric distance vector at the time of the particle's formation real(DP), dimension(NDIM) :: origin_vh !! The heliocentric velocity vector at the time of the particle's formation - contains - procedure :: dump => symba_io_dump_particle_info !! I/O routine for dumping particle info to file - procedure :: initialize => symba_io_initialize_particle_info !! I/O routine for reading in particle info data - procedure :: read_frame => symba_io_read_frame_info !! I/O routine for reading in a single frame of particle info - procedure :: write_frame => symba_io_write_frame_info !! I/O routine for writing out a single frame of particle info end type symba_particle_info !******************************************************************************************************************************** @@ -66,6 +50,19 @@ module symba_classes integer(I4B), dimension(:), allocatable :: child !! Index of children particles end type symba_kinship + !******************************************************************************************************************************** + ! symba_cb class definitions and method interfaces + !******************************************************************************************************************************* + !> SyMBA central body particle class + type, extends(helio_cb) :: symba_cb + real(DP) :: M0 = 0.0_DP !! Initial mass of the central body + real(DP) :: dM = 0.0_DP !! Change in mass of the central body + real(DP) :: R0 = 0.0_DP !! Initial radius of the central body + real(DP) :: dR = 0.0_DP !! Change in the radius of the central body + type(symba_particle_info) :: info + contains + end type symba_cb + !******************************************************************************************************************************** ! symba_pl class definitions and method interfaces !******************************************************************************************************************************* @@ -73,9 +70,9 @@ module symba_classes type, extends(helio_pl) :: symba_pl logical, dimension(:), allocatable :: lcollision !! flag indicating whether body has merged with another this time step logical, dimension(:), allocatable :: lencounter !! flag indicating whether body is part of an encounter this time step - logical, dimension(:), allocatable :: lmtiny !! flag indicating whether this body is below the MTINY cutoff value - integer(I4B) :: nplm !! number of bodies above the MTINY limit - integer(I8B) :: nplplm !! Number of body (all massive)-body (only those above MTINY) comparisons in the flattened upper triangular matrix + logical, dimension(:), allocatable :: lmtiny !! flag indicating whether this body is below the GMTINY cutoff value + integer(I4B) :: nplm !! number of bodies above the GMTINY limit + integer(I8B) :: nplplm !! Number of body (all massive)-body (only those above GMTINY) comparisons in the flattened upper triangular matrix integer(I4B), dimension(:), allocatable :: nplenc !! number of encounters with other planets this time step integer(I4B), dimension(:), allocatable :: ntpenc !! number of encounters with test particles this time step integer(I4B), dimension(:), allocatable :: levelg !! level at which this body should be moved @@ -118,6 +115,7 @@ module symba_classes integer(I4B), dimension(:), allocatable :: nplenc !! number of encounters with planets this time step integer(I4B), dimension(:), allocatable :: levelg !! level at which this particle should be moved integer(I4B), dimension(:), allocatable :: levelm !! deepest encounter level achieved this time step + type(symba_particle_info), dimension(:), allocatable :: info contains procedure :: drift => symba_drift_tp !! Method for Danby drift in Democratic Heliocentric coordinates. Sets the mask to the current recursion level procedure :: encounter_check => symba_encounter_check_tp !! Checks if any test particles are undergoing a close encounter with a massive body @@ -160,8 +158,7 @@ module symba_classes ! symba_nbody_system class definitions and method interfaces !******************************************************************************************************************************** type, extends(helio_nbody_system) :: symba_nbody_system - class(symba_merger), allocatable :: mergeadd_list !! List of added bodies in mergers or collisions - class(symba_merger), allocatable :: mergesub_list !! List of subtracted bodies in mergers or collisions + class(symba_merger), allocatable :: pl_adds !! List of added bodies in mergers or collisions class(symba_pltpenc), allocatable :: pltpenc_list !! List of massive body-test particle encounters in a single step class(symba_plplenc), allocatable :: plplenc_list !! List of massive body-massive body encounters in a single step integer(I4B) :: irec !! System recursion level @@ -328,12 +325,13 @@ module subroutine symba_io_write_discard(self, param) class(swiftest_parameters), intent(in) :: param !! Current run configuration parameters end subroutine symba_io_write_discard - module subroutine symba_io_dump_particle_info(self, param, msg) - use swiftest_classes, only : swiftest_parameters + module subroutine symba_io_dump_particle_info(system, param, lincludecb, tpidx, plidx) implicit none - class(symba_particle_info), intent(inout) :: self !! Swiftest base object - class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), optional, intent(in) :: msg !! Message to display with dump operation + class(symba_nbody_system), intent(inout) :: system !! SyMBA nbody system object + class(symba_parameters), intent(in) :: param !! Current run configuration parameters with SyMBA extensions + logical, optional, intent(in) :: lincludecb !! Set to true to include the central body (default is false) + integer(I4B), dimension(:), optional, intent(in) :: tpidx !! Array of test particle indices to append to the particle file + integer(I4B), dimension(:), optional, intent(in) :: plidx !! Array of massive body indices to append to the particle file end subroutine symba_io_dump_particle_info module subroutine symba_io_param_reader(self, unit, iotype, v_list, iostat, iomsg) @@ -357,23 +355,12 @@ module subroutine symba_io_param_writer(self, unit, iotype, v_list, iostat, ioms integer, intent(out) :: iostat !! IO status code character(len=*), intent(inout) :: iomsg !! Message to pass if iostat /= 0 end subroutine symba_io_param_writer - - module subroutine symba_io_initialize_particle_info(self, param) - use swiftest_classes, only : swiftest_parameters - implicit none - class(symba_particle_info), intent(inout) :: self !! SyMBA particle info object - class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - end subroutine symba_io_initialize_particle_info - module subroutine symba_io_read_frame_info(self, iu, param, form, ierr) - use swiftest_classes, only : swiftest_parameters + module subroutine symba_io_read_particle(system, param) implicit none - class(symba_particle_info), intent(inout) :: self !! SyMBA particle info object - integer(I4B), intent(inout) :: iu !! Unit number for the output file to write frame to - class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), intent(in) :: form !! Input format code ("XV" or "EL") - integer(I4B), intent(out) :: ierr !! Error code - end subroutine symba_io_read_frame_info + class(symba_nbody_system), intent(inout) :: system !! SyMBA nbody system file + class(symba_parameters), intent(inout) :: param !! Current run configuration parameters with SyMBA extensions + end subroutine symba_io_read_particle module subroutine symba_kick_getacch_pl(self, system, param, t, lbeg) use swiftest_classes, only : swiftest_nbody_system, swiftest_parameters @@ -403,14 +390,12 @@ module subroutine symba_kick_pltpenc(self, system, dt, irec, sgn) integer(I4B), intent(in) :: irec !! Current recursion level integer(I4B), intent(in) :: sgn !! sign to be applied to acceleration end subroutine symba_kick_pltpenc - - module subroutine symba_io_write_frame_info(self, iu, param) - use swiftest_classes, only : swiftest_parameters + + module subroutine symba_setup_initialize_particle_info(system, param) implicit none - class(symba_particle_info), intent(in) :: self !! SyMBA particle info object - integer(I4B), intent(inout) :: iu !! Unit number for the output file to write frame to - class(swiftest_parameters), intent(in) :: param !! Current run configuration parameters - end subroutine symba_io_write_frame_info + class(symba_nbody_system), intent(inout) :: system !! SyMBA nbody system object + class(symba_parameters), intent(inout) :: param !! Current run configuration parameters with SyMBA extensions + end subroutine symba_setup_initialize_particle_info module subroutine symba_setup_initialize_system(self, param) use swiftest_classes, only : swiftest_parameters @@ -489,18 +474,20 @@ end subroutine symba_step_reset_system end interface interface util_append - module subroutine symba_util_append_arr_info(arr, source, lsource_mask) + module subroutine symba_util_append_arr_info(arr, source, nold, nsrc, lsource_mask) implicit none type(symba_particle_info), dimension(:), allocatable, intent(inout) :: arr !! Destination array type(symba_particle_info), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine symba_util_append_arr_info - module subroutine symba_util_append_arr_kin(arr, source, lsource_mask) + module subroutine symba_util_append_arr_kin(arr, source, nold, nsrc, lsource_mask) implicit none type(symba_kinship), dimension(:), allocatable, intent(inout) :: arr !! Destination array type(symba_kinship), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine symba_util_append_arr_kin end interface @@ -510,7 +497,7 @@ module subroutine symba_util_append_merger(self, source, lsource_mask) implicit none class(symba_merger), intent(inout) :: self !! SyMBA massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine symba_util_append_merger module subroutine symba_util_append_pl(self, source, lsource_mask) @@ -518,7 +505,7 @@ module subroutine symba_util_append_pl(self, source, lsource_mask) implicit none class(symba_pl), intent(inout) :: self !! SyMBA massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine symba_util_append_pl module subroutine symba_util_append_tp(self, source, lsource_mask) @@ -526,7 +513,7 @@ module subroutine symba_util_append_tp(self, source, lsource_mask) implicit none class(symba_tp), intent(inout) :: self !! SyMBA test particle object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine symba_util_append_tp end interface diff --git a/src/modules/whm_classes.f90 b/src/modules/whm_classes.f90 index a79f52bca..6d5b26394 100644 --- a/src/modules/whm_classes.f90 +++ b/src/modules/whm_classes.f90 @@ -232,7 +232,7 @@ module subroutine whm_util_append_pl(self, source, lsource_mask) implicit none class(whm_pl), intent(inout) :: self !! WHM massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to end subroutine whm_util_append_pl module subroutine whm_util_spill_pl(self, discards, lspill_list, ldestructive) diff --git a/src/rmvs/rmvs_util.f90 b/src/rmvs/rmvs_util.f90 index 9f9cf0037..ee9ce6932 100644 --- a/src/rmvs/rmvs_util.f90 +++ b/src/rmvs/rmvs_util.f90 @@ -11,21 +11,23 @@ module subroutine rmvs_util_append_pl(self, source, lsource_mask) !! Arguments class(rmvs_pl), intent(inout) :: self !! RMVS massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to select type(source) class is (rmvs_pl) - call whm_util_append_pl(self, source, lsource_mask) + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%nenc, source%nenc, nold, nsrc, lsource_mask) + call util_append(self%tpenc1P, source%tpenc1P, nold, nsrc, lsource_mask) + call util_append(self%plind, source%plind, nold, nsrc, lsource_mask) - call util_append(self%nenc, source%nenc, lsource_mask) - call util_append(self%tpenc1P, source%tpenc1P, lsource_mask) - call util_append(self%plind, source%plind, lsource_mask) + ! The following are not implemented as RMVS doesn't make use of fill operations on pl type + ! So they are here as a placeholder in case someone wants to extend the RMVS class for some reason + !call util_append(self%outer, source%outer, nold, nsrc, lsource_mask) + !call util_append(self%inner, source%inner, nold, nsrc, lsource_mask) + !call util_append(self%planetocentric, source%planetocentric, nold, nsrc, lsource_mask) - ! The following are not implemented as RMVS doesn't make use of fill operations on pl type - ! So they are here as a placeholder in case someone wants to extend the RMVS class for some reason - !call util_append(self%outer, source%outer, lsource_mask) - !call util_append(self%inner, source%inner, lsource_mask) - !call util_append(self%planetocentric, source%planetocentric, lsource_mask) + call whm_util_append_pl(self, source, lsource_mask) + end associate class default write(*,*) "Invalid object passed to the append method. Source must be of class rmvs_pl or its descendents!" call util_exit(FAILURE) @@ -44,15 +46,17 @@ module subroutine rmvs_util_append_tp(self, source, lsource_mask) !! Arguments class(rmvs_tp), intent(inout) :: self !! RMVS test particle object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to select type(source) class is (rmvs_tp) - call util_append_tp(self, source, lsource_mask) ! Note: whm_tp does not have its own append method, so we skip back to the base class + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%lperi, source%lperi, nold, nsrc, lsource_mask) + call util_append(self%plperP, source%plperP, nold, nsrc, lsource_mask) + call util_append(self%plencP, source%plencP, nold, nsrc, lsource_mask) - call util_append(self%lperi, source%lperi, lsource_mask) - call util_append(self%plperP, source%plperP, lsource_mask) - call util_append(self%plencP, source%plencP, lsource_mask) + call util_append_tp(self, source, lsource_mask) ! Note: whm_tp does not have its own append method, so we skip back to the base class + end associate class default write(*,*) "Invalid object passed to the append method. Source must be of class rmvs_tp or its descendents!" call util_exit(FAILURE) @@ -139,8 +143,6 @@ module subroutine rmvs_util_resize_pl(self, nnew) class(rmvs_pl), intent(inout) :: self !! RMVS massive body object integer(I4B), intent(in) :: nnew !! New size neded - call whm_util_resize_pl(self, nnew) - call util_resize(self%nenc, nnew) call util_resize(self%tpenc1P, nnew) call util_resize(self%plind, nnew) @@ -151,6 +153,7 @@ module subroutine rmvs_util_resize_pl(self, nnew) !call util_resize(self%inner, nnew) !call util_resize(self%planetocentric, nnew) + call whm_util_resize_pl(self, nnew) return end subroutine rmvs_util_resize_pl @@ -164,13 +167,13 @@ module subroutine rmvs_util_resize_tp(self, nnew) class(rmvs_tp), intent(inout) :: self !! RMVS test particle object integer(I4B), intent(in) :: nnew !! New size neded - call util_resize_tp(self, nnew) - call util_resize(self%lperi, nnew) call util_resize(self%plperP, nnew) call util_resize(self%plencP, nnew) call util_resize(self%xheliocentric, nnew) + call util_resize_tp(self, nnew) + return end subroutine rmvs_util_resize_tp diff --git a/src/setup/setup.f90 b/src/setup/setup.f90 index 6cba6d27b..8f96c48a1 100644 --- a/src/setup/setup.f90 +++ b/src/setup/setup.f90 @@ -54,8 +54,8 @@ module subroutine setup_construct_system(system, param) allocate(symba_pl :: system%pl) allocate(symba_tp :: system%tp) allocate(symba_tp :: system%tp_discards) - allocate(symba_merger :: system%mergeadd_list) - allocate(symba_merger :: system%mergesub_list) + allocate(symba_merger :: system%pl_adds) + allocate(symba_merger :: system%pl_discards) allocate(symba_plplenc :: system%plplenc_list) allocate(symba_pltpenc :: system%pltpenc_list) end select @@ -127,14 +127,12 @@ module subroutine setup_initialize_system(self, param) call self%cb%initialize(param) call self%pl%initialize(param) call self%tp%initialize(param) - call util_valid(self%pl, self%tp) - self%maxid = maxval([self%pl%id(:), self%tp%id(:)]) + call self%validate_ids(param) call self%set_msys() call self%pl%set_mu(self%cb) call self%tp%set_mu(self%cb) call self%pl%eucl_index() if (.not.param%lrhill_present) call self%pl%set_rhill(self%cb) - !if (param%lfirstenergy) then return end subroutine setup_initialize_system diff --git a/src/symba/symba_collision.f90 b/src/symba/symba_collision.f90 index 952d59709..1910411b9 100644 --- a/src/symba/symba_collision.f90 +++ b/src/symba/symba_collision.f90 @@ -22,7 +22,7 @@ module subroutine symba_collision_check_pltpenc(self, system, param, t, dt, irec logical, dimension(:), allocatable :: lcollision, lmask real(DP), dimension(NDIM) :: xr, vr integer(I4B) :: k - real(DP) :: rlim, mtot + real(DP) :: rlim, Gmtot logical :: isplpl if (self%nenc == 0) return @@ -55,8 +55,8 @@ module subroutine symba_collision_check_pltpenc(self, system, param, t, dt, irec xr(:) = pl%xh(:, ind1(k)) - pl%xh(:, ind2(k)) vr(:) = pl%vb(:, ind1(k)) - pl%vb(:, ind2(k)) rlim = pl%radius(ind1(k)) + pl%radius(ind2(k)) - mtot = pl%Gmass(ind1(k)) + pl%Gmass(ind2(k)) - lcollision(k) = symba_collision_check_one(xr(1), xr(2), xr(3), vr(1), vr(2), vr(3), mtot, rlim, dt, self%lvdotr(k)) + Gmtot = pl%Gmass(ind1(k)) + pl%Gmass(ind2(k)) + lcollision(k) = symba_collision_check_one(xr(1), xr(2), xr(3), vr(1), vr(2), vr(3), Gmtot, rlim, dt, self%lvdotr(k)) end do else do concurrent(k = 1:nenc, lmask(k)) @@ -359,7 +359,7 @@ module subroutine symba_collision_make_family_pl(self, idx) p2 = pl%kin(idx(2))%parent if (p1 == p2) return ! This is a collision between to children of a shared parent. We will ignore it. - if (pl%Gmass(p1) > pl%Gmass(p2)) then + if (pl%mass(p1) > pl%mass(p2)) then index_parent = p1 index_child = p2 else @@ -449,7 +449,7 @@ module subroutine symba_collision_resolve_fragmentations(self, system, param) v2_si(:) = plpl_collisions%v2(:,i) * param%DU2M / param%TU2S !! The velocity of the parent from inside the step (at collision) density_si(:) = mass_si(:) / (4.0_DP / 3._DP * PI * radius_si(:)**3) !! The collective density of the parent and its children Mcb_si = cb%mass * param%MU2KG - mtiny_si = (param%MTINY / param%GU) * param%MU2KG + mtiny_si = (param%GMTINY / param%GU) * param%MU2KG mass_res(:) = 0.0_DP @@ -463,8 +463,8 @@ module subroutine symba_collision_resolve_fragmentations(self, system, param) mass_res(1) = min(max(mlr, 0.0_DP), mtot) mass_res(2) = min(max(mslr, 0.0_DP), mtot) mass_res(3) = min(max(mtot - mlr - mslr, 0.0_DP), mtot) - mass_res(:) = (mass_res(:) / param%MU2KG) * param%GU - Qloss = Qloss * (param%GU / param%MU2KG) * (param%TU2S / param%DU2M)**2 + mass_res(:) = (mass_res(:) / param%MU2KG) + Qloss = Qloss * (param%TU2S / param%DU2M)**2 / param%MU2KG select case (regime) case (COLLRESOLVE_REGIME_DISRUPTION) diff --git a/src/symba/symba_discard.f90 b/src/symba/symba_discard.f90 index 5f6d3926a..253fb2700 100644 --- a/src/symba/symba_discard.f90 +++ b/src/symba/symba_discard.f90 @@ -271,7 +271,6 @@ subroutine symba_discard_peri_pl(pl, system, param) pl%lfirst = lfirst_orig return - end subroutine symba_discard_peri_pl @@ -285,6 +284,8 @@ module subroutine symba_discard_pl(self, system, param) class(symba_pl), intent(inout) :: self !! SyMBA test particle object class(swiftest_nbody_system), intent(inout) :: system !! Swiftest nbody system object class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters + ! Internals + real(DP) :: Eorbit_before, Eorbit_after select type(system) class is (symba_nbody_system) @@ -309,8 +310,17 @@ module subroutine symba_discard_pl(self, system, param) end if if (any(pl%ldiscard(:))) then + if (param%lenergy) then + call system%get_energy_and_momentum(param) + Eorbit_before = system%te + end if call symba_discard_nonplpl_conservation(self, system, param) call pl%rearray(system, param) + if (param%lenergy) then + call system%get_energy_and_momentum(param) + Eorbit_after = system%te + system%Ecollisions = Eorbit_after - Eorbit_before + end if end if end associate diff --git a/src/symba/symba_fragmentation.f90 b/src/symba/symba_fragmentation.f90 index efdd8c0d7..b36c54e9a 100644 --- a/src/symba/symba_fragmentation.f90 +++ b/src/symba/symba_fragmentation.f90 @@ -28,122 +28,63 @@ module function symba_fragmentation_casedisruption(system, param, family, x, v, real(DP), dimension(2) :: vol real(DP), dimension(:, :), allocatable :: vb_frag, xb_frag, rot_frag, Ip_frag real(DP), dimension(:), allocatable :: m_frag, rad_frag + integer(I4B), dimension(:), allocatable :: id_frag logical :: lfailure - logical, dimension(system%pl%nbody) :: lmask - class(symba_pl), allocatable :: plnew - select type(pl => system%pl) - class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) - ! Collisional fragments will be uniformly distributed around the pre-impact barycenter - nfrag = NFRAG_DISRUPT - allocate(m_frag(nfrag)) - allocate(rad_frag(nfrag)) - allocate(xb_frag(NDIM, nfrag)) - allocate(vb_frag(NDIM, nfrag)) - allocate(rot_frag(NDIM, nfrag)) - allocate(Ip_frag(NDIM, nfrag)) - - mtot = sum(mass(:)) - xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot - vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot - - ! Get mass weighted mean of Ip and average density - Ip_new(:) = (mass(1) * Ip(:,1) + mass(2) * Ip(:,2)) / mtot - vol(:) = 4._DP / 3._DP * PI * radius(:)**3 - avg_dens = mtot / sum(vol(:)) - - ! Distribute the mass among fragments, with a branch to check for the size of the second largest fragment - m_frag(1) = mass_res(1) - if (mass_res(2) > mass_res(1) / 3._DP) then - m_frag(2) = mass_res(2) - istart = 3 - else - istart = 2 - end if - ! Distribute remaining mass among the remaining bodies - do i = istart, nfrag - m_frag(i) = (mtot - sum(m_frag(1:istart - 1))) / (nfrag - istart + 1) - end do - - ! Distribute any residual mass if there is any and set the radius - m_frag(nfrag) = m_frag(nfrag) + (mtot - sum(m_frag(:))) - rad_frag(:) = (3 * m_frag(:) / (4 * PI * avg_dens))**(1.0_DP / 3.0_DP) - - do i = 1, nfrag - Ip_frag(:, i) = Ip_new(:) - end do - - call fragmentation_initialize(system, param, family, x, v, L_spin, Ip, mass, radius, & - nfrag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, Qloss, lfailure) - - if (lfailure) then - write(*,*) 'No fragment solution found, so treat as a pure hit-and-run' - status = ACTIVE - nfrag = 0 - else - ! Populate the list of new bodies - write(*,'("Generating ",I2.0," fragments")') nfrag - status = DISRUPTION - - ! Add the family bodies to the subtraction list - nfamily = size(family(:)) - lmask(:) = .false. - lmask(family(:)) = .true. - pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) - ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily - - allocate(plnew, mold=pl) - call plnew%setup(nfrag, param) - - plnew%id(:) = [(i, i = system%maxid + 1, system%maxid + nfrag)] - system%maxid = system%maxid + nfrag - plnew%status(:) = ACTIVE - plnew%lcollision(:) = .false. - plnew%ldiscard(:) = .false. - plnew%xb(:,:) = xb_frag(:, :) - plnew%vb(:,:) = vb_frag(:, :) - do i = 1, nfrag - plnew%xh(:,i) = xb_frag(:, i) - cb%xb(:) - plnew%vh(:,i) = vb_frag(:, i) - cb%vb(:) - end do - plnew%mass(:) = m_frag(:) - plnew%Gmass(:) = param%GU * m_frag(:) - plnew%density(:) = avg_dens - plnew%radius(:) = rad_frag(:) - plnew%info(:)%origin_type = "Disruption" - plnew%info(:)%origin_time = param%t - do i = 1, nfrag - plnew%info(i)%origin_xh(:) = plnew%xh(:,i) - plnew%info(i)%origin_vh(:) = plnew%vh(:,i) - end do - if (param%lrotation) then - plnew%Ip(:,:) = Ip_frag(:,:) - plnew%rot(:,:) = rot_frag(:,:) - end if - if (param%ltides) then - ibiggest = maxloc(pl%Gmass(family(:)), dim=1) - plnew%Q = pl%Q(ibiggest) - plnew%k2 = pl%k2(ibiggest) - plnew%tlag = pl%tlag(ibiggest) - end if + ! Collisional fragments will be uniformly distributed around the pre-impact barycenter + nfrag = NFRAG_DISRUPT + allocate(m_frag(nfrag)) + allocate(rad_frag(nfrag)) + allocate(xb_frag(NDIM, nfrag)) + allocate(vb_frag(NDIM, nfrag)) + allocate(rot_frag(NDIM, nfrag)) + allocate(Ip_frag(NDIM, nfrag)) + allocate(id_frag(nfrag)) - ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody - - call plnew%setup(0, param) - deallocate(plnew) - end if - - end associate - end select + mtot = sum(mass(:)) + xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot + vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot + + ! Get mass weighted mean of Ip and average density + Ip_new(:) = (mass(1) * Ip(:,1) + mass(2) * Ip(:,2)) / mtot + vol(:) = 4._DP / 3._DP * PI * radius(:)**3 + avg_dens = mtot / sum(vol(:)) + + ! Distribute the mass among fragments, with a branch to check for the size of the second largest fragment + m_frag(1) = mass_res(1) + if (mass_res(2) > mass_res(1) / 3._DP) then + m_frag(2) = mass_res(2) + istart = 3 + else + istart = 2 + end if + ! Distribute remaining mass among the remaining bodies + do i = istart, nfrag + m_frag(i) = (mtot - sum(m_frag(1:istart - 1))) / (nfrag - istart + 1) + end do + + ! Distribute any residual mass if there is any and set the radius + m_frag(nfrag) = m_frag(nfrag) + (mtot - sum(m_frag(:))) + rad_frag(:) = (3 * m_frag(:) / (4 * PI * avg_dens))**(1.0_DP / 3.0_DP) + id_frag(:) = [(i, i = system%maxid + 1, system%maxid + nfrag)] + + do i = 1, nfrag + Ip_frag(:, i) = Ip_new(:) + end do + + call fragmentation_initialize(system, param, family, x, v, L_spin, Ip, mass, radius, & + nfrag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, Qloss, lfailure) + + if (lfailure) then + write(*,*) 'No fragment solution found, so treat as a pure hit-and-run' + status = ACTIVE + nfrag = 0 + else + ! Populate the list of new bodies + write(*,'("Generating ",I2.0," fragments")') nfrag + status = DISRUPTION + call symba_fragmentation_mergeaddsub(system, param, family, id_frag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, status) + end if return end function symba_fragmentation_casedisruption @@ -166,7 +107,7 @@ module function symba_fragmentation_casehitandrun(system, param, family, x, v, m ! Result integer(I4B) :: status !! Status flag assigned to this outcome ! Internals - integer(I4B) :: i, nfrag, jproj, jtarg, idstart, ibiggest, nfamily, nstart, nend + integer(I4B) :: i, nfrag, jproj, jtarg, idstart, ibiggest, nfamily real(DP) :: mtot, avg_dens real(DP), dimension(NDIM) :: xcom, vcom real(DP), dimension(2) :: vol @@ -175,133 +116,73 @@ module function symba_fragmentation_casehitandrun(system, param, family, x, v, m integer(I4B), dimension(:), allocatable :: id_frag logical :: lpure logical, dimension(system%pl%nbody) :: lmask - class(symba_pl), allocatable :: plnew - select type(pl => system%pl) - class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) - mtot = sum(mass(:)) - xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot - vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot - lpure = .false. - - ! The largest body will stay untouched - if (mass(1) > mass(2)) then - jtarg = 1 - jproj = 2 - else - jtarg = 2 - jproj = 1 - end if - - if (mass_res(2) > 0.9_DP * mass(jproj)) then ! Pure hit and run, so we'll just keep the two bodies untouched - write(*,*) 'Pure hit and run. No new fragments generated.' - nfrag = 0 - lpure = .true. - else ! Imperfect hit and run, so we'll keep the largest body and destroy the other - nfrag = NFRAG_DISRUPT - 1 - lpure = .false. - allocate(m_frag(nfrag)) - allocate(id_frag(nfrag)) - allocate(rad_frag(nfrag)) - allocate(xb_frag(NDIM, nfrag)) - allocate(vb_frag(NDIM, nfrag)) - allocate(rot_frag(NDIM, nfrag)) - allocate(Ip_frag(NDIM, nfrag)) - m_frag(1) = mass(jtarg) - ibiggest = maxloc(pl%Gmass(family(:)), dim=1) - id_frag(1) = pl%id(ibiggest) - rad_frag(1) = radius(jtarg) - xb_frag(:, 1) = x(:, jtarg) - vb_frag(:, 1) = v(:, jtarg) - Ip_frag(:,1) = Ip(:, jtarg) - - ! Get mass weighted mean of Ip and average density - vol(:) = 4._DP / 3._DP * pi * radius(:)**3 - avg_dens = mass(jproj) / vol(jproj) - m_frag(2:nfrag) = (mtot - m_frag(1)) / (nfrag - 1) - rad_frag(2:nfrag) = (3 * m_frag(2:nfrag) / (4 * PI * avg_dens))**(1.0_DP / 3.0_DP) - m_frag(nfrag) = m_frag(nfrag) + (mtot - sum(m_frag(:))) - - do i = 1, nfrag - Ip_frag(:, i) = Ip(:, jproj) - end do - - ! Put the fragments on the circle surrounding the center of mass of the system - call fragmentation_initialize(system, param, family, x, v, L_spin, Ip, mass, radius, & - nfrag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, Qloss, lpure) - if (lpure) then - write(*,*) 'Should have been a pure hit and run instead' - nfrag = 0 - else - write(*,'("Generating ",I2.0," fragments")') nfrag - end if - end if - if (lpure) then - status = ACTIVE - else - status = HIT_AND_RUN - - ! Add the family bodies to the subtraction list - nfamily = size(family(:)) - lmask(:) = .false. - lmask(family(:)) = .true. - pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) - ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily + mtot = sum(mass(:)) + xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot + vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot + lpure = .false. - allocate(plnew, mold=pl) - call plnew%setup(nfrag, param) - - plnew%id(:) = [(i, i = system%maxid + 1, system%maxid + nfrag)] - system%maxid = system%maxid + nfrag - plnew%status(:) = ACTIVE - plnew%lcollision(:) = .false. - plnew%ldiscard(:) = .false. - plnew%xb(:,:) = xb_frag(:, :) - plnew%vb(:,:) = vb_frag(:, :) - do i = 1, nfrag - plnew%xh(:,i) = xb_frag(:, i) - cb%xb(:) - plnew%vh(:,i) = vb_frag(:, i) - cb%vb(:) - end do - plnew%mass(:) = m_frag(:) - plnew%Gmass(:) = param%GU * m_frag(:) - plnew%density(:) = avg_dens - plnew%radius(:) = rad_frag(:) - plnew%info(:)%origin_type = "Hit and run fragment" - plnew%info(:)%origin_time = param%t - do i = 1, nfrag - plnew%info(i)%origin_xh(:) = plnew%xh(:,i) - plnew%info(i)%origin_vh(:) = plnew%vh(:,i) - end do - if (param%lrotation) then - plnew%Ip(:,:) = Ip_frag(:,:) - plnew%rot(:,:) = rot_frag(:,:) - end if - if (param%ltides) then - ibiggest = maxloc(pl%Gmass(family(:)), dim=1) - plnew%Q = pl%Q(ibiggest) - plnew%k2 = pl%k2(ibiggest) - plnew%tlag = pl%tlag(ibiggest) - end if + ! The largest body will stay untouched + if (mass(1) > mass(2)) then + jtarg = 1 + jproj = 2 + else + jtarg = 2 + jproj = 1 + end if - ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody - - call plnew%setup(0, param) - deallocate(plnew) - - end if - end associate - end select + if (mass_res(2) > 0.9_DP * mass(jproj)) then ! Pure hit and run, so we'll just keep the two bodies untouched + write(*,*) 'Pure hit and run. No new fragments generated.' + nfrag = 0 + lpure = .true. + else ! Imperfect hit and run, so we'll keep the largest body and destroy the other + nfrag = NFRAG_DISRUPT - 1 + lpure = .false. + allocate(m_frag(nfrag)) + allocate(id_frag(nfrag)) + allocate(rad_frag(nfrag)) + allocate(xb_frag(NDIM, nfrag)) + allocate(vb_frag(NDIM, nfrag)) + allocate(rot_frag(NDIM, nfrag)) + allocate(Ip_frag(NDIM, nfrag)) + m_frag(1) = mass(jtarg) + ibiggest = maxloc(system%pl%Gmass(family(:)), dim=1) + id_frag(1) = system%pl%id(ibiggest) + rad_frag(1) = radius(jtarg) + xb_frag(:, 1) = x(:, jtarg) + vb_frag(:, 1) = v(:, jtarg) + Ip_frag(:,1) = Ip(:, jtarg) + + ! Get mass weighted mean of Ip and average density + vol(:) = 4._DP / 3._DP * pi * radius(:)**3 + avg_dens = mass(jproj) / vol(jproj) + m_frag(2:nfrag) = (mtot - m_frag(1)) / (nfrag - 1) + rad_frag(2:nfrag) = (3 * m_frag(2:nfrag) / (4 * PI * avg_dens))**(1.0_DP / 3.0_DP) + m_frag(nfrag) = m_frag(nfrag) + (mtot - sum(m_frag(:))) + id_frag(2:nfrag) = [(i, i = system%maxid + 1, system%maxid + nfrag - 1)] + + do i = 1, nfrag + Ip_frag(:, i) = Ip(:, jproj) + end do + + ! Put the fragments on the circle surrounding the center of mass of the system + call fragmentation_initialize(system, param, family, x, v, L_spin, Ip, mass, radius, & + nfrag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, Qloss, lpure) + if (lpure) then + write(*,*) 'Should have been a pure hit and run instead' + nfrag = 0 + else + write(*,'("Generating ",I2.0," fragments")') nfrag + end if + end if + if (lpure) then + status = ACTIVE + else + status = HIT_AND_RUN + call symba_fragmentation_mergeaddsub(system, param, family, id_frag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, status) + end if - return + return end function symba_fragmentation_casehitandrun @@ -323,118 +204,75 @@ module function symba_fragmentation_casemerge(system, param, family, x, v, mass, ! Result integer(I4B) :: status !! Status flag assigned to this outcome ! Internals - integer(I4B) :: i, j, ibiggest, nfamily, nstart, nend - real(DP) :: mass_new, radius_new, volume_new, pe - real(DP), dimension(NDIM) :: xcom, vcom, xc, vc, xcrossv + integer(I4B) :: i, j, ibiggest, nfamily + real(DP) :: volume_new, pe + real(DP), dimension(NDIM) :: xc, vc, xcrossv real(DP), dimension(2) :: vol real(DP), dimension(NDIM) :: L_orb_old, L_spin_old - real(DP), dimension(NDIM) :: L_spin_new, rot_new, Ip_new + real(DP), dimension(NDIM) :: L_spin_new logical, dimension(system%pl%nbody) :: lmask - class(symba_pl), allocatable :: plnew + real(DP), dimension(NDIM, 1) :: vb_frag, xb_frag, rot_frag, Ip_frag + real(DP), dimension(1) :: m_frag, rad_frag + integer(I4B), dimension(1) :: id_frag select type(pl => system%pl) class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) - status = MERGED - write(*, '("Merging bodies ",99(I8,",",:))') pl%id(family(:)) - mass_new = sum(mass(:)) - - ! Merged body is created at the barycenter of the original bodies - xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mass_new - vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mass_new - - ! Get mass weighted mean of Ip and - vol(:) = 4._DP / 3._DP * PI * radius(:)**3 - volume_new = sum(vol(:)) - radius_new = (3 * volume_new / (4 * PI))**(1._DP / 3._DP) - - L_orb_old(:) = 0.0_DP - - ! Compute orbital angular momentum of pre-impact system - do i = 1, 2 - xc(:) = x(:, i) - xcom(:) - vc(:) = v(:, i) - vcom(:) - xcrossv(:) = xc(:) .cross. vc(:) - L_orb_old(:) = L_orb_old(:) + mass(i) * xcrossv(:) - end do - - if (param%lrotation) then - Ip_new(:) = (mass(1) * Ip(:,1) + mass(2) * Ip(:,2)) / mass_new - L_spin_old(:) = L_spin(:,1) + L_spin(:,2) + write(*, '("Merging bodies ",99(I8,",",:))') pl%id(family(:)) - ! Conserve angular momentum by putting pre-impact orbital momentum into spin of the new body - L_spin_new(:) = L_orb_old(:) + L_spin_old(:) - - ! Assume prinicpal axis rotation on 3rd Ip axis - rot_new(:) = L_spin_new(:) / (Ip_new(3) * mass_new * radius_new**2) - else ! If spin is not enabled, we will consider the lost pre-collision angular momentum as "escaped" and add it to our bookkeeping variable - system%Lescape(:) = system%Lescape(:) + L_orb_old(:) - end if + ibiggest = maxloc(pl%Gmass(family(:)), dim=1) + id_frag(1) = pl%id(family(ibiggest)) + + m_frag(1) = sum(mass(:)) + + ! Merged body is created at the barycenter of the original bodies + xb_frag(:,1) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / m_frag(1) + vb_frag(:,1) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / m_frag(1) + + ! Get mass weighted mean of Ip and + vol(:) = 4._DP / 3._DP * PI * radius(:)**3 + volume_new = sum(vol(:)) + rad_frag(1) = (3 * volume_new / (4 * PI))**(1._DP / 3._DP) + + L_orb_old(:) = 0.0_DP + + ! Compute orbital angular momentum of pre-impact system + do i = 1, 2 + xc(:) = x(:, i) - xb_frag(:,1) + vc(:) = v(:, i) - vb_frag(:,1) + xcrossv(:) = xc(:) .cross. vc(:) + L_orb_old(:) = L_orb_old(:) + mass(i) * xcrossv(:) + end do - ! Keep track of the component of potential energy due to the pre-impact family for book-keeping - nfamily = size(family(:)) - pe = 0.0_DP - do j = 1, nfamily - do i = j + 1, nfamily - pe = pe - pl%mass(i) * pl%mass(j) / norm2(pl%xb(:, i) - pl%xb(:, j)) - end do + if (param%lrotation) then + Ip_frag(:,1) = (mass(1) * Ip(:,1) + mass(2) * Ip(:,2)) / m_frag(1) + L_spin_old(:) = L_spin(:,1) + L_spin(:,2) + + ! Conserve angular momentum by putting pre-impact orbital momentum into spin of the new body + L_spin_new(:) = L_orb_old(:) + L_spin_old(:) + + ! Assume prinicpal axis rotation on 3rd Ip axis + rot_frag(:,1) = L_spin_new(:) / (Ip_frag(3,1) * m_frag(1) * rad_frag(1)**2) + else ! If spin is not enabled, we will consider the lost pre-collision angular momentum as "escaped" and add it to our bookkeeping variable + system%Lescape(:) = system%Lescape(:) + L_orb_old(:) + end if + + ! Keep track of the component of potential energy due to the pre-impact family for book-keeping + nfamily = size(family(:)) + pe = 0.0_DP + do j = 1, nfamily + do i = j + 1, nfamily + pe = pe - pl%mass(i) * pl%mass(j) / norm2(pl%xb(:, i) - pl%xb(:, j)) end do - system%Ecollisions = system%Ecollisions + pe - system%Euntracked = system%Euntracked - pe - - ! Add the family bodies to the subtraction list - lmask(:) = .false. - lmask(family(:)) = .true. - pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) - ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily - - ! Create the new merged body - allocate(plnew, mold=pl) - call plnew%setup(1, param) - - ! The merged body's name will be that of the largest of the two parents - ibiggest = maxloc(pl%Gmass(family(:)), dim=1) - plnew%id(1) = pl%id(family(ibiggest)) - plnew%status(1) = ACTIVE - plnew%lcollision = .false. - plnew%ldiscard = .false. - plnew%xb(:,1) = xcom(:) - plnew%vb(:,1) = vcom(:) - plnew%xh(:,1) = xcom(:) - cb%xb(:) - plnew%vh(:,1) = vcom(:) - cb%vb(:) - plnew%mass(1) = mass_new - plnew%Gmass(1) = param%GU * mass_new - plnew%density(1) = mass_new / volume_new - plnew%radius(1) = radius_new - plnew%info(1) = pl%info(family(ibiggest)) - if (param%lrotation) then - plnew%Ip(:,1) = Ip_new(:) - plnew%rot(:,1) = rot_new(:) - end if - if (param%ltides) then - plnew%Q = pl%Q(ibiggest) - plnew%k2 = pl%k2(ibiggest) - plnew%tlag = pl%tlag(ibiggest) - end if - - ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody - - call plnew%setup(0, param) - deallocate(plnew) - - end associate + end do + system%Ecollisions = system%Ecollisions + pe + system%Euntracked = system%Euntracked - pe + + status = MERGED + call symba_fragmentation_mergeaddsub(system, param, family, id_frag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, status) + end select return - end function symba_fragmentation_casemerge @@ -462,75 +300,112 @@ module function symba_fragmentation_casesupercatastrophic(system, param, family, real(DP), dimension(NDIM) :: Ip_new real(DP), dimension(:, :), allocatable :: vb_frag, xb_frag, rot_frag, Ip_frag real(DP), dimension(:), allocatable :: m_frag, rad_frag + integer(I4B), dimension(:), allocatable :: id_frag logical :: lfailure logical, dimension(system%pl%nbody) :: lmask + + ! Collisional fragments will be uniformly distributed around the pre-impact barycenter + nfrag = NFRAG_SUPERCAT + allocate(m_frag(nfrag)) + allocate(rad_frag(nfrag)) + allocate(id_frag(nfrag)) + allocate(xb_frag(NDIM, nfrag)) + allocate(vb_frag(NDIM, nfrag)) + allocate(rot_frag(NDIM, nfrag)) + allocate(Ip_frag(NDIM, nfrag)) + + mtot = sum(mass(:)) + xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot + vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot + + ! Get mass weighted mean of Ip and average density + Ip_new(:) = (mass(1) * Ip(:,1) + mass(2) * Ip(:,2)) / mtot + vol(:) = 4._DP / 3._DP * pi * radius(:)**3 + avg_dens = mtot / sum(vol(:)) + + ! If we are adding the first and largest fragment (lr), check to see if its mass is SMALLER than an equal distribution of + ! mass between all fragments. If so, we will just distribute the mass equally between the fragments + min_frag_mass = mtot / nfrag + if (mass_res(1) < min_frag_mass) then + m_frag(:) = min_frag_mass + else + m_frag(1) = mass_res(1) + m_frag(2:nfrag) = (mtot - mass_res(1)) / (nfrag - 1) + end if + ! Distribute any residual mass if there is any and set the radius + m_frag(nfrag) = m_frag(nfrag) + (mtot - sum(m_frag(:))) + rad_frag(:) = (3 * m_frag(:) / (4 * PI * avg_dens))**(1.0_DP / 3.0_DP) + id_frag(:) = [(i, i = system%maxid + 1, system%maxid + nfrag)] + + do i = 1, nfrag + Ip_frag(:, i) = Ip_new(:) + end do + + call fragmentation_initialize(system, param, family, x, v, L_spin, Ip, mass, radius, & + nfrag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, Qloss, lfailure) + + if (lfailure) then + write(*,*) 'No fragment solution found, so treat as a pure hit-and-run' + status = ACTIVE + nfrag = 0 + else + ! Populate the list of new bodies + write(*,'("Generating ",I2.0," fragments")') nfrag + status = SUPERCATASTROPHIC + call symba_fragmentation_mergeaddsub(system, param, family, id_frag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, status) + end if + + return + end function symba_fragmentation_casesupercatastrophic + + + subroutine symba_fragmentation_mergeaddsub(system, param, family, id_frag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, status) + !! author: David A. Minton + !! + !! Fills the pl_discards and pl_adds with removed and added bodies + !! + implicit none + ! Arguments + class(symba_nbody_system), intent(inout) :: system !! SyMBA nbody system object + class(symba_parameters), intent(in) :: param !! Current run configuration parameters with SyMBA additions + integer(I4B), dimension(:), intent(in) :: family !! List of indices of all bodies inovlved in the collision + integer(I4B), dimension(:), intent(in) :: id_frag !! List of fragment ids + real(DP), dimension(:), intent(in) :: m_frag, rad_frag !! Distribution of fragment mass and radii + real(DP), dimension(:,:), intent(in) :: Ip_frag !! Fragment rotational inertia vectors + real(DP), dimension(:,:), intent(in) :: xb_frag, vb_frag, rot_frag !! Fragment barycentric position, barycentric velocity, and rotation vectors + integer(I4B), intent(in) :: status !! Status flag to assign to adds + ! Internals + integer(I4B) :: i, ibiggest, nstart, nend, nfamily, nfrag + logical, dimension(system%pl%nbody) :: lmask class(symba_pl), allocatable :: plnew - + select type(pl => system%pl) class is (symba_pl) - associate(mergeadd_list => system%mergeadd_list, mergesub_list => system%mergesub_list, cb => system%cb) - ! Collisional fragments will be uniformly distributed around the pre-impact barycenter - nfrag = NFRAG_SUPERCAT - allocate(m_frag(nfrag)) - allocate(rad_frag(nfrag)) - allocate(xb_frag(NDIM, nfrag)) - allocate(vb_frag(NDIM, nfrag)) - allocate(rot_frag(NDIM, nfrag)) - allocate(Ip_frag(NDIM, nfrag)) - - mtot = sum(mass(:)) - xcom(:) = (mass(1) * x(:,1) + mass(2) * x(:,2)) / mtot - vcom(:) = (mass(1) * v(:,1) + mass(2) * v(:,2)) / mtot - - ! Get mass weighted mean of Ip and average density - Ip_new(:) = (mass(1) * Ip(:,1) + mass(2) * Ip(:,2)) / mtot - vol(:) = 4._DP / 3._DP * pi * radius(:)**3 - avg_dens = mtot / sum(vol(:)) - - ! If we are adding the first and largest fragment (lr), check to see if its mass is SMALLER than an equal distribution of - ! mass between all fragments. If so, we will just distribute the mass equally between the fragments - min_frag_mass = mtot / nfrag - if (mass_res(1) < min_frag_mass) then - m_frag(:) = min_frag_mass - else - m_frag(1) = mass_res(1) - m_frag(2:nfrag) = (mtot - mass_res(1)) / (nfrag - 1) - end if - ! Distribute any residual mass if there is any and set the radius - m_frag(nfrag) = m_frag(nfrag) + (mtot - sum(m_frag(:))) - rad_frag(:) = (3 * m_frag(:) / (4 * PI * avg_dens))**(1.0_DP / 3.0_DP) - - do i = 1, nfrag - Ip_frag(:, i) = Ip_new(:) - end do - - call fragmentation_initialize(system, param, family, x, v, L_spin, Ip, mass, radius, & - nfrag, Ip_frag, m_frag, rad_frag, xb_frag, vb_frag, rot_frag, Qloss, lfailure) - - if (lfailure) then - write(*,*) 'No fragment solution found, so treat as a pure hit-and-run' - status = ACTIVE - nfrag = 0 - else - ! Populate the list of new bodies - write(*,'("Generating ",I2.0," fragments")') nfrag - status = SUPERCATASTROPHIC + select type(pl_discards => system%pl_discards) + class is (symba_merger) + associate(pl_adds => system%pl_adds, cb => system%cb) ! Add the family bodies to the subtraction list nfamily = size(family(:)) + nfrag = size(m_frag(:)) lmask(:) = .false. lmask(family(:)) = .true. pl%status(family(:)) = MERGED - nstart = mergesub_list%nbody + 1 - nend = mergesub_list%nbody + nfamily - call mergesub_list%append(pl, lmask) + nstart = pl_discards%nbody + 1 + nend = pl_discards%nbody + nfamily + call pl_discards%append(pl, lmask) + pl%ldiscard(family(:)) = .true. + pl%lcollision(family(:)) = .true. + ! Record how many bodies were subtracted in this event - mergesub_list%ncomp(nstart:nend) = nfamily + pl_discards%ncomp(nstart:nend) = nfamily + ! Setup new bodies allocate(plnew, mold=pl) call plnew%setup(nfrag, param) - - plnew%id(:) = [(i, i = system%maxid + 1, system%maxid + nfrag)] + ibiggest = maxloc(pl%Gmass(family(:)), dim=1) + + plnew%id(:) = id_frag(:) system%maxid = system%maxid + nfrag plnew%status(:) = ACTIVE plnew%lcollision(:) = .false. @@ -543,39 +418,53 @@ module function symba_fragmentation_casesupercatastrophic(system, param, family, end do plnew%mass(:) = m_frag(:) plnew%Gmass(:) = param%GU * m_frag(:) - plnew%density(:) = avg_dens plnew%radius(:) = rad_frag(:) - plnew%info(:)%origin_type = "Supercatastrophic" - plnew%info(:)%origin_time = param%t - do i = 1, nfrag - plnew%info(i)%origin_xh(:) = plnew%xh(:,i) - plnew%info(i)%origin_vh(:) = plnew%vh(:,i) - end do + plnew%density(:) = m_frag(:) / rad_frag(:) + + select case(status) + case(DISRUPTION) + plnew%info(:)%origin_type = "Disruption" + case(SUPERCATASTROPHIC) + plnew%info(:)%origin_type = "Supercatastrophic" + case(HIT_AND_RUN) + plnew%info(:)%origin_type = "Hit and run fragment" + case(MERGED) + plnew%info(1) = pl%info(ibiggest) + end select + + if (status /= MERGED) then + plnew%info(:)%origin_time = param%t + do i = 1, nfrag + plnew%info(i)%origin_xh(:) = plnew%xh(:,i) + plnew%info(i)%origin_vh(:) = plnew%vh(:,i) + end do + end if + if (param%lrotation) then plnew%Ip(:,:) = Ip_frag(:,:) plnew%rot(:,:) = rot_frag(:,:) end if if (param%ltides) then - ibiggest = maxloc(pl%Gmass(family(:)), dim=1) plnew%Q = pl%Q(ibiggest) plnew%k2 = pl%k2(ibiggest) plnew%tlag = pl%tlag(ibiggest) end if - + call plnew%set_mu(cb) + pl%lmtiny(:) = pl%Gmass(:) > param%GMTINY + ! Append the new merged body to the list and record how many we made - nstart = mergeadd_list%nbody + 1 - nend = mergeadd_list%nbody + plnew%nbody - call mergeadd_list%append(plnew) - mergeadd_list%ncomp(nstart:nend) = plnew%nbody - + nstart = pl_adds%nbody + 1 + nend = pl_adds%nbody + plnew%nbody + call pl_adds%append(plnew, lsource_mask=[(.true., i=1, plnew%nbody)]) + pl_adds%ncomp(nstart:nend) = plnew%nbody + call plnew%setup(0, param) deallocate(plnew) - end if - - end associate + end associate + end select end select return - end function symba_fragmentation_casesupercatastrophic + end subroutine symba_fragmentation_mergeaddsub end submodule s_symba_fragmentation diff --git a/src/symba/symba_io.f90 b/src/symba/symba_io.f90 index 2e568dd7e..97e5798c2 100644 --- a/src/symba/symba_io.f90 +++ b/src/symba/symba_io.f90 @@ -2,26 +2,88 @@ use swiftest contains - module subroutine symba_io_dump_particle_info(self, param, msg) + module subroutine symba_io_dump_particle_info(system, param, lincludecb, tpidx, plidx) !! author: David A. Minton !! - !! Dumps the particle information data to a file + !! Dumps the particle information data to a file. + !! Pass a list of array indices for test particles (tpidx) and/or massive bodies (plidx) to append implicit none - class(symba_particle_info), intent(inout) :: self !! Swiftest base object - class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), optional, intent(in) :: msg !! Message to display with dump operation - end subroutine symba_io_dump_particle_info + ! Arguments + class(symba_nbody_system), intent(inout) :: system !! SyMBA nbody system object + class(symba_parameters), intent(in) :: param !! Current run configuration parameters with SyMBA extensions + logical, optional, intent(in) :: lincludecb !! Set to true to include the central body (default is false) + integer(I4B), dimension(:), optional, intent(in) :: tpidx !! Array of test particle indices to append to the particle file + integer(I4B), dimension(:), optional, intent(in) :: plidx !! Array of massive body indices to append to the particle file + ! Internals + logical, save :: lfirst = .true. + integer(I4B), parameter :: LUN = 22 + integer(I4B) :: i, ierr + if (lfirst) then + select case(param%out_stat) + case('APPEND') + open(unit = LUN, file = param%particle_out, status = 'OLD', position = 'APPEND', form = 'UNFORMATTED', iostat = ierr) + case('NEW', 'UNKNOWN', 'REPLACE') + open(unit = LUN, file = param%particle_out, status = param%out_stat, form = 'UNFORMATTED', iostat = ierr) + case default + write(*,*) 'Invalid status code',trim(adjustl(param%out_stat)) + call util_exit(FAILURE) + end select + if (ierr /= 0) then + write(*, *) "Swiftest error:" + write(*, *) " particle output file already exists or cannot be accessed" + call util_exit(FAILURE) + end if - module subroutine symba_io_initialize_particle_info(self, param) - !! author: David A. Minton - !! - !! Initializes a particle info data structure, either starting a new one or reading one in - !! from a file if it is a restarted run - implicit none - class(symba_particle_info), intent(inout) :: self !! SyMBA particle info object - class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - end subroutine symba_io_initialize_particle_info + lfirst = .false. + else + open(unit = LUN, file = param%particle_out, status = 'OLD', position = 'APPEND', form = 'UNFORMATTED', iostat = ierr) + if (ierr /= 0) then + write(*, *) "Swiftest error:" + write(*, *) " unable to open binary output file for APPEND" + call util_exit(FAILURE) + end if + end if + + if (present(lincludecb)) then + if (lincludecb) then + select type(cb => system%cb) + class is (symba_cb) + write(LUN) cb%id + write(LUN) cb%info + end select + end if + end if + + if (present(plidx) .and. (system%pl%nbody > 0)) then + select type(pl => system%pl) + class is (symba_pl) + do i = 1, size(plidx) + write(LUN) pl%id(plidx(i)) + write(LUN) pl%info(plidx(i)) + end do + end select + end if + + if (present(tpidx) .and. (system%tp%nbody > 0)) then + select type(tp => system%tp) + class is (symba_tp) + do i = 1, size(tpidx) + write(LUN) tp%id(tpidx(i)) + write(LUN) tp%info(tpidx(i)) + end do + end select + end if + + close(unit = LUN, iostat = ierr) + if (ierr /= 0) then + write(*, *) "Swiftest error:" + write(*, *) " unable to close particle output file" + call util_exit(FAILURE) + end if + + return + end subroutine symba_io_dump_particle_info module subroutine symba_io_param_reader(self, unit, iotype, v_list, iostat, iomsg) @@ -68,11 +130,13 @@ module subroutine symba_io_param_reader(self, unit, iotype, v_list, iostat, ioms ifirst = ilast + 1 param_value = io_get_token(line_trim, ifirst, ilast, iostat) select case (param_name) + case ("PARTICLE_OUT") + param%particle_out = param_value case ("FRAGMENTATION") call io_toupper(param_value) if (param_value == "YES" .or. param_value == "T") self%lfragmentation = .true. - case ("MTINY") - read(param_value, *) param%mtiny + case ("GMTINY") + read(param_value, *) param%Gmtiny case("SEED") read(param_value, *) nseeds_from_file ! Because the number of seeds can vary between compilers/systems, we need to make sure we can handle cases in which the input file has a different @@ -111,12 +175,12 @@ module subroutine symba_io_param_reader(self, unit, iotype, v_list, iostat, ioms write(*,*) "SEED: N,VAL = ",size(param%seed), param%seed(:) end if - if (self%mtiny < 0.0_DP) then - write(iomsg,*) "MTINY invalid or not set: ", self%mtiny + if (self%Gmtiny < 0.0_DP) then + write(iomsg,*) "GMTINY invalid or not set: ", self%Gmtiny iostat = -1 return else - write(*,*) "MTINY = ", self%mtiny + write(*,*) "GMTINY = ", self%Gmtiny end if if (.not.self%lclose) then @@ -166,8 +230,8 @@ module subroutine symba_io_param_writer(self, unit, iotype, v_list, iostat, ioms ! Special handling is required for writing the random number seed array as its size is not known until runtime ! For the "SEED" parameter line, the first value will be the size of the seed array and the rest will be the seed array elements - write(param_name, Afmt) "PARTICLE_FILE"; write(param_value, Afmt) trim(adjustl(param%particle_file)); write(unit, Afmt) adjustl(param_name), adjustl(param_value) - write(param_name, Afmt) "MTINY"; write(param_value, Rfmt) param%mtiny; write(unit, Afmt) adjustl(param_name), adjustl(param_value) + write(param_name, Afmt) "PARTICLE_OUT"; write(param_value, Afmt) trim(adjustl(param%particle_out)); write(unit, Afmt) adjustl(param_name), adjustl(param_value) + write(param_name, Afmt) "GMTINY"; write(param_value, Rfmt) param%Gmtiny; write(unit, Afmt) adjustl(param_name), adjustl(param_value) write(param_name, Afmt) "FRAGMENTATION"; write(param_value, Lfmt) param%lfragmentation; write(unit, Afmt) adjustl(param_name), adjustl(param_value) if (param%lfragmentation) then write(param_name, Afmt) "SEED" @@ -194,19 +258,74 @@ module subroutine symba_io_param_writer(self, unit, iotype, v_list, iostat, ioms end subroutine symba_io_param_writer - module subroutine symba_io_read_frame_info(self, iu, param, form, ierr) + module subroutine symba_io_read_particle(system, param) !! author: David A. Minton !! - !! Reads a single frame of a particle info data from a file. + !! Reads an old particle information file for a restartd run implicit none - class(symba_particle_info), intent(inout) :: self !! SyMBA particle info object - integer(I4B), intent(inout) :: iu !! Unit number for the output file to write frame to - class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters - character(*), intent(in) :: form !! Input format code ("XV" or "EL") - integer(I4B), intent(out) :: ierr !! Error code + class(symba_nbody_system), intent(inout) :: system !! SyMBA nbody system file + class(symba_parameters), intent(inout) :: param !! Current run configuration parameters with SyMBA extensions - ierr = 0 - end subroutine symba_io_read_frame_info + ! Internals + integer(I4B), parameter :: LUN = 22 + integer(I4B) :: i, ierr, id, idx + logical :: lmatch + type(symba_particle_info) :: tmpinfo + + open(unit = LUN, file = param%particle_out, status = 'OLD', form = 'UNFORMATTED', iostat = ierr) + if (ierr /= 0) then + write(*, *) "Swiftest error:" + write(*, *) " unable to open binary particle file for reading" + call util_exit(FAILURE) + end if + + select type(cb => system%cb) + class is (symba_cb) + select type(pl => system%pl) + class is (symba_pl) + select type(tp => system%tp) + class is (symba_tp) + do + lmatch = .false. + read(LUN, iostat=ierr) id + if (ierr /=0) exit + + if (idx == cb%id) then + read(LUN) cb%info + lmatch = .true. + else + if (pl%nbody > 0) then + idx = findloc(pl%id(:), id, dim=1) + if (idx /= 0) then + read(LUN) pl%info(idx) + lmatch = .true. + end if + end if + if (.not.lmatch .and. tp%nbody > 0) then + idx = findloc(tp%id(:), id, dim=1) + if (idx /= 0) then + read(LUN) tp%info(idx) + lmatch = .true. + end if + end if + end if + if (.not.lmatch) then + write(*,*) 'Particle id ',id,' not found. Skipping' + read(LUN) tmpinfo + end if + end do + close(unit = LUN, iostat = ierr) + end select + end select + end select + if (ierr /= 0) then + write(*, *) "Swiftest error:" + write(*, *) " unable to close particle output file" + call util_exit(FAILURE) + end if + + return + end subroutine symba_io_read_particle module subroutine symba_io_write_discard(self, param) @@ -225,66 +344,60 @@ module subroutine symba_io_write_discard(self, param) character(*), parameter :: PLNAMEFMT = '(I8, 2(1X, E23.16))' class(swiftest_body), allocatable :: pltemp - associate(pl => self%pl, npl => self%pl%nbody, mergesub_list => self%mergesub_list, mergeadd_list => self%mergeadd_list) + associate(pl => self%pl, npl => self%pl%nbody, pl_adds => self%pl_adds) if (self%tp_discards%nbody > 0) call io_write_discard(self, param) + select type(pl_discards => self%pl_discards) + class is (symba_merger) + if (pl_discards%nbody == 0) return + select case(param%out_stat) + case('APPEND') + open(unit = LUN, file = param%discard_out, status = 'OLD', position = 'APPEND', form = 'FORMATTED', iostat = ierr) + case('NEW', 'REPLACE', 'UNKNOWN') + open(unit = LUN, file = param%discard_out, status = param%out_stat, form = 'FORMATTED', iostat = ierr) + case default + write(*,*) 'Invalid status code for OUT_STAT: ',trim(adjustl(param%out_stat)) + call util_exit(FAILURE) + end select + lfirst = .false. + if (param%lgr) then + call pl_discards%pv2v(param) + call pl_adds%pv2v(param) + end if - if (mergesub_list%nbody == 0) return - select case(param%out_stat) - case('APPEND') - open(unit = LUN, file = param%discard_out, status = 'OLD', position = 'APPEND', form = 'FORMATTED', iostat = ierr) - case('NEW', 'REPLACE', 'UNKNOWN') - open(unit = LUN, file = param%discard_out, status = param%out_stat, form = 'FORMATTED', iostat = ierr) - case default - write(*,*) 'Invalid status code for OUT_STAT: ',trim(adjustl(param%out_stat)) - call util_exit(FAILURE) - end select - lfirst = .false. - if (param%lgr) then - call mergesub_list%pv2v(param) - call mergeadd_list%pv2v(param) - end if - - write(LUN, HDRFMT) param%t, mergesub_list%nbody, param%lbig_discard - iadd = 1 - isub = 1 - do while (iadd <= mergeadd_list%nbody) - nadd = mergeadd_list%ncomp(iadd) - nsub = mergesub_list%ncomp(isub) - do j = 1, nadd - if (iadd <= mergeadd_list%nbody) then - write(LUN, NAMEFMT) ADD, mergesub_list%id(iadd), mergesub_list%status(iadd) - write(LUN, VECFMT) mergeadd_list%xh(1, iadd), mergeadd_list%xh(2, iadd), mergeadd_list%xh(3, iadd) - write(LUN, VECFMT) mergeadd_list%vh(1, iadd), mergeadd_list%vh(2, iadd), mergeadd_list%vh(3, iadd) - else - exit - end if - iadd = iadd + 1 - end do - do j = 1, nsub - if (isub <= mergesub_list%nbody) then - write(LUN, NAMEFMT) SUB, mergesub_list%id(isub), mergesub_list%status(isub) - write(LUN, VECFMT) mergesub_list%xh(1, isub), mergesub_list%xh(2, isub), mergesub_list%xh(3, isub) - write(LUN, VECFMT) mergesub_list%vh(1, isub), mergesub_list%vh(2, isub), mergesub_list%vh(3, isub) - else - exit - end if - isub = isub + 1 + write(LUN, HDRFMT) param%t, pl_discards%nbody, param%lbig_discard + iadd = 1 + isub = 1 + do while (iadd <= pl_adds%nbody) + nadd = pl_adds%ncomp(iadd) + nsub = pl_discards%ncomp(isub) + do j = 1, nadd + if (iadd <= pl_adds%nbody) then + write(LUN, NAMEFMT) ADD, pl_adds%id(iadd), pl_adds%status(iadd) + write(LUN, VECFMT) pl_adds%xh(1, iadd), pl_adds%xh(2, iadd), pl_adds%xh(3, iadd) + write(LUN, VECFMT) pl_adds%vh(1, iadd), pl_adds%vh(2, iadd), pl_adds%vh(3, iadd) + else + exit + end if + iadd = iadd + 1 + end do + do j = 1, nsub + if (isub <= pl_discards%nbody) then + write(LUN, NAMEFMT) SUB, pl_discards%id(isub), pl_discards%status(isub) + write(LUN, VECFMT) pl_discards%xh(1, isub), pl_discards%xh(2, isub), pl_discards%xh(3, isub) + write(LUN, VECFMT) pl_discards%vh(1, isub), pl_discards%vh(2, isub), pl_discards%vh(3, isub) + else + exit + end if + isub = isub + 1 + end do end do - end do - close(LUN) + close(LUN) + end select end associate return end subroutine symba_io_write_discard - - module subroutine symba_io_write_frame_info(self, iu, param) - implicit none - class(symba_particle_info), intent(in) :: self !! SyMBA particle info object - integer(I4B), intent(inout) :: iu !! Unit number for the output file to write frame to - class(swiftest_parameters), intent(in) :: param !! Current run configuration parameters - end subroutine symba_io_write_frame_info - end submodule s_symba_io diff --git a/src/symba/symba_setup.f90 b/src/symba/symba_setup.f90 index 021873a70..e06fb20b5 100644 --- a/src/symba/symba_setup.f90 +++ b/src/symba/symba_setup.f90 @@ -2,6 +2,62 @@ use swiftest contains + module subroutine symba_setup_initialize_particle_info(system, param) + !! author: David A. Minton + !! + !! Initializes a new particle information data structure with initial conditions recorded + implicit none + ! Argumets + class(symba_nbody_system), intent(inout) :: system !! SyMBA nbody system object + class(symba_parameters), intent(inout) :: param !! Current run configuration parameters with SyMBA extensions + ! Internals + integer(I4B) :: i + integer(I4B), dimension(:), allocatable :: idx + + select type(cb => system%cb) + class is (symba_cb) + cb%info%origin_type = "Central body" + cb%info%origin_time = param%t0 + cb%info%origin_xh(:) = 0.0_DP + cb%info%origin_vh(:) = 0.0_DP + call symba_io_dump_particle_info(system, param, lincludecb=.true.) + end select + + select type(pl => system%pl) + class is (symba_pl) + do i = 1, pl%nbody + pl%info(i)%origin_type = "Initial conditions" + pl%info(i)%origin_time = param%t0 + pl%info(i)%origin_xh(:) = pl%xh(:,i) + pl%info(i)%origin_vh(:) = pl%vh(:,i) + end do + if (pl%nbody > 0) then + allocate(idx(pl%nbody)) + call symba_io_dump_particle_info(system, param, plidx=[(i, i=1, pl%nbody)]) + deallocate(idx) + end if + end select + + select type(tp => system%tp) + class is (symba_tp) + do i = 1, tp%nbody + tp%info(i)%origin_type = "Initial conditions" + tp%info(i)%origin_time = param%t0 + tp%info(i)%origin_xh(:) = tp%xh(:,i) + tp%info(i)%origin_vh(:) = tp%vh(:,i) + end do + if (tp%nbody > 0) then + allocate(idx(tp%nbody)) + call symba_io_dump_particle_info(system, param, tpidx=[(i, i=1, tp%nbody)]) + deallocate(idx) + end if + end select + + + return + end subroutine symba_setup_initialize_particle_info + + module subroutine symba_setup_initialize_system(self, param) !! author: David A. Minton !! @@ -25,8 +81,13 @@ module subroutine symba_setup_initialize_system(self, param) call pl%sort("mass", ascending=.false.) select type(param) class is (symba_parameters) - pl%lmtiny(:) = pl%Gmass(:) > param%MTINY + pl%lmtiny(:) = pl%Gmass(:) > param%GMTINY pl%nplm = count(pl%lmtiny(:)) + if (param%lrestart) then + call symba_io_read_particle(system, param) + else + call symba_setup_initialize_particle_info(system, param) + end if end select end select end associate @@ -162,10 +223,12 @@ module subroutine symba_setup_tp(self, n, param) if (allocated(self%nplenc)) deallocate(self%nplenc) if (allocated(self%levelg)) deallocate(self%levelg) if (allocated(self%levelm)) deallocate(self%levelm) + if (allocated(self%info)) deallocate(self%info) allocate(self%nplenc(n)) allocate(self%levelg(n)) allocate(self%levelm(n)) + allocate(self%info(n)) self%nplenc(:) = 0 self%levelg(:) = -1 diff --git a/src/symba/symba_step.f90 b/src/symba/symba_step.f90 index 41e7a3a74..7065625b4 100644 --- a/src/symba/symba_step.f90 +++ b/src/symba/symba_step.f90 @@ -237,7 +237,7 @@ module subroutine symba_step_reset_system(self) ! Internals integer(I4B) :: i - associate(system => self, pltpenc_list => self%pltpenc_list, plplenc_list => self%plplenc_list, mergeadd_list => self%mergeadd_list, mergesub_list => self%mergesub_list) + associate(system => self, pltpenc_list => self%pltpenc_list, plplenc_list => self%plplenc_list, pl_adds => self%pl_adds, pl_discards => self%pl_discards) select type(pl => system%pl) class is (symba_pl) select type(tp => system%tp) @@ -265,8 +265,8 @@ module subroutine symba_step_reset_system(self) pltpenc_list%nenc = 0 end if - call mergeadd_list%resize(0) - call mergesub_list%resize(0) + call pl_adds%resize(0) + call pl_discards%resize(0) end select end select end associate diff --git a/src/symba/symba_util.f90 b/src/symba/symba_util.f90 index 98c8889d8..4c0f256e3 100644 --- a/src/symba/symba_util.f90 +++ b/src/symba/symba_util.f90 @@ -2,7 +2,7 @@ use swiftest contains - module subroutine symba_util_append_arr_info(arr, source, lsource_mask) + module subroutine symba_util_append_arr_info(arr, source, nold, nsrc, lsource_mask) !! author: David A. Minton !! !! Append a single array of particle information type onto another. If the destination array is not allocated, or is not big enough, this will allocate space for it. @@ -10,38 +10,24 @@ module subroutine symba_util_append_arr_info(arr, source, lsource_mask) ! Arguments type(symba_particle_info), dimension(:), allocatable, intent(inout) :: arr !! Destination array type(symba_particle_info), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - ! Internals - integer(I4B) :: narr, nsrc + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to if (.not. allocated(source)) return - if (present(lsource_mask)) then - nsrc = count(lsource_mask) + if (.not.allocated(arr)) then + allocate(arr(nold+nsrc)) else - nsrc = size(source) + call util_resize(arr, nold + nsrc) end if - if (allocated(arr)) then - narr = size(arr) - else - allocate(arr(nsrc)) - narr = 0 - end if - - call util_resize(arr, narr + nsrc) - - if (present(lsource_mask)) then - arr(narr + 1:narr + nsrc) = pack(source(:), lsource_mask(:)) - else - arr(narr + 1:narr + nsrc) = source(:) - end if + arr(nold + 1:nold + nsrc) = pack(source(1:nsrc), lsource_mask(1:nsrc)) return end subroutine symba_util_append_arr_info - module subroutine symba_util_append_arr_kin(arr, source, lsource_mask) + module subroutine symba_util_append_arr_kin(arr, source, nold, nsrc, lsource_mask) !! author: David A. Minton !! !! Append a single array of kinship type onto another. If the destination array is not allocated, or is not big enough, this will allocate space for it. @@ -49,32 +35,18 @@ module subroutine symba_util_append_arr_kin(arr, source, lsource_mask) ! Arguments type(symba_kinship), dimension(:), allocatable, intent(inout) :: arr !! Destination array type(symba_kinship), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - ! Internals - integer(I4B) :: narr, nsrc + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to if (.not. allocated(source)) return - if (present(lsource_mask)) then - nsrc = count(lsource_mask) - else - nsrc = size(source) - end if - - if (allocated(arr)) then - narr = size(arr) + if (.not.allocated(arr)) then + allocate(arr(nold+nsrc)) else - allocate(arr(nsrc)) - narr = 0 + call util_resize(arr, nold + nsrc) end if - call util_resize(arr, narr + nsrc) - - if (present(lsource_mask)) then - arr(narr + 1:narr + nsrc) = pack(source(:), lsource_mask(:)) - else - arr(narr + 1:narr + nsrc) = source(:) - end if + arr(nold + 1:nold + nsrc) = pack(source(1:nsrc), lsource_mask(1:nsrc)) return end subroutine symba_util_append_arr_kin @@ -89,24 +61,26 @@ module subroutine symba_util_append_pl(self, source, lsource_mask) !! Arguments class(symba_pl), intent(inout) :: self !! SyMBA massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to select type(source) class is (symba_pl) - call util_append_pl(self, source, lsource_mask) ! Note: helio_pl does not have its own append method, so we skip back to the base class - - call util_append(self%lcollision, source%lcollision, lsource_mask) - call util_append(self%lencounter, source%lencounter, lsource_mask) - call util_append(self%lmtiny, source%lmtiny, lsource_mask) - call util_append(self%nplenc, source%nplenc, lsource_mask) - call util_append(self%ntpenc, source%ntpenc, lsource_mask) - call util_append(self%levelg, source%levelg, lsource_mask) - call util_append(self%levelm, source%levelm, lsource_mask) - call util_append(self%isperi, source%isperi, lsource_mask) - call util_append(self%peri, source%peri, lsource_mask) - call util_append(self%atp, source%atp, lsource_mask) - call util_append(self%kin, source%kin, lsource_mask) - call util_append(self%info, source%info, lsource_mask) + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%lcollision, source%lcollision, nold, nsrc, lsource_mask) + call util_append(self%lencounter, source%lencounter, nold, nsrc, lsource_mask) + call util_append(self%lmtiny, source%lmtiny, nold, nsrc, lsource_mask) + call util_append(self%nplenc, source%nplenc, nold, nsrc, lsource_mask) + call util_append(self%ntpenc, source%ntpenc, nold, nsrc, lsource_mask) + call util_append(self%levelg, source%levelg, nold, nsrc, lsource_mask) + call util_append(self%levelm, source%levelm, nold, nsrc, lsource_mask) + call util_append(self%isperi, source%isperi, nold, nsrc, lsource_mask) + call util_append(self%peri, source%peri, nold, nsrc, lsource_mask) + call util_append(self%atp, source%atp, nold, nsrc, lsource_mask) + call util_append(self%kin, source%kin, nold, nsrc, lsource_mask) + call util_append(self%info, source%info, nold, nsrc, lsource_mask) + + call util_append_pl(self, source, lsource_mask) ! Note: helio_pl does not have its own append method, so we skip back to the base class + end associate class default write(*,*) "Invalid object passed to the append method. Source must be of class symba_pl or its descendents!" call util_exit(FAILURE) @@ -125,24 +99,30 @@ module subroutine symba_util_append_merger(self, source, lsource_mask) ! Arguments class(symba_merger), intent(inout) :: self !! SyMBA massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to ! Internals integer(I4B), dimension(:), allocatable :: ncomp_tmp !! Temporary placeholder for ncomp incase we are appending a symba_pl object to a symba_merger + integer(I4B) :: nold, nsrc + nold = self%nbody + nsrc = source%nbody select type(source) class is (symba_merger) + call util_append(self%ncomp, source%ncomp, nold, nsrc, lsource_mask) call symba_util_append_pl(self, source, lsource_mask) - call util_append(self%ncomp, source%ncomp, lsource_mask) class is (symba_pl) - call symba_util_append_pl(self, source, lsource_mask) allocate(ncomp_tmp, mold=source%id) ncomp_tmp(:) = 0 - call util_append(self%ncomp, ncomp_tmp, lsource_mask) + call util_append(self%ncomp, ncomp_tmp, nold, nsrc, lsource_mask) + call symba_util_append_pl(self, source, lsource_mask) class default write(*,*) "Invalid object passed to the append method. Source must be of class symba_pl or its descendents!" call util_exit(FAILURE) end select + ! Save the number of appended bodies + self%ncomp(nold+1:nold+nsrc) = nsrc + return end subroutine symba_util_append_merger @@ -156,15 +136,18 @@ module subroutine symba_util_append_tp(self, source, lsource_mask) !! Arguments class(symba_tp), intent(inout) :: self !! SyMBA test particle object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to select type(source) class is (symba_tp) - call util_append_tp(self, source, lsource_mask) ! Note: helio_tp does not have its own append method, so we skip back to the base class - - call util_append(self%nplenc, source%nplenc, lsource_mask) - call util_append(self%levelg, source%levelg, lsource_mask) - call util_append(self%levelm, source%levelm, lsource_mask) + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%nplenc, source%nplenc, nold, nsrc, lsource_mask) + call util_append(self%levelg, source%levelg, nold, nsrc, lsource_mask) + call util_append(self%levelm, source%levelm, nold, nsrc, lsource_mask) + call util_append(self%info, source%info, nold, nsrc, lsource_mask) + + call util_append_tp(self, source, lsource_mask) ! Note: helio_tp does not have its own append method, so we skip back to the base class + end associate class default write(*,*) "Invalid object passed to the append method. Source must be of class symba_tp or its descendents!" call util_exit(FAILURE) @@ -271,6 +254,7 @@ module subroutine symba_util_fill_tp(self, inserts, lfill_list) call util_fill(keeps%nplenc, inserts%nplenc, lfill_list) call util_fill(keeps%levelg, inserts%levelg, lfill_list) call util_fill(keeps%levelm, inserts%levelm, lfill_list) + call util_fill(keeps%info, inserts%info, lfill_list) call util_fill_tp(keeps, inserts, lfill_list) ! Note: helio_tp does not have its own fill method, so we skip back to the base class class default @@ -379,27 +363,37 @@ module subroutine symba_util_rearray_pl(self, system, param) class(symba_nbody_system), intent(inout) :: system !! Swiftest nbody system object class(symba_parameters), intent(in) :: param !! Current run configuration parameters ! Internals - class(symba_pl), allocatable :: pl_discards !! The discarded body list. + class(symba_pl), allocatable :: tmp !! The discarded body list. + integer(I4B) :: i + logical, dimension(:), allocatable :: lmask + + associate(pl => self, pl_adds => system%pl_adds) + allocate(tmp, mold=pl) + ! Remove the discards and destroy the list, as the system already tracks pl_discards elsewhere + allocate(lmask, source=pl%ldiscard(:)) + lmask(:) = lmask(:) .or. pl%status(:) == INACTIVE + call pl%spill(tmp, lspill_list=lmask, ldestructive=.true.) + call tmp%setup(0,param) + deallocate(tmp) - associate(pl => self, mergeadd_list => system%mergeadd_list) - allocate(pl_discards, mold=pl) - ! Remove the discards - call pl%spill(pl_discards, lspill_list=(pl%ldiscard(:) .or. pl%status(:) == INACTIVE), ldestructive=.true.) + ! Deallocate any temporary variables + if (allocated(pl%xbeg)) deallocate(pl%xbeg) + if (allocated(pl%xend)) deallocate(pl%xend) ! Add in any new bodies - call pl%append(mergeadd_list) + if (pl_adds%nbody > 0) then + call pl%append(pl_adds, lsource_mask=[(.true., i=1, pl_adds%nbody)]) + call symba_io_dump_particle_info(system, param, plidx=[(i, i = 1, pl%nbody)]) + end if ! If there are still bodies in the system, sort by mass in descending order and re-index if (pl%nbody > 0) then call pl%sort("mass", ascending=.false.) - pl%lmtiny(:) = pl%Gmass(:) > param%MTINY + pl%lmtiny(:) = pl%Gmass(:) > param%GMTINY pl%nplm = count(pl%lmtiny(:)) call pl%eucl_index() end if - ! Destroy the discarded body list, since we already have what we need in the mergesub_list - call pl_discards%setup(0,param) - deallocate(pl_discards) end associate return @@ -483,10 +477,10 @@ module subroutine symba_util_resize_merger(self, nnew) class(symba_merger), intent(inout) :: self !! SyMBA massive body object integer(I4B), intent(in) :: nnew !! New size neded - call symba_util_resize_pl(self, nnew) - call util_resize(self%ncomp, nnew) + call symba_util_resize_pl(self, nnew) + return end subroutine symba_util_resize_merger @@ -500,8 +494,6 @@ module subroutine symba_util_resize_pl(self, nnew) class(symba_pl), intent(inout) :: self !! SyMBA massive body object integer(I4B), intent(in) :: nnew !! New size neded - call util_resize_pl(self, nnew) - call util_resize(self%lcollision, nnew) call util_resize(self%lencounter, nnew) call util_resize(self%lmtiny, nnew) @@ -515,6 +507,8 @@ module subroutine symba_util_resize_pl(self, nnew) call util_resize(self%kin, nnew) call util_resize(self%info, nnew) + call util_resize_pl(self, nnew) + return end subroutine symba_util_resize_pl @@ -528,11 +522,12 @@ module subroutine symba_util_resize_tp(self, nnew) class(symba_tp), intent(inout) :: self !! SyMBA test particle object integer(I4B), intent(in) :: nnew !! New size neded - call util_resize_tp(self, nnew) - call util_resize(self%nplenc, nnew) call util_resize(self%levelg, nnew) call util_resize(self%levelm, nnew) + call util_resize(self%info, nnew) + + call util_resize_tp(self, nnew) return end subroutine symba_util_resize_tp @@ -690,6 +685,7 @@ module subroutine symba_util_sort_rearrange_tp(self, ind) if (allocated(tp%nplenc)) tp%nplenc(1:ntp) = tp_sorted%nplenc(ind(1:ntp)) if (allocated(tp%levelg)) tp%levelg(1:ntp) = tp_sorted%levelg(ind(1:ntp)) if (allocated(tp%levelm)) tp%levelm(1:ntp) = tp_sorted%levelm(ind(1:ntp)) + if (allocated(tp%info)) tp%info(1:ntp) = tp_sorted%info(ind(1:ntp)) deallocate(tp_sorted) end associate @@ -847,6 +843,7 @@ module subroutine symba_util_spill_tp(self, discards, lspill_list, ldestructive) call util_spill(keeps%nplenc, discards%nplenc, lspill_list, ldestructive) call util_spill(keeps%levelg, discards%levelg, lspill_list, ldestructive) call util_spill(keeps%levelm, discards%levelm, lspill_list, ldestructive) + call util_spill(keeps%info, discards%info, lspill_list, ldestructive) call util_spill_tp(keeps, discards, lspill_list, ldestructive) class default diff --git a/src/util/util_append.f90 b/src/util/util_append.f90 index 0f7ac0bde..dc48f9861 100644 --- a/src/util/util_append.f90 +++ b/src/util/util_append.f90 @@ -2,7 +2,7 @@ use swiftest contains - module subroutine util_append_arr_char_string(arr, source, lsource_mask) + module subroutine util_append_arr_char_string(arr, source, nold, nsrc, lsource_mask) !! author: David A. Minton !! !! Append a single array of character string type onto another. If the destination array is not allocated, or is not big enough, this will allocate space for it. @@ -10,38 +10,24 @@ module subroutine util_append_arr_char_string(arr, source, lsource_mask) ! Arguments character(len=STRMAX), dimension(:), allocatable, intent(inout) :: arr !! Destination array character(len=STRMAX), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - ! Internals - integer(I4B) :: narr, nsrc + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to if (.not. allocated(source)) return - if (present(lsource_mask)) then - nsrc = count(lsource_mask) + if (.not.allocated(arr)) then + allocate(arr(nold+nsrc)) else - nsrc = size(source) + call util_resize(arr, nold + nsrc) end if - if (allocated(arr)) then - narr = size(arr) - else - allocate(arr(nsrc)) - narr = 0 - end if - - call util_resize(arr, narr + nsrc) - - if (present(lsource_mask)) then - arr(narr + 1:narr + nsrc) = pack(source(:), lsource_mask(:)) - else - arr(narr + 1:narr + nsrc) = source(:) - end if + arr(nold + 1:nold + nsrc) = pack(source(1:nsrc), lsource_mask(1:nsrc)) return end subroutine util_append_arr_char_string - module subroutine util_append_arr_DP(arr, source, lsource_mask) + module subroutine util_append_arr_DP(arr, source, nold, nsrc, lsource_mask) !! author: David A. Minton !! !! Append a single array of double precision type onto another. If the destination array is not allocated, or is not big enough, this will allocate space for it. @@ -49,38 +35,24 @@ module subroutine util_append_arr_DP(arr, source, lsource_mask) ! Arguments real(DP), dimension(:), allocatable, intent(inout) :: arr !! Destination array real(DP), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - ! Internals - integer(I4B) :: narr, nsrc + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to if (.not. allocated(source)) return - if (present(lsource_mask)) then - nsrc = count(lsource_mask) + if (.not.allocated(arr)) then + allocate(arr(nold+nsrc)) else - nsrc = size(source) + call util_resize(arr, nold + nsrc) end if - if (allocated(arr)) then - narr = size(arr) - else - allocate(arr(nsrc)) - narr = 0 - end if - - call util_resize(arr, narr + nsrc) - - if (present(lsource_mask)) then - arr(narr + 1:narr + nsrc) = pack(source(:), lsource_mask(:)) - else - arr(narr + 1:narr + nsrc) = source(:) - end if + arr(nold + 1:nold + nsrc) = pack(source(1:nsrc), lsource_mask(1:nsrc)) return end subroutine util_append_arr_DP - module subroutine util_append_arr_DPvec(arr, source, lsource_mask) + module subroutine util_append_arr_DPvec(arr, source, nold, nsrc, lsource_mask) !! author: David A. Minton !! !! Append a single array of double precision vector type of size (NDIM, n) onto another. If the destination array is not allocated, or is not big enough, this will allocate space for it. @@ -88,40 +60,26 @@ module subroutine util_append_arr_DPvec(arr, source, lsource_mask) ! Arguments real(DP), dimension(:,:), allocatable, intent(inout) :: arr !! Destination array real(DP), dimension(:,:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - ! Internals - integer(I4B) :: narr, nsrc + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to if (.not. allocated(source)) return - if (present(lsource_mask)) then - nsrc = count(lsource_mask) - else - nsrc = size(source, dim=2) - end if - - if (allocated(arr)) then - narr = size(arr, dim=2) + if (.not.allocated(arr)) then + allocate(arr(NDIM, nold+nsrc)) else - allocate(arr(NDIM, nsrc)) - narr = 0 + call util_resize(arr, nold + nsrc) end if - call util_resize(arr, narr + nsrc) - - if (present(lsource_mask)) then - arr(1, narr + 1:narr + nsrc) = pack(source(1,:), lsource_mask(:)) - arr(2, narr + 1:narr + nsrc) = pack(source(2,:), lsource_mask(:)) - arr(3, narr + 1:narr + nsrc) = pack(source(3,:), lsource_mask(:)) - else - arr(:, narr + 1:narr + nsrc) = source(:,:) - end if + arr(1, nold + 1:nold + nsrc) = pack(source(1,1:nsrc), lsource_mask(1:nsrc)) + arr(2, nold + 1:nold + nsrc) = pack(source(2,1:nsrc), lsource_mask(1:nsrc)) + arr(3, nold + 1:nold + nsrc) = pack(source(3,1:nsrc), lsource_mask(1:nsrc)) return end subroutine util_append_arr_DPvec - module subroutine util_append_arr_I4B(arr, source, lsource_mask) + module subroutine util_append_arr_I4B(arr, source, nold, nsrc, lsource_mask) !! author: David A. Minton !! !! Append a single array of integer(I4B) onto another. If the destination array is not allocated, or is not big enough, this will allocate space for it. @@ -129,38 +87,24 @@ module subroutine util_append_arr_I4B(arr, source, lsource_mask) ! Arguments integer(I4B), dimension(:), allocatable, intent(inout) :: arr !! Destination array integer(I4B), dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - ! Internals - integer(I4B) :: narr, nsrc + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to if (.not. allocated(source)) return - if (present(lsource_mask)) then - nsrc = count(lsource_mask) - else - nsrc = size(source) - end if - - if (allocated(arr)) then - narr = size(arr) + if (.not.allocated(arr)) then + allocate(arr(nold+nsrc)) else - allocate(arr(nsrc)) - narr = 0 + call util_resize(arr, nold + nsrc) end if - call util_resize(arr, narr + nsrc) - - if (present(lsource_mask)) then - arr(narr + 1:narr + nsrc) = pack(source(:), lsource_mask(:)) - else - arr(narr + 1:narr + nsrc) = source(:) - end if + arr(nold + 1:nold + nsrc) = pack(source(1:nsrc), lsource_mask(1:nsrc)) return end subroutine util_append_arr_I4B - module subroutine util_append_arr_logical(arr, source, lsource_mask) + module subroutine util_append_arr_logical(arr, source, nold, nsrc, lsource_mask) !! author: David A. Minton !! !! Append a single array of logical type onto another. If the destination array is not allocated, or is not big enough, this will allocate space for it. @@ -168,32 +112,18 @@ module subroutine util_append_arr_logical(arr, source, lsource_mask) ! Arguments logical, dimension(:), allocatable, intent(inout) :: arr !! Destination array logical, dimension(:), allocatable, intent(in) :: source !! Array to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - ! Internals - integer(I4B) :: narr, nsrc + integer(I4B), intent(in) :: nold, nsrc !! Extend of the old array and the source array, respectively + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to if (.not. allocated(source)) return - if (allocated(arr)) then - narr = size(arr) - else - allocate(arr(nsrc)) - narr = 0 - end if - - if (present(lsource_mask)) then - nsrc = count(lsource_mask) + if (.not.allocated(arr)) then + allocate(arr(nold+nsrc)) else - nsrc = size(source) + call util_resize(arr, nold + nsrc) end if - call util_resize(arr, narr + nsrc) - - if (present(lsource_mask)) then - arr(narr + 1:narr + nsrc) = pack(source(:), lsource_mask(:)) - else - arr(narr + 1:narr + nsrc) = source(:) - end if + arr(nold + 1:nold + nsrc) = pack(source(1:nsrc), lsource_mask(1:nsrc)) return end subroutine util_append_arr_logical @@ -208,29 +138,31 @@ module subroutine util_append_body(self, source, lsource_mask) ! Arguments class(swiftest_body), intent(inout) :: self !! Swiftest body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to - - call util_append(self%name, source%name, lsource_mask) - call util_append(self%id, source%id, lsource_mask) - call util_append(self%status, source%status, lsource_mask) - call util_append(self%ldiscard, source%ldiscard, lsource_mask) - call util_append(self%lmask, source%lmask, lsource_mask) - call util_append(self%mu, source%mu, lsource_mask) - call util_append(self%xh, source%xh, lsource_mask) - call util_append(self%vh, source%vh, lsource_mask) - call util_append(self%xb, source%xb, lsource_mask) - call util_append(self%vb, source%vb, lsource_mask) - call util_append(self%ah, source%ah, lsource_mask) - call util_append(self%aobl, source%aobl, lsource_mask) - call util_append(self%atide, source%atide, lsource_mask) - call util_append(self%agr, source%agr, lsource_mask) - call util_append(self%ir3h, source%ir3h, lsource_mask) - call util_append(self%a, source%a, lsource_mask) - call util_append(self%e, source%e, lsource_mask) - call util_append(self%inc, source%inc, lsource_mask) - call util_append(self%capom, source%capom, lsource_mask) - call util_append(self%omega, source%omega, lsource_mask) - call util_append(self%capm, source%capm, lsource_mask) + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%name, source%name, nold, nsrc, lsource_mask) + call util_append(self%id, source%id, nold, nsrc, lsource_mask) + call util_append(self%status, source%status, nold, nsrc, lsource_mask) + call util_append(self%ldiscard, source%ldiscard, nold, nsrc, lsource_mask) + call util_append(self%lmask, source%lmask, nold, nsrc, lsource_mask) + call util_append(self%mu, source%mu, nold, nsrc, lsource_mask) + call util_append(self%xh, source%xh, nold, nsrc, lsource_mask) + call util_append(self%vh, source%vh, nold, nsrc, lsource_mask) + call util_append(self%xb, source%xb, nold, nsrc, lsource_mask) + call util_append(self%vb, source%vb, nold, nsrc, lsource_mask) + call util_append(self%ah, source%ah, nold, nsrc, lsource_mask) + call util_append(self%aobl, source%aobl, nold, nsrc, lsource_mask) + call util_append(self%atide, source%atide, nold, nsrc, lsource_mask) + call util_append(self%agr, source%agr, nold, nsrc, lsource_mask) + call util_append(self%ir3h, source%ir3h, nold, nsrc, lsource_mask) + call util_append(self%a, source%a, nold, nsrc, lsource_mask) + call util_append(self%e, source%e, nold, nsrc, lsource_mask) + call util_append(self%inc, source%inc, nold, nsrc, lsource_mask) + call util_append(self%capom, source%capom, nold, nsrc, lsource_mask) + call util_append(self%omega, source%omega, nold, nsrc, lsource_mask) + call util_append(self%capm, source%capm, nold, nsrc, lsource_mask) + end associate self%nbody = count(self%status(:) /= INACTIVE) @@ -247,26 +179,28 @@ module subroutine util_append_pl(self, source, lsource_mask) ! Arguments class(swiftest_pl), intent(inout) :: self !! Swiftest massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to select type(source) class is (swiftest_pl) - call util_append_body(self, source, lsource_mask) - - call util_append(self%mass, source%mass, lsource_mask) - call util_append(self%Gmass, source%Gmass, lsource_mask) - call util_append(self%rhill, source%rhill, lsource_mask) - call util_append(self%radius, source%radius, lsource_mask) - call util_append(self%xbeg, source%xbeg, lsource_mask) - call util_append(self%xend, source%xend, lsource_mask) - call util_append(self%vbeg, source%vbeg, lsource_mask) - call util_append(self%density, source%density, lsource_mask) - call util_append(self%Ip, source%Ip, lsource_mask) - call util_append(self%rot, source%rot, lsource_mask) - call util_append(self%k2, source%k2, lsource_mask) - call util_append(self%Q, source%Q, lsource_mask) - call util_append(self%tlag, source%tlag, lsource_mask) + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%mass, source%mass, nold, nsrc, lsource_mask) + call util_append(self%Gmass, source%Gmass, nold, nsrc, lsource_mask) + call util_append(self%rhill, source%rhill, nold, nsrc, lsource_mask) + call util_append(self%radius, source%radius, nold, nsrc, lsource_mask) + call util_append(self%xbeg, source%xbeg, nold, nsrc, lsource_mask) + call util_append(self%xend, source%xend, nold, nsrc, lsource_mask) + call util_append(self%vbeg, source%vbeg, nold, nsrc, lsource_mask) + call util_append(self%density, source%density, nold, nsrc, lsource_mask) + call util_append(self%Ip, source%Ip, nold, nsrc, lsource_mask) + call util_append(self%rot, source%rot, nold, nsrc, lsource_mask) + call util_append(self%k2, source%k2, nold, nsrc, lsource_mask) + call util_append(self%Q, source%Q, nold, nsrc, lsource_mask) + call util_append(self%tlag, source%tlag, nold, nsrc, lsource_mask) + + call util_append_body(self, source, lsource_mask) + end associate call self%eucl_index() class default @@ -287,15 +221,17 @@ module subroutine util_append_tp(self, source, lsource_mask) ! Arguments class(swiftest_tp), intent(inout) :: self !! Swiftest test particle object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to select type(source) class is (swiftest_tp) - call util_append_body(self, source, lsource_mask) + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%isperi, source%isperi, nold, nsrc, lsource_mask) + call util_append(self%peri, source%peri, nold, nsrc, lsource_mask) + call util_append(self%atp, source%atp, nold, nsrc, lsource_mask) - call util_append(self%isperi, source%isperi, lsource_mask) - call util_append(self%peri, source%peri, lsource_mask) - call util_append(self%atp, source%atp, lsource_mask) + call util_append_body(self, source, lsource_mask) + end associate class default write(*,*) "Invalid object passed to the append method. Source must be of class swiftest_tp or its descendents" call util_exit(FAILURE) diff --git a/src/util/util_coord.f90 b/src/util/util_coord.f90 index c10dbace7..2a970d0dc 100644 --- a/src/util/util_coord.f90 +++ b/src/util/util_coord.f90 @@ -24,6 +24,7 @@ module subroutine util_coord_h2b_pl(self, cb) xtmp(:) = 0.0_DP vtmp(:) = 0.0_DP do i = 1, npl + if (pl%status(i) == INACTIVE) cycle Gmtot = Gmtot + pl%Gmass(i) xtmp(:) = xtmp(:) + pl%Gmass(i) * pl%xh(:,i) vtmp(:) = vtmp(:) + pl%Gmass(i) * pl%vh(:,i) @@ -31,6 +32,7 @@ module subroutine util_coord_h2b_pl(self, cb) cb%xb(:) = -xtmp(:) / Gmtot cb%vb(:) = -vtmp(:) / Gmtot do i = 1, npl + if (pl%status(i) == INACTIVE) cycle pl%xb(:,i) = pl%xh(:,i) + cb%xb(:) pl%vb(:,i) = pl%vh(:,i) + cb%vb(:) end do @@ -51,20 +53,15 @@ module subroutine util_coord_h2b_tp(self, cb) ! Arguments class(swiftest_tp), intent(inout) :: self !! Swiftest test particle object class(swiftest_cb), intent(in) :: cb !! Swiftest central body object + ! Internals + integer(I4B) :: i if (self%nbody == 0) return - associate(ntp => self%nbody, xbcb => cb%xb, vbcb => cb%vb, status => self%status, & - xb => self%xb, xh => self%xh, vb => self%vb, vh => self%vh) - - where(status(1:ntp) /= INACTIVE) - xb(1, 1:ntp) = xh(1, 1:ntp) + xbcb(1) - xb(2, 1:ntp) = xh(2, 1:ntp) + xbcb(2) - xb(3, 1:ntp) = xh(3, 1:ntp) + xbcb(3) - - vb(1, 1:ntp) = vh(1, 1:ntp) + vbcb(1) - vb(2, 1:ntp) = vh(2, 1:ntp) + vbcb(2) - vb(3, 1:ntp) = vh(3, 1:ntp) + vbcb(3) - end where + associate(tp => self, ntp => self%nbody) + do concurrent (i = 1:ntp, tp%status(i) /= INACTIVE) + tp%xb(:, i) = tp%xh(:, i) + cb%xb(:) + tp%vb(:, i) = tp%vh(:, i) + cb%vb(:) + end do end associate return @@ -87,11 +84,10 @@ module subroutine util_coord_b2h_pl(self, cb) if (self%nbody == 0) return - associate(npl => self%nbody, xbcb => cb%xb, vbcb => cb%vb, xb => self%xb, xh => self%xh, & - vb => self%vb, vh => self%vh) - do i = 1, NDIM - xh(i, 1:npl) = xb(i, 1:npl) - xbcb(i) - vh(i, 1:npl) = vb(i, 1:npl) - vbcb(i) + associate(pl => self, npl => self%nbody) + do concurrent (i = 1:npl, pl%status(i) /= INACTIVE) + pl%xh(:, i) = pl%xb(:, i) - cb%xb(:) + pl%vh(:, i) = pl%vb(:, i) - cb%vb(:) end do end associate @@ -110,20 +106,16 @@ module subroutine util_coord_b2h_tp(self, cb) ! Arguments class(swiftest_tp), intent(inout) :: self !! Swiftest massive body object class(swiftest_cb), intent(in) :: cb !! Swiftest central body object + ! Internals + integer(I4B) :: i if (self%nbody == 0) return - associate(ntp => self%nbody, xbcb => cb%xb, vbcb => cb%vb, xb => self%xb, xh => self%xh, & - vb => self%vb, vh => self%vh, status => self%status) - where(status(1:ntp) /= INACTIVE) - xh(1, 1:ntp) = xb(1, 1:ntp) - xbcb(1) - xh(2, 1:ntp) = xb(2, 1:ntp) - xbcb(2) - xh(3, 1:ntp) = xb(3, 1:ntp) - xbcb(3) - - vh(1, 1:ntp) = vb(1, 1:ntp) - vbcb(1) - vh(2, 1:ntp) = vb(2, 1:ntp) - vbcb(2) - vh(3, 1:ntp) = vb(3, 1:ntp) - vbcb(3) - end where + associate(tp => self, ntp => self%nbody) + do concurrent(i = 1:ntp, tp%status(i) /= INACTIVE) + tp%xh(:, i) = tp%xb(:, i) - cb%xb(:) + tp%vh(:, i) = tp%vb(:, i) - cb%vb(:) + end do end associate return diff --git a/src/util/util_get_energy_momentum.f90 b/src/util/util_get_energy_momentum.f90 index 38701229d..fa7cda43d 100644 --- a/src/util/util_get_energy_momentum.f90 +++ b/src/util/util_get_energy_momentum.f90 @@ -15,11 +15,12 @@ module subroutine util_get_energy_momentum_system(self, param) ! Internals integer(I4B) :: i, j integer(I8B) :: k - real(DP) :: rmag, v2, rot2, oblpot, hx, hy, hz, hsx, hsy, hsz + real(DP) :: oblpot, kecb, kespincb real(DP), dimension(self%pl%nbody) :: irh, kepl, kespinpl, pecb real(DP), dimension(self%pl%nbody) :: Lplorbitx, Lplorbity, Lplorbitz real(DP), dimension(self%pl%nbody) :: Lplspinx, Lplspiny, Lplspinz real(DP), dimension(self%pl%nplpl) :: pepl + real(DP), dimension(NDIM) :: Lcborbit, Lcbspin logical, dimension(self%pl%nplpl) :: lstatpl logical, dimension(self%pl%nbody) :: lstatus @@ -37,78 +38,99 @@ module subroutine util_get_energy_momentum_system(self, param) Lplspiny(:) = 0.0_DP Lplspinz(:) = 0.0_DP lstatus(1:npl) = pl%status(1:npl) /= INACTIVE - !!$omp simd private(v2, rot2, hx, hy, hz) - do i = 1, npl - v2 = dot_product(pl%vb(:,i), pl%vb(:,i)) - hx = pl%xb(2,i) * pl%vb(3,i) - pl%xb(3,i) * pl%vb(2,i) - hy = pl%xb(3,i) * pl%vb(1,i) - pl%xb(1,i) * pl%vb(3,i) - hz = pl%xb(1,i) * pl%vb(2,i) - pl%xb(2,i) * pl%vb(1,i) - ! Angular momentum from orbit - Lplorbitx(i) = pl%mass(i) * hx - Lplorbity(i) = pl%mass(i) * hy - Lplorbitz(i) = pl%mass(i) * hz + kecb = cb%mass * dot_product(cb%vb(:), cb%vb(:)) + Lcborbit(:) = cb%mass * cb%xb(:) .cross. cb%vb(:) + + do concurrent (i = 1:npl, lstatus(i)) + block ! We use a block construct to prevent generating temporary arrays for local variables + real(DP) :: v2, hx, hy, hz + v2 = dot_product(pl%vb(:,i), pl%vb(:,i)) + hx = pl%xb(2,i) * pl%vb(3,i) - pl%xb(3,i) * pl%vb(2,i) + hy = pl%xb(3,i) * pl%vb(1,i) - pl%xb(1,i) * pl%vb(3,i) + hz = pl%xb(1,i) * pl%vb(2,i) - pl%xb(2,i) * pl%vb(1,i) + + ! Angular momentum from orbit + Lplorbitx(i) = pl%mass(i) * hx + Lplorbity(i) = pl%mass(i) * hy + Lplorbitz(i) = pl%mass(i) * hz - ! Kinetic energy from orbit and spin - kepl(i) = pl%mass(i) * v2 + ! Kinetic energy from orbit and spin + kepl(i) = pl%mass(i) * v2 + end block end do if (param%lrotation) then - do i = 1, npl - rot2 = dot_product(pl%rot(:,i), pl%rot(:,i)) - ! For simplicity, we always assume that the rotation pole is the 3rd principal axis - hsx = pl%Ip(3,i) * pl%radius(i)**2 * pl%rot(1,i) - hsy = pl%Ip(3,i) * pl%radius(i)**2 * pl%rot(2,i) - hsz = pl%Ip(3,i) * pl%radius(i)**2 * pl%rot(3,i) + kespincb = cb%mass * cb%Ip(3) * cb%radius**2 * dot_product(cb%rot(:), cb%rot(:)) + + ! For simplicity, we always assume that the rotation pole is the 3rd principal axis + Lcbspin(:) = cb%Ip(3) * cb%mass * cb%radius**2 * cb%rot(:) - ! Angular momentum from spin - Lplspinx(i) = pl%mass(i) * hsx - Lplspiny(i) = pl%mass(i) * hsy - Lplspinz(i) = pl%mass(i) * hsz - kespinpl(i) = pl%mass(i) * pl%Ip(3, i) * pl%radius(i)**2 * rot2 + do concurrent (i = 1:npl, lstatus(i)) + block + real(DP) :: rot2, hsx, hsy, hsz + + rot2 = dot_product(pl%rot(:,i), pl%rot(:,i)) + ! For simplicity, we always assume that the rotation pole is the 3rd principal axis + hsx = pl%Ip(3,i) * pl%radius(i)**2 * pl%rot(1,i) + hsy = pl%Ip(3,i) * pl%radius(i)**2 * pl%rot(2,i) + hsz = pl%Ip(3,i) * pl%radius(i)**2 * pl%rot(3,i) + + ! Angular momentum from spin + Lplspinx(i) = pl%mass(i) * hsx + Lplspiny(i) = pl%mass(i) * hsy + Lplspinz(i) = pl%mass(i) * hsz + kespinpl(i) = pl%mass(i) * pl%Ip(3, i) * pl%radius(i)**2 * rot2 + end block end do else + kespincb = 0.0_DP kespinpl(:) = 0.0_DP end if ! Do the central body potential energy component first - !$omp simd - do i = 1, npl - associate(px => pl%xh(1,i), py => pl%xh(2,i), pz => pl%xh(3,i)) - pecb(i) = -cb%mass * pl%mass(i) / sqrt(px**2 + py**2 + pz**2) - end associate - end do + associate(px => pl%xb(1,:), py => pl%xb(2,:), pz => pl%xb(3,:)) + do concurrent(i = 1:npl, lstatus(i)) + pecb(i) = -cb%Gmass * pl%mass(i) / sqrt(px(i)**2 + py(i)**2 + pz(i)**2) + end do + end associate ! Do the potential energy between pairs of massive bodies - do k = 1, pl%nplpl - associate(ik => pl%k_plpl(1, k), jk => pl%k_plpl(2, k)) - pepl(k) = -pl%mass(ik) * pl%mass(jk) / norm2(pl%xb(:, jk) - pl%xb(:, ik)) - lstatpl(k) = (lstatus(ik) .and. lstatus(jk)) - end associate - end do - - system%ke_orbit = 0.5_DP * sum(kepl(1:npl), lstatus(:)) - if (param%lrotation) system%ke_spin = 0.5_DP * sum(kespinpl(1:npl), lstatus(:)) + associate(indi => pl%k_plpl(1, :), indj => pl%k_plpl(2, :)) + do concurrent (k = 1:pl%nplpl) + lstatpl(k) = (lstatus(indi(k)) .and. lstatus(indj(k))) + end do + + do concurrent (k = 1:pl%nplpl, lstatpl(k)) + pepl(k) = -pl%Gmass(indi(k)) * pl%mass(indj(k)) / norm2(pl%xb(:, indi(k)) - pl%xb(:, indj(k))) + end do + end associate - system%pe = sum(pepl(:), lstatpl(:)) + sum(pecb(2:npl), lstatus(2:npl)) + system%pe = sum(pepl(:), lstatpl(:)) + sum(pecb(1:npl), lstatus(1:npl)) + + system%ke_orbit = 0.5_DP * (kecb + sum(kepl(1:npl), lstatus(:))) + if (param%lrotation) system%ke_spin = 0.5_DP * (kespincb + sum(kespinpl(1:npl), lstatus(:))) ! Potential energy from the oblateness term if (param%loblatecb) then - !$omp simd - do i = 1, npl + do concurrent(i = 1:npl, lstatus(i)) irh(i) = 1.0_DP / norm2(pl%xh(:,i)) end do - call obl_pot(npl, cb%mass, pl%mass, cb%j2rp2, cb%j4rp4, pl%xh, irh, oblpot) + call obl_pot(npl, cb%Gmass, pl%mass, cb%j2rp2, cb%j4rp4, pl%xh, irh, oblpot) system%pe = system%pe + oblpot end if - system%Lorbit(1) = sum(Lplorbitx(1:npl), lstatus(1:npl)) - system%Lorbit(2) = sum(Lplorbity(1:npl), lstatus(1:npl)) - system%Lorbit(3) = sum(Lplorbitz(1:npl), lstatus(1:npl)) - - system%Lspin(1) = sum(Lplspinx(1:npl), lstatus(1:npl)) - system%Lspin(2) = sum(Lplspiny(1:npl), lstatus(1:npl)) - system%Lspin(3) = sum(Lplspinz(1:npl), lstatus(1:npl)) + system%Lorbit(1) = Lcborbit(1) + sum(Lplorbitx(1:npl), lstatus(1:npl)) + system%Lorbit(2) = Lcborbit(2) + sum(Lplorbity(1:npl), lstatus(1:npl)) + system%Lorbit(3) = Lcborbit(3) + sum(Lplorbitz(1:npl), lstatus(1:npl)) + + if (param%lrotation) then + system%Lspin(1) = Lcbspin(1) + sum(Lplspinx(1:npl), lstatus(1:npl)) + system%Lspin(2) = Lcbspin(2) + sum(Lplspiny(1:npl), lstatus(1:npl)) + system%Lspin(3) = Lcbspin(3) + sum(Lplspinz(1:npl), lstatus(1:npl)) + end if + + system%te = system%ke_orbit + system%ke_spin + system%pe end associate return diff --git a/src/util/util_rescale.f90 b/src/util/util_rescale.f90 new file mode 100644 index 000000000..62a9409ec --- /dev/null +++ b/src/util/util_rescale.f90 @@ -0,0 +1,52 @@ +submodule (swiftest_classes) s_util_rescale + use swiftest +contains + module subroutine util_rescale_system(self, param, mscale, dscale, tscale) + !! author: David A. Minton + !! + !! Rescales an nbody system to a new set of units. Inputs are the multipliers on the mass (mscale), distance (dscale), and time units (tscale). + !! Rescales all united quantities in the system, as well as the mass conversion factors, gravitational constant, and Einstein's constant in the parameter object. + implicit none + class(swiftest_nbody_system), intent(inout) :: self !! Swiftest nbody system object + class(swiftest_parameters), intent(inout) :: param !! Current run configuration parameters. Returns with new values of the scale vactors and GU + real(DP), intent(in) :: mscale, dscale, tscale !! Scale factors for mass, distance, and time units, respectively. + ! Internals + real(DP) :: vscale + + param%MU2KG = param%MU2KG * mscale + param%DU2M = param%DU2M * dscale + param%TU2S = param%TU2S * tscale + + ! Calculate the G for the system units + param%GU = GC / (param%DU2M**3 / (param%MU2KG * param%TU2S**2)) + + ! Calculate the inverse speed of light in the system units + param%inv_c2 = einsteinC * param%TU2S / param%DU2M + param%inv_c2 = (param%inv_c2)**(-2) + + vscale = dscale / tscale + + associate(cb => self%cb, pl => self%pl, npl => self%pl%nbody, tp => self%tp, ntp => self%tp%nbody) + + cb%mass = cb%mass / mscale + cb%Gmass = param%GU * cb%mass + cb%radius = cb%radius / dscale + cb%xb(:) = cb%xb(:) / dscale + cb%vb(:) = cb%vb(:) / vscale + cb%rot(:) = cb%rot(:) * tscale + pl%mass(1:npl) = pl%mass(1:npl) / mscale + pl%Gmass(1:npl) = param%GU * pl%mass(1:npl) + pl%radius(1:npl) = pl%radius(1:npl) / dscale + pl%xh(:,1:npl) = pl%xh(:,1:npl) / dscale + pl%vh(:,1:npl) = pl%vh(:,1:npl) / vscale + pl%xb(:,1:npl) = pl%xb(:,1:npl) / dscale + pl%vb(:,1:npl) = pl%vb(:,1:npl) / vscale + pl%rot(:,1:npl) = pl%rot(:,1:npl) * tscale + + end associate + + + return + end subroutine util_rescale_system + +end submodule s_util_rescale \ No newline at end of file diff --git a/src/util/util_resize.f90 b/src/util/util_resize.f90 index c6d5aa34f..80d87209c 100644 --- a/src/util/util_resize.f90 +++ b/src/util/util_resize.f90 @@ -1,6 +1,7 @@ submodule (swiftest_classes) s_util_resize use swiftest contains + module subroutine util_resize_arr_char_string(arr, nnew) !! author: David A. Minton !! diff --git a/src/util/util_spill.f90 b/src/util/util_spill.f90 index 9acc6ae93..9c76ff5e9 100644 --- a/src/util/util_spill.f90 +++ b/src/util/util_spill.f90 @@ -183,7 +183,7 @@ module subroutine util_spill_body(self, discards, lspill_list, ldestructive) ! This is the base class, so will be the last to be called in the cascade. ! Therefore we need to set the nbody values for both the keeps and discareds discards%nbody = count(lspill_list(:)) - keeps%nbody = count(.not.lspill_list(:)) + keeps%nbody = keeps%nbody - discards%nbody if (keeps%nbody > size(keeps%status)) keeps%status(keeps%nbody+1:size(keeps%status)) = INACTIVE end associate diff --git a/src/util/util_valid.f90 b/src/util/util_valid.f90 index c5923b38e..f05c81f35 100644 --- a/src/util/util_valid.f90 +++ b/src/util/util_valid.f90 @@ -2,7 +2,7 @@ use swiftest contains - module subroutine util_valid(pl, tp) + module subroutine util_valid_id_system(self, param) !! author: David A. Minton !! !! Validate massive body and test particle ids @@ -11,31 +11,33 @@ module subroutine util_valid(pl, tp) !! Adapted from David E. Kaufmann's Swifter routine: util_valid.f90 implicit none ! Arguments - class(swiftest_pl), intent(in) :: pl - class(swiftest_tp), intent(in) :: tp + class(swiftest_nbody_system), intent(inout) :: self !! Swiftest nbody system object + class(swiftest_parameters), intent(in) :: param !! Current run configuration parameters ! Internals integer(I4B) :: i integer(I4B), dimension(:), allocatable :: idarr - associate(npl => pl%nbody, ntp => tp%nbody) - allocate(idarr(npl+ntp)) + associate(cb => self%cb, pl => self%pl, npl => self%pl%nbody, tp => self%tp, ntp => self%tp%nbody) + allocate(idarr(1+npl+ntp)) + idarr(1) = cb%id do i = 1, npl - idarr(i) = pl%id(i) + idarr(1+i) = pl%id(i) end do do i = 1, ntp - idarr(npl+i) = tp%id(i) + idarr(1+npl+i) = tp%id(i) end do call util_sort(idarr) - do i = 1, npl + ntp - 1 + do i = 1, npl + ntp if (idarr(i) == idarr(i+1)) then write(*, *) "Swiftest error:" write(*, *) " more than one body/particle has id = ", idarr(i) call util_exit(FAILURE) end if end do + self%maxid = maxval(idarr) end associate return - end subroutine util_valid + end subroutine util_valid_id_system end submodule s_util_valid diff --git a/src/whm/whm_setup.f90 b/src/whm/whm_setup.f90 index cbf36cc90..eaed16c14 100644 --- a/src/whm/whm_setup.f90 +++ b/src/whm/whm_setup.f90 @@ -82,7 +82,7 @@ module subroutine whm_setup_initialize_system(self, param) call self%pl%sort("ir3h", ascending=.false.) ! Make sure that the discard list gets allocated initially - call self%tp_discards%setup(self%tp%nbody, param) + call self%tp_discards%setup(0, param) call self%pl%set_mu(self%cb) call self%tp%set_mu(self%cb) if (param%lgr) then diff --git a/src/whm/whm_util.f90 b/src/whm/whm_util.f90 index f3dc15d3e..cc84ba3d5 100644 --- a/src/whm/whm_util.f90 +++ b/src/whm/whm_util.f90 @@ -11,17 +11,19 @@ module subroutine whm_util_append_pl(self, source, lsource_mask) !! Arguments class(whm_pl), intent(inout) :: self !! WHM massive body object class(swiftest_body), intent(in) :: source !! Source object to append - logical, dimension(:), optional, intent(in) :: lsource_mask !! Logical mask indicating which elements to append to + logical, dimension(:), intent(in) :: lsource_mask !! Logical mask indicating which elements to append to select type(source) class is (whm_pl) - call util_append_pl(self, source, lsource_mask) - - call util_append(self%eta, source%eta, lsource_mask) - call util_append(self%muj, source%muj, lsource_mask) - call util_append(self%ir3j, source%ir3j, lsource_mask) - call util_append(self%xj, source%xj, lsource_mask) - call util_append(self%vj, source%vj, lsource_mask) + associate(nold => self%nbody, nsrc => source%nbody) + call util_append(self%eta, source%eta, nold, nsrc, lsource_mask) + call util_append(self%muj, source%muj, nold, nsrc, lsource_mask) + call util_append(self%ir3j, source%ir3j, nold, nsrc, lsource_mask) + call util_append(self%xj, source%xj, nold, nsrc, lsource_mask) + call util_append(self%vj, source%vj, nold, nsrc, lsource_mask) + + call util_append_pl(self, source, lsource_mask) + end associate class default write(*,*) "Invalid object passed to the append method. Source must be of class whm_pl or its descendents" call util_exit(FAILURE) @@ -74,14 +76,14 @@ module subroutine whm_util_resize_pl(self, nnew) class(whm_pl), intent(inout) :: self !! WHM massive body object integer(I4B), intent(in) :: nnew !! New size neded - call util_resize_pl(self, nnew) - call util_resize(self%eta, nnew) call util_resize(self%xj, nnew) call util_resize(self%vj, nnew) call util_resize(self%muj, nnew) call util_resize(self%ir3j, nnew) + call util_resize_pl(self, nnew) + return end subroutine whm_util_resize_pl diff --git a/tp_maker.py b/tp_maker.py deleted file mode 100644 index 900283375..000000000 --- a/tp_maker.py +++ /dev/null @@ -1,59 +0,0 @@ -import rebound -import numpy as np - -sim = rebound.Simulation() -sim.units = ('AU', 'yr', 'Msun') -sim.add(m=1.) -sim.move_to_com() -ps = sim.particles - -#!!!!!!! CHANGE THESE THINGS !!!!!!!!!!!!! - -sim.convert_particle_units('AU', 'd', 'Msun') - -N_tp = 3000 -N_ps = 2001 - -#TP_OUTFILE_SWIFT = open('Feb25_tp_2_swift.txt', 'w') -TP_OUTFILE_SWIFTER = open('tp.in', 'w') - -np.random.seed(2) - -#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! - -def uniform(minimum, maximum): - return np.random.uniform()*(maximum-minimum)+minimum - -while sim.N < (1+N_tp): - a_tp = uniform(1.7,2.0) - e_tp = uniform(0.0, 0.3) - inc_tp = uniform(0.0, 0.3) - O_tp = uniform(0,2*np.pi) - o_tp = uniform(0,2*np.pi) - M_tp = uniform(-np.pi, np.pi) - tp = rebound.Particle(simulation=sim,primary=sim.particles[0],m=0.0, r=0.0, a=a_tp, e=e_tp, inc=inc_tp, Omega=O_tp, omega=o_tp, M=M_tp) - sim.add(tp) - -x_tp = [ps[i].x for i in range(0, sim.N)] -y_tp = [ps[i].y for i in range(0, sim.N)] -z_tp = [ps[i].z for i in range(0, sim.N)] -vx_tp = [ps[i].vx for i in range(0, sim.N)] -vy_tp = [ps[i].vy for i in range(0, sim.N)] -vz_tp = [ps[i].vz for i in range(0, sim.N)] - -#with TP_OUTFILE_SWIFT as output: -# output.write("%s \n" %(N_tp)) #number of particles in the system -# for i in range (1, sim.N): -# output.write("%s %s %s \n" % ("{:10.8e}".format(x_tp[i]), "{:10.8e}".format(y_tp[i]), "{:10.8e}".format(z_tp[i]))) #x y z -# output.write("%s %s %s \n" % ("{:10.8e}".format(vx_tp[i]), "{:10.8e}".format(vy_tp[i]), "{:10.8e}".format(vz_tp[i]))) #vx vy vz -# output.write("0 0 0 0 0 0 0 0 0 0 0 0 0\n") #flags -# output.write("0.0d0 0.0d0 0.0d0 0.0d0 0.0d0\n") #flags -# output.write("0.0d0 0.0d0 0.0d0 0.0d0 0.0d0\n") #flags -# output.write("0.0d0 0.0d0 0.0d0\n") #flags - -with TP_OUTFILE_SWIFTER as output: - output.write("%s \n" %(N_tp)) #number of particles in the system - for i in range (1, sim.N): - output.write("%s \n" % ((i+N_ps) )) #ID - output.write("%s %s %s \n" % ("{:10.8e}".format(x_tp[i]), "{:10.8e}".format(y_tp[i]), "{:10.8e}".format(z_tp[i]))) #x y z - output.write("%s %s %s \n" % ("{:10.8e}".format(vx_tp[i]), "{:10.8e}".format(vy_tp[i]), "{:10.8e}".format(vz_tp[i]))) #vx vy vz \ No newline at end of file