CompleteEvents.cpp

Selecting 'complete' events in analysis

This class demonstrates the use of the global variables KVZtot and KVZVtot in a KVReconEventSelector analysis class to calculate total measured charge and momentum, normalize to the total charge and momentum of the analysed system, and reject events which do not fulfill required constraints on these global variables.

#pragma once
 
#include "KVReconEventSelector.h"
 
class CompleteEvents : public KVReconEventSelector
{
 
   double ztot_sys, ztot_min, ztot_max;
   double zvtot_sys, zvtot_min, zvtot_max;
 
public:
   CompleteEvents() = default;
 
   virtual void InitRun() override;
   virtual void EndRun() override {}
   virtual void InitAnalysis() override;
   virtual Bool_t Analysis() override;
   virtual void EndAnalysis() override {}
 
   ClassDefOverride(CompleteEvents,1)
};
 

#include "CompleteEvents.h"
#include "KVReconstructedNucleus.h"
#include "KVBatchSystem.h"
#include "KVDataAnalyser.h"
#include "KVMultiDetArray.h"
#include "TRandom.h"
 
void CompleteEvents::InitAnalysis(void)
{
   // DEFINITION OF GLOBAL VARIABLES USED IN ANALYSIS
 
   // KVZtot to calculate total charge
   auto ztot = AddGV("KVZtot", "ztot");
   // Define our event selection based on the ztot variable (see KVVarGlob::SetEventSelection()).
   // 'val' will be the value of ztot for a given event
   // Note that the limits ztot_min and ztot_max will be defined in InitRun()
   ztot->SetEventSelection([&](const KVVarGlob* vg)
                            {
                               auto val = vg->GetValue();
                               return val>=ztot_min && val<=ztot_max;
                            }
                           );
 
   // KVZVtot to calculate total pseudo-momentum (Z*V)
   auto zvtot = AddGV("KVZVtot", "zvtot");
   // limit the number of TTree branches created for this variable to just 1 (see below)
   zvtot->SetMaxNumBranches(1);
   // Define our event selection based on the zvtot variable.
   // 'val' will be the value of the z-component of zvtot for a given event
   // Note that the limits zvtot_min and zvtot_max will be defined in InitRun()
   zvtot->SetEventSelection([&](const KVVarGlob* vg)
                            {
                               auto val = vg->GetValue("Z");
                               return val>=zvtot_min && val<=zvtot_max;
                            }
                           );
 
   // Note: The global variables added with AddGV() are in the default list (KVGVList)
   // for which only particles which are 'OK' are taken into account: this means those
   // for which the default identification & calibration quality code selections are
   // applied, unless this choice is modified in InitRun() (see below).
   //
   // If you want, you can define and use a different list of global variables (in fact,
   // you can define as many as you want), and define the selection of particles it uses
   // (or none at all if you wish): see KVEventSelector::AddGVList()
 
   // 2D histo
   AddHisto<TH2F>("ztot_zvtot", "Z_{tot}/Z_{sys} vs ZV_{tot}/ZV_{sys}", 200, 0, 1.5, 200, 0, 1.5);
 
   // create TTree with branches for our global variables
   auto t = AddTree("myTree");
   // this will create a branch "ztot" for the KVZtot variable, and a branch "zvtot.Z" with
   // the z-component (beam direction) of the total pseudo-momentum vector calculated by
   // KVZVtot. if we had not limited the number of branches for this variable (see above)
   // there would also be a "zvtot.X" and "zvtot.Y" branch.
   GetGVList()->MakeBranches(t);
 
   /*** DEFINE WHERE TO SAVE THE RESULTS ***/
   // This filename will be used for interactive and PROOFlite jobs.
   // When running in batch mode, this will automatically use the job name.
   SetJobOutputFileName("CompleteEvents_results.root");
}
 
//_____________________________________
void CompleteEvents::InitRun(void)
{
   // Initialisations for each run
   // Called at the beginning of each run
 
   // This is the place to define the correct identification/calibration codes for particles
   // which will be used in your analysis. These particles will be labelled 'OK'
   // (i.e. the method IsOK() for these particles returns kTRUE).
   //
   // If no explicit selection is indicated here, an automatic selection for each multidetector
   // array will be made using the default accepted values which are defined in variables
   // [array].ReconstructedNuclei.AcceptID/ECodes.
   //
   // You can change the selection (or deactivate it) here by doing any of the following:
   //
   // gMultiDetArray->AcceptIDCodes("12,33"); => accept only ID codes in list
   // gMultiDetArray->AcceptAllIDCodes();     => accept particles with any ID code
   //
   // If the experiment used a combination of arrays, codes have to be set for
   // each array individually:
   // gMultiDetArray->GetArray("[name]")->Accept.. => setting for array [name]
 
   // set title of TTree with name of analysed system
   GetTree("myTree")->SetTitle(GetCurrentRun()->GetSystemName());
 
   // retrieve the total charge and total pseudo-momentum of the system being analysed
   ztot_sys = GetCurrentRun()->GetSystem()->GetZtot();
   zvtot_sys = GetCurrentRun()->GetSystem()->GetZVtot();
   // define the limits for our selections (see InitAnalysis()) based on analysed system characteristics
   ztot_min = 0.5*ztot_sys;
   ztot_max = 1.05*ztot_sys;
   zvtot_min = 0.5*zvtot_sys;
   zvtot_max = 1.1*zvtot_sys;
}
 
//_____________________________________
Bool_t CompleteEvents::Analysis(void)
{
   // update values of all global variable branches
   GetGVList()->FillBranches();
   // save values in TTree
   FillTree();
   // fill our histogram ztot vs. zvtot (normalised to system values)
   auto ztot = GetGV("ztot")->GetValue();
   ztot += gRandom->Uniform(-.5,.5); // this is just to make it look nicer!
   FillHisto("ztot_zvtot", GetGV("zvtot")->GetValue("Z")/zvtot_sys, ztot/ztot_sys);
 
   return kTRUE;
}