Merge pull request #15 from xsuite/release/v0.1.6

Release 0.1.6

Author: freddieknets

.gitignore

@@ -143,12 +143,6 @@ dmypy.json
 # VSCode
 .vscode/
 
-# CMake
-CMakeCache*.txt
-CMakeFiles*/
-Makefile*
-cmake_install*.cmake
-
 # SixTrack
 fort.??*
 *.so

examples/results.py

@@ -2,7 +2,7 @@
 
 list_of_succeeded_jobs = []
 user='ddicroce'
-studyname='example_study'
-for jobname, new_particles in xb.RetrieveJobs(user=user, study=studyname):
-    print(jobname)
+study_name='example_study'
+for new_particles, jobinfo in xb.RetrieveJobs(user=user, study_name=study_name):
+    print(jobinfo)
     print(f"Particles: {new_particles.at_turn}")

examples/submission.py

@@ -12,34 +12,31 @@
 
 
 user = 'sixtadm'
-
-
-num_turns = 2000
-num_particles = 1e6
-line = xt.Line(elements=[
-    xt.Drift(length=1.0), xt.Multipole(knl=[1e-6]), xt.Drift(length=1.0)])
-
-particles_per_sub = 1000
-
-studyname = "example_study"
-
-
-# Submission can be done in a context, where the submission
-# itself is triggered when exiting the context
-with xb.SubmitJobs(user=user, study=studyname) as submitter:
-    for i in range(int(num_particles/particles_per_sub)):
-        particles = xp.Particles(x=np.random.normal(0, 0.0001, particles_per_sub),
-                                 y=np.random.normal(0, 0.0001, particles_per_sub))
-        submitter.add(job_name=f'{studyname}_{i}', num_turns=num_turns, line=line, particles=particles,
-                checkpoint_every=100)
-
-
-# Or by manually triggering the submission
-submitter = xb.SubmitJobs(user=user, study=studyname)
-for i in range(int(num_particles/particles_per_sub)):
-    particles = xp.Particles(x=np.random.normal(0, 0.0001, particles_per_sub),
-                             y=np.random.normal(0, 0.0001, particles_per_sub))
-    submitter.add(job_name=f'{studyname}_{i}', num_turns=num_turns, line=line, particles=particles,
-                  checkpoint_every=100)
-submitter.submit()
+line = xt.Line.from_json(xb._pkg_root.parent / 'tests' / 'data' / 'sequence_lhc_run3_b1.json')
+line.build_tracker()
+
+# Each of these jobs takes ~3h  (~3500 particle*turns / second)
+num_jobs = 250
+num_part_per_job = 400
+num_turns = 100000
+checkpoint_every = 1000
+
+all_part = line.build_particles(x_norm=np.random.normal(0, 10, num_part_per_job*num_jobs),
+                                y_norm=np.random.normal(0, 10, num_part_per_job*num_jobs),
+                                nemitt_x=3.5e-6, nemitt_y=3.5e-6)
+
+study_name = "example_study"
+jobs = xb.SubmitJobs(user=user, study_name=study_name, line=line, dev_server=True)
+prev = time.time()
+for i in range(num_jobs):
+    # select subgroup of particles
+    this_part = all_part.filter((all_part.particle_id>=i*num_part_per_job) \
+                                & (all_part.particle_id<(i+1)*num_part_per_job))
+    # create job
+    jobs.add(job_name=f'job{i}', num_turns=num_turns, particles=this_part,
+             checkpoint_every=checkpoint_every)
+    # output progress
+    if i%25 == 24:
+        now = time.time() ; print(f"{i+1}/{num_jobs}  ({now-prev:.4}s)"); prev = now
+jobs.submit()
 

examples/timing.py

@@ -0,0 +1,42 @@
+import subprocess
+import time
+from pathlib import Path
+import numpy as np
+
+import xtrack as xt
+import xboinc as xb
+
+line = xt.Line.from_json('../tests/data/sequence_lhc_run3_b1.json')
+line.build_tracker()
+file_in  = Path('xboinc_input.bin')
+file_out = Path('sim_state_out.bin')
+
+num_part = 200
+num_turns = 50
+checkpoint_every = 10
+
+part = line.build_particles(x_norm=np.random.normal(0, 10, num_part),
+                            y_norm=np.random.normal(0, 10, num_part),
+                            nemitt_x=3.5e-6, nemitt_y=3.5e-6)
+
+xb.SimConfig.build(filename=file_in, num_turns=num_turns, line=line,
+                   particles=part, checkpoint_every=checkpoint_every)
+
+print("")
+now = time.time()
+cmd = subprocess.run(['running/xboinc_0.1-x86_64-pc-linux-gnu'])
+print(f"Tracking with executable: done in {time.time()-now:.1f}s")
+line.track(part, num_turns=num_turns, time=True)
+print(f"Tracking from within python: done in {line.time_last_track:.1f}s.")
+
+exec_part = xb.SimState.from_binary(file_out).particles
+assert np.all(part.state == exec_part.state)
+assert np.allclose(part.x, exec_part.x, rtol=1e-10)
+assert np.allclose(part.px, exec_part.px, rtol=1e-10)
+assert np.allclose(part.y, exec_part.y, rtol=1e-10)
+assert np.allclose(part.py, exec_part.py, rtol=1e-10)
+assert np.allclose(part.zeta, exec_part.zeta, rtol=1e-10)
+assert np.allclose(part.delta, exec_part.delta, rtol=1e-10)
+print("Particles match!")
+file_in.unlink()
+file_out.unlink()

pyproject.toml

@@ -5,7 +5,7 @@
 
 [tool.poetry]
 name = "xboinc"
-version = "0.1.5"
+version = "0.1.6"
 description = "Xsuite BOINC interface"
 homepage = "https://github.com/xsuite/xboinc"
 repository = "https://github.com/xsuite/xboinc"
@@ -22,12 +22,12 @@ include = [ "LICENSE", "NOTICE" ]
 [tool.poetry.dependencies]
 python   = '>=3.8'
 numpy    = '>=1.0'
-xobjects = '==0.2.8'
-xdeps    = '==0.4.2'
-xpart    = '==0.15.3'
-xtrack   = '==0.42.0'
-xfields  = '==0.13.1'
-xcoll    = '==0.2.5'
+xobjects = '==0.2.10'
+xdeps    = '==0.5.2'
+xpart    = '==0.16.3'
+xtrack   = '==0.48.1'
+xfields  = '==0.15.0'
+xcoll    = '==0.2.7'
 
 [tool.poetry.dev-dependencies]
 pytest = ">7"

tests/test_00_version.py

@@ -12,7 +12,7 @@
 
 
 def test_version():
-    assert __version__ == '0.1.5'
+    assert __version__ == '0.1.6'
 
 
 def test_sim_ver():
@@ -25,12 +25,12 @@ def test_sim_ver():
 
 def test_xsuite_versions():
     expected_version = {
-        'xobjects' : '0.2.8',
-        'xdeps'    : '0.4.2',
-        'xpart'    : '0.15.3',
-        'xtrack'   : '0.42.0',
-        'xfields'  : '0.13.1',
-        'xcoll'    : '0.2.5',
+        'xobjects' : '0.2.10',
+        'xdeps'    : '0.5.2',
+        'xpart'    : '0.16.3',
+        'xtrack'   : '0.48.1',
+        'xfields'  : '0.15.0',
+        'xcoll'    : '0.2.7',
     }
     current_version = {}
 

tests/test_01_compilation_and_running.py

@@ -18,6 +18,9 @@
 
 line_file = xb._pkg_root.parent / 'tests' / 'data' / 'sequence_lhc_run3_b1.json'
 num_turns = 1000
+input_filename      = 'xboinc_input.bin'
+output_filename     = 'sim_state_out.bin'
+checkpoint_filename = 'checkpoint.bin'
 
 
 def test_compilation():
@@ -48,13 +51,13 @@ def test_generate_input():
     xb._skip_xsuite_version_check = True
     line, part = _make_input()
     xb.SimConfig.build(line=line, particles=part, num_turns=num_turns, checkpoint_every=10,
-                        filename='xboinc_input.bin')
-    input_file = Path.cwd() / "xboinc_input.bin"
+                        filename=input_filename)
+    input_file = Path.cwd() / input_filename
     assert input_file.exists()
     xb._skip_xsuite_version_check = False
 
 
-def test_track():
+def test_track(request):
     xb._skip_xsuite_version_check = True
     # If no executable is present, make one
     exec_file = list(Path.cwd().glob(f'xboinc_{xb.app_version}-*'))
@@ -64,19 +67,22 @@ def test_track():
     exec_file = exec_file[0]
 
     # If no input file is present, make one
-    input_file = Path.cwd() / 'xboinc_input.bin'
+    input_file = Path.cwd() / input_filename
     if not input_file.exists():
         test_generate_input()
 
     # run xboinc tracker
     t1 = time.time()
     cmd = subprocess.run([exec_file])
-    print(round(time.time() - t1, 1))
+    calculation_time = round(time.time() - t1, 1)
+    request.config.cache.set('calculation_time', calculation_time)
     if cmd.returncode != 0:
         raise RuntimeError(f"Tracking failed.")
+    else:
+        print(f"Tracking done in {calculation_time}s.")
 
     # Read output
-    output_file = Path.cwd() / 'sim_state_out.bin'
+    output_file = Path.cwd() / output_filename
     assert output_file.exists()
     sim_state = xb.SimState.from_binary(output_file)
 
@@ -93,11 +99,11 @@ def test_track():
     assert not np.allclose(part_xboinc.py, part_xboinc.py[0], rtol=1e-4, atol=0)
 
     # Rename file for comparison in next test
-    output_file.rename(output_file.parent / f'{output_file.name}_2')
+    output_file.rename(output_file.parent / f"{output_filename}_2")
     xb._skip_xsuite_version_check = False
 
 
-def test_checkpoint():
+def test_checkpoint(request):
     xb._skip_xsuite_version_check = True
     # If no executable is present, make one
     exec_file = list(Path.cwd().glob(f'xboinc_{xb.app_version}-*'))
@@ -107,25 +113,28 @@ def test_checkpoint():
     exec_file = exec_file[0]
 
     # If no input file is present, make one
-    input_file = Path.cwd() / 'xboinc_input.bin'
+    input_file = Path.cwd() / input_filename
     if not input_file.exists():
         test_generate_input()
 
     # If previous output file not present, we need to regenerate it (to be able to compare)
-    output_file = Path.cwd() / 'sim_state_out.bin_2'
+    output_file = Path.cwd() / f"{output_filename}_2"
     if not output_file.exists():
         test_track()
 
     # run xboinc tracker and interrupt halfway
     interrupted = False
-    timeout = 25
+    timeout = 0.6*request.config.cache.get('calculation_time', 25)
     print(f"Will interrupt after {timeout}s.")
+    t1 = time.time()
+    calculation_time = round(time.time() - t1, 1)
     try:
         cmd = subprocess.run(exec_file, timeout=timeout)
     except subprocess.TimeoutExpired:
         interrupted = True
-        print("Interrupted calculation. Now trying to continue.")
-        checkpoint_file = Path.cwd() / 'checkpoint.bin'
+        t2 = time.time()
+        print(f"Interrupted calculation after {round(t2 - t1, 1)}s. Now trying to continue.")
+        checkpoint_file = Path.cwd() / checkpoint_filename
         assert checkpoint_file.exists()
     if not interrupted:
         raise ValueError("Timeout was too short. Adapt the test 'test_checkpoint'.")
@@ -134,18 +143,21 @@ def test_checkpoint():
     cmd = subprocess.run(exec_file)
     if cmd.returncode != 0:
         raise RuntimeError(f"Tracking failed.")
+    else:
+        t3 = time.time()
+        print(f"Continued tracking done in {round(t3 - t2, 1)}s (total tracking time {round(t3 - t1, 1)}s).")
 
     # Compare file to previous result
-    output_file = Path.cwd() / 'sim_state_out.bin'
+    output_file = Path.cwd() / output_filename
     assert output_file.exists()
-    assert filecmp.cmp(output_file, output_file.parent / f'{output_file.name}_2', shallow=False)
+    assert filecmp.cmp(output_file, output_file.parent / f"{output_file.name}_2", shallow=False)
     xb._skip_xsuite_version_check = False
 
 
 def test_vs_xtrack():
     xb._skip_xsuite_version_check = True
     # If no output is present, make one
-    output_file = Path.cwd() / 'sim_state_out.bin_2'
+    output_file = Path.cwd() / f"{output_filename}_2"
     if not output_file.exists():
         test_track()
     sim_state = xb.SimState.from_binary(output_file)

tests/test_02_user.py

@@ -8,30 +8,59 @@
 import pytest
 
 import xboinc as xb
+from xboinc.user import user_data_file, get_directory, get_domain, get_user_data
+from xboinc.server import server_account, dropdir, fs_exists
+from xboinc.server.paths import _test_afs, _test_eos
 
+register_file       = dropdir / f"register_{server_account}.json"
+deregister_file     = dropdir / f"deregister_{server_account}.json"
+register_file_dev   = dropdir / f"dev_register_{server_account}.json"
+deregister_file_dev = dropdir / f"dev_deregister_{server_account}.json"
 
-user       = 'sixtadm'
-folder_afs = Path('/afs/cern.ch/user/s/sixtadm/public/test_xboinc').resolve()
-folder_eos = Path('/afs/cern.ch/user/s/sixtadm/eos_sixtadm/test_xboinc').resolve()
-user_data_file = xb._pkg_root / 'user_data.json'
 
-
-def test_remove():
-    xb.user.remove_user(user)
-    with user_data_file.open('r') as fid:
+def test_register():
+    xb.register(server_account, _test_afs)
+    assert get_directory(server_account) == _test_afs
+    assert (get_directory(server_account) / 'input').exists()
+    assert (get_directory(server_account) / 'output').exists()
+    assert (get_directory(server_account) / 'input_dev').exists()
+    assert (get_directory(server_account) / 'output_dev').exists()
+    assert get_domain(server_account) == 'afs'
+    assert get_user_data(server_account)['directory'] == _test_afs.as_posix()
+    assert get_user_data(server_account)['domain'] == 'afs'
+    assert fs_exists(register_file)
+    assert not fs_exists(deregister_file)
+    with register_file.open('r') as fid:
         userdict = json.load(fid)
-    assert user not in userdict.keys()
+    assert userdict['user'] == server_account
+    assert userdict['directory'] == _test_afs.as_posix()
+    assert userdict['domain'] == 'afs'
+    assert fs_exists(register_file_dev)
+    assert not fs_exists(deregister_file_dev)
+    with register_file_dev.open('r') as fid:
+        userdict = json.load(fid)
+    assert userdict['user'] == server_account
+    assert userdict['directory'] == _test_afs.as_posix()
+    assert userdict['domain'] == 'afs'
 
+    with pytest.raises(NotImplementedError):
+        xb.register(server_account, _test_eos)
 
-def test_register():
-    xb.register(user, folder_afs)
-    assert xb.user.get_folder(user) == folder_afs
-    assert (xb.user.get_folder(user) / 'input').exists()
-    assert (xb.user.get_folder(user) / 'output').exists()
-    assert xb.user.get_domain(user) == 'afs'
-    assert xb.user.get_user_data(user)['folder'] == folder_afs.as_posix()
-    assert xb.user.get_user_data(user)['domain'] == 'afs'
-    assert xb.server.eos.eos_exists(xb.server.paths.dropdir / f"register_{user}.json")
 
-    with pytest.raises(NotImplementedError):
-        xb.register(user, folder_eos)
+def test_deregister():
+    xb.deregister(server_account)
+    with user_data_file.open('r') as fid:
+        userdict = json.load(fid)
+    assert server_account not in userdict.keys()
+    with pytest.raises(ValueError):
+        get_user_data(server_account)
+    assert not fs_exists(register_file)
+    assert not fs_exists(register_file_dev)
+    assert fs_exists(deregister_file)
+    with deregister_file.open('r') as fid:
+        userdict = json.load(fid)
+    assert userdict['user'] == server_account
+    assert fs_exists(deregister_file_dev)
+    with deregister_file_dev.open('r') as fid:
+        userdict = json.load(fid)
+    assert userdict['user'] == server_account