KinKal

From Mu2eWiki
Revision as of 16:08, 3 August 2023 by Kutschke (talk | contribs)
Jump to navigation Jump to search

Local KinKal development with Muse

Under development morning of Aug 3, 2023

Introduction

This section describes how to do simultaneous development of KinKal and Offline. Because KinKal uses a different build system than does Offline, you need to take a few additional steps when you start. Once you have taken these steps "muse build" will first build KinKal and install it into a local UPS area; it will then build Offline using the local UPS area as the source for finding KinKal.

This writeup assumes that you have a basic knowledge of UPS and of Muse; in particular you should understand what a Muse envset is and how to use it. Normally you will choose the envset recommended by Offline and this example is written assuming that's what you want to do. It will note where you need to make different choices if you wish to use a different envset. If you are new to this work and you need to use a different envset, your mentor will tell you.

Initial build

To start development the first step is to decide which Muse envset you will start from. Normally you will choose the envset recommended by Offline; if you are new to this work and it is important to use a different envset, your mentor will tell you.

  1. In a clean shell, create a Muse workDir and cd there
      mkdir 'myworkdir'
      cd 'myworkdir'
      
  2. clone KinKal into the Muse workdir as your would normally. Add the Mu2e KinKal repo as a remote and checkout the main branch of the Mu2e KinKal remote.
    git clone git@github.com:<your GitHub username>/KinKal
    cd KinKal
    git remote add -f mu2e https://github.com/KFTrack/KinKal
    git checkout -b work_branch mu2e/main
    cd ..
    

    If you already have work in progress on work_branch, in your fork of KinKal, change the git checkout command to choose that branch.

  3. clone your fork of Offline into the muse workdir as you would normally. Add the Mu2e Offline repo as a remote and checkout the main branch of the Mu2e Offline remote. If you need other muse-aware repos (Production, TrkAna, ...) for your workflow, you can add them too
    git clone git@github.com:<your GitHub username>/Offline
    cd Offline
    git remote add -f mu2e https://github.com/Mu2e/Offline
    git checkout -b work_branch mu2e/master
    cd ..
    ( git clone git@github.com:<your GitHub username>/Production )
    ( git clone git@github.com:<your GitHub username>/TrkAna )
    
  4. Setup the development environment
    setup mu2e
    setup codetools
    
  5. Choose a UPS version number for your local build of KinKal; you can use any number thet is not already in use. Choosing version 9.9.9 is likely to be safe for a long time to come. The version must have 3 dot separated fields, following the idea of semantic versioning.
  6. Build KinKal; create a local ups directory and install the build of KinKal into that UPS area.
    kk2ups -v "9.9.9" -b -i -m "" -j 8
    
  7. If everything worked correctly, the output of this command will end with
    Begin install.
    Begin install of prof version.
    Begin install of debug version.
    KinKal_to_UPS/build completed with status 0
    
  8. The command kk2ups is short for "KinKal to UPS" and is found in codetools. This step will
    1. (-b) build the existing checkout in the local clone of KinKal
    2. (-i) if necessary, create a local directory named artexternals, configure it as a UPS repositor
    3. (-i) copy the build of KinKal in artexternals/KinKal/v09_09_09 and configure it as a UPS product
  9. Look at the files created by kk2ups:
    ls artexternals/KinKal/
    v09_09_09  v09_09_09.version
    
  10. The full syntax of the kk2ups option -m is: -m "value", where value is the name of an existing Muse envset. It says that, when building KinKal, use the version of root that will be found by the command "muse setup -q value". In this example value is an empty string which tells kk2ups to use the default envset set; because you have a clone of Offline in your Muse working area, it will use the version specified by Offline/.muse.
  11. To learn more about kk2ups you can read [1] or look at the output of
    kk2ups -?
    
  12. Make a copy of the envset used to build KinKal. If you used the default of -m "" in step 6, you can find the name of the envset in the file Offline/.muse .
    mkdir muse
    cd muse
    cp /cvmfs/mu2e.opensciencegrid.org/DataFiles/Muse/pxyz unnn
    

    where pxzy is the name of the envset used to build KinKal and where unnn is the name of your new envset.

  13. Edit the envset unnn to make two changes
    1. copy so that it references your local version of KinKal. I the following line IE replace the version number in the line 'setup -B KinKal v00_01_06 -q +${MUSE_BUILD}:+${MUSE_COMPILER_E}:+${MUSE_PYTHON}' with your tag (v09_09_09).
         setup -B KinKal  vxx_yy_zz  -q +${MUSE_BUILD}:+${MUSE_COMPILER_E}:+${MUSE_PYTHON}' with your tag (v09_09_09).
         
      change the version number to v09_09_09.
    2. Add the following line after the last setup command:
            export MUSE_PREBUILD="kk2ups -v \"999.0.0\" -b -i -j 24"
          
  14. cd back to the muse working directory and setup muse using the envset you just created
         cd ..
         muse setup -q unnn
      
  15. Build Offline and any other repos that you cloned in step ??
           muse build -j 8
       
      On mu2ebuild01 you can increase 8 to 24
    

Rebuilding KinKal

Once you have a stock build of Offline and KinKal, you can can develop both code sets coherently.

  • edit KinKal as needed
  • edit Offline as needed to exploit new KinKal features
  • rebuild KinKal and update the installation
  • rebuild Offline
(edit KinKal/*/*)
(edit Offline/*/*)
cd build_profile
make -j 20
make test
cd ..
KinKal_to_UPS/build -v v9.9.9 -i -d artexternals
muse build

Returning to the area

  • to return in a new shell and simply run the code you've already edited and built, you only need to repeat the setups:
cd 'workdir'
setup mu2e
export PRODUCTS=${PWD}/artexternals:${PRODUCTS}
muse setup -q u999

Adding debug build

An environment can only be setup once, so for an process, you must choose one or the other. The steps all follow form the prof build

  • setups. Setup muse in debug. Since you don't have the new KinKal in debug, you can setup root by setting up the published versions
setup mu2e
cd 'workdir'
muse setup -q debug
  • build debug KinKal using the same fake version as for prof
mkdir build_debug
cd build_debug
cmake ../KinKal  -DCMAKE_BUILD_TYPE=Debug
make -j 20
make test
cd ..
KinKal_to_UPS/build -v v9.9.9 -i -d artexternals
  • now that the debug version of the local KinKal product is available, you need to setup in a new shell to get the full environment
exit
ssh 'myuser@mu2egpvm04.fnal.gov'
cd 'workdir'
setup mu2e
export PRODUCTS=${PWD}/artexternals:${PRODUCTS}
muse setup -q u999:debug
muse build

What if you update Offline?

If you update the version of Offline in your working area:

  1. Compare the old and new versions of Offline to see if the version or qualifiers of root have changed.
  2. If they have not, you are done with this section. If they have, then you need to do the following:
  3. Make a new build of KinKal using the modified root and install it in your local artexternals directory.
    1. Hint: you may wish to investigate the -s versionSuffix option in KinKal_to_UPS.
    2. Hint: remember to start a new login session
  4. Follow the instructions in Muse#Maintaining_a_Customized_Setup to update your local muse/uNNN file to select your new build of KinKal.

Original Notes

To develop new code in KinKal and call it in Offline you will need to define your own version of KinKal and install it in your own private extension to UPS. You need to do some initial setup in a throwaway shell:

  • create a Muse workDir and cd there
  • checkout your fork of Offline in the muse workdir as you would normally
  • checkout your fork of KinKal in the muse workdir .The KinKal development model is the same as Offline: start with the head of main, create your own branch, develop and commit to that, and make a PR to KinKal when your development is ready.
  • checkout tag v0.1.4 of KinKal_to_UPS
  • build KinKal according to the instructions in README. make sure to run the test (make test)
  • create the directory 'artexternals' in the muse workdir
  • execute 'muse setup -q (prof, debug) depending on what you want. Note you can have both builds in the same workdir, but any given shell can be only one or the other.
  • invoke KinKal_to_UPS/build -v your_version -i -b -j10, where your_version is whatever version you want (it is temporary). I have this command saved in a script /mu2e/app/users/brownd/KFTrack/install_KinKal.sh
  • define a user envset in the ./muse directory. mine is /mu2e/app/users/brownd/KFTrack/muse/u002 The name is unimportant. Edit that so it refers to your_version of KinKal

Then, close that shell. From then on, you can work with KinKal and/or Offline in this muse workdir with the following commands:

  • create a new shell, and cd to your muse workdir
  • exectue 'export PRODUCTS=${PWD}/artexternals:${PRODUCTS}' This tells UPS to look for KinKal in your local install
  • execute 'muse setup -q (prof, debug) your_envset'

(I have these defined as /mu2e/app/users/brownd/KFTrack/setup_prof.sh and setup_debug.sh in my area)'

  • Any time you change KinKal rebuild and rerun the tests, and then rerun install_KinKal.sh
  • Any time you change Mu2eKinKal (or after changing and rebuilding KinKal as above) rebuild Offline using 'muse build'

Second version: Local KinKal development with Muse

Initial build

To develop new code in KinKal for new use cases in Offline you will need to checkout KinKal and install it in your own private extension to UPS. You need to do some initial setup in a throwaway shell:

  • create a Muse workDir and cd there
  • setup Muse. This puts a root and other products in the environment, which the KinKal build will use
mkdir 'myworkdir'
cd 'myworkdir'
  • checkout your fork of Offline in the muse workdir as you would normally. Add the main mu2e repo as a remote. If you need other muse-aware repos (Production, TrkAna, ...) for your workflow, you can add them too
git clone git@github.com:<your GitHub username>/Offline
cd Offline
git remote add -f mu2e https://github.com/Mu2e/Offline
git checkout -b work_branch mu2e/master
cd ..
(git clone git@github.com:<your GitHub username>/TrkAna.git)
  • create a fork of KinKal in GitHub (if you don't already have one). In a browser, go to the KinKal GitHub page, then under the 'fork' menu select 'Create a new fork'. You must be logged in to your GitHub account.
  • checkout your fork of KinKal in the muse workdir .The KinKal development model is the same as Offline: start with the head of main, create your own branch, develop and commit to that, and make a PR to KinKal when your development is ready. Start with the current version of KinKal
git clone git@github.com:<your GitHub username>/KinKal
cd KinKal
git remote add -f mu2e https://github.com/KFTrack/KinKal
git checkout -b work_branch mu2e/$KINKAL_VERSION
cd ..
  • build KinKal according to the instructions in README. You can build either a profile (optimized)

or debug. If you want both, just repeat this step. mkdir build_profile (or build_debug) cd build_profile (or build_debug) cmake ../KinKal -DCMAKE_BUILD_TYPE=Release (or Debug) make -j 20 make test cd ..

  • checkout KinKal_to_UPS, and use it to make your build of KinKal visible to Offline through UPS.
git clone https://github.com/Mu2e/KinKal_to_UPS
mkdir artexternals
rsync -aur /cvmfs/mu2e.opensciencegrid.org/artexternals/.upsfiles artexternals/
  • install your build of KinKal in artexternals. You must assign a tag to your build; the value is arbitrary, but it shouldn't correspond to an actual tag. Below a dummy is used.
KinKal_to_UPS/build -v v9.9.9 -i -d artexternals
  • create an envset that points to your local UPS version of KinKal. Start with a copy of the current Offline envset.
  • edit the copy so that it references your local version of KinKal. IE replace the tag in the line 'setup -B KinKal v00_01_06 -q +${MUSE_BUILD}:+${MUSE_COMPILER_E}:+${MUSE_PYTHON}' with your tag (v09_09_09)
mkdir muse
cp $MUSE_ENVSET_DIR/$MUSE_ENVSET muse/u999
vim muse/u999
...

At this point, KinKal is built and UPS-installed locally, but the current setup of Offline still points to the old version of KinKal. To get Offline to use your new version of KinKal you need a new shell. Close your existing shell, and start a new one, then cd back to your work directory. Note you only need to do this when setting up a new work directory; the following commands are needed for all subsequent use of this workdir

  • close your current shell
  • create a new shell, and cd to your muse workdir.
  • Tell UPS where to look find your local version of KinKal
  • setup muse, specifying the envset you created, which points to your local KinKal installation
exit (closes the current shell)
ssh 'myuser'@mu2egpvm04.fnal.gov
cd 'myworkdir'
setup mu2e
export PRODUCTS=${PWD}/artexternals:${PRODUCTS}
muse setup -q u999
  • Now build Offline (and any other muse-aware repos you've cloned)

muse build -j 20

Rebuilding KinKal

Once you have a stock build of Offline and KinKal, you can can develop both code sets coherently.

  • edit KinKal as needed
  • edit Offline as needed to exploit new KinKal features
  • rebuild KinKal and update the installation
  • rebuild Offline
(edit KinKal/*/*)
(edit Offline/*/*)
cd build_profile
make -j 20
make test
cd ..
KinKal_to_UPS/build -v v9.9.9 -i -d artexternals
muse build

Returning to the area

  • to return in a new shell and simply run the code you've already edited and built, you only need to repeat the setups:
cd 'workdir'
setup mu2e
export PRODUCTS=${PWD}/artexternals:${PRODUCTS}
muse setup -q u999

Adding debug build

An environment can only be setup once, so for an process, you must choose one or the other. The steps all follow form the prof build

  • setups. Setup muse in debug. Since you don't have the new KinKal in debug, you can setup root by setting up the published versions
setup mu2e
cd 'workdir'
muse setup -q debug
  • build debug KinKal using the same fake version as for prof
mkdir build_debug
cd build_debug
cmake ../KinKal  -DCMAKE_BUILD_TYPE=Debug
make -j 20
make test
cd ..
KinKal_to_UPS/build -v v9.9.9 -i -d artexternals
  • now that the debug version of the local KinKal product is available, you need to setup in a new shell to get the full environment
exit
ssh 'myuser@mu2egpvm04.fnal.gov'
cd 'workdir'
setup mu2e
export PRODUCTS=${PWD}/artexternals:${PRODUCTS}
muse setup -q u999:debug
muse build

What if you update Offline?

If you update the version of Offline in your working area:

  1. Compare the old and new versions of Offline to see if the version or qualifiers of root have changed.
  2. If they have not, you are done with this section. If they have, then you need to do the following:
  3. Make a new build of KinKal using the modified root and install it in your local artexternals directory.
    1. Hint: you may wish to investigate the -s versionSuffix option in KinKal_to_UPS.
    2. Hint: remember to start a new login session
  4. Follow the instructions in Muse#Maintaining_a_Customized_Setup to update your local muse/uNNN file to select your new build of KinKal.

Original Notes