KVSimDirFilterAnalyser.cpp

//Created by KVClassFactory on Thu Mar 23 14:02:40 2017
//Author: John Frankland,,,
 
#include "KVSimDirFilterAnalyser.h"
#include <KVClassFactory.h>
#include <KVDataSetManager.h>
#include <KVExpDB.h>
#include <KVTriggerConditions.h>
#include "KVMultiDetArray.h"
#include "KVNucleusEvent.h"
 
ClassImp(KVSimDirFilterAnalyser)
 
 
 
KVSimDirFilterAnalyser::KVSimDirFilterAnalyser()
   : KVSimDirAnalyser()
{
   // Default constructor
}
 
 
 
 
 
KVSimDirFilterAnalyser::~KVSimDirFilterAnalyser()
{
   // Destructor
 
   if (fKinematics->TestBit(kCanDelete)) delete fKinematics;
}
 
 
 
 
void KVSimDirFilterAnalyser::preInitAnalysis()
{
   // Use options passed to KVEventSelector to initialise dataset used for filter
 
   if (!gDataSetManager) {
      gDataSetManager = new KVDataSetManager;
      gDataSetManager->Init();
   }
   if (!gDataSet) gDataSetManager->GetDataSet(fAnalysisClass->GetOpt("DataSet"))->cd();
}
 
 
 
 
void KVSimDirFilterAnalyser::preInitRun()
{
   // Use options passed to KVEventSelector to initialise kinematics for reaction
   // and build experimental set-up
 
   KVString system = fAnalysisClass->GetOpt("System");
   fSystem = gExpDB->GetSystem(system);
   bool adhoc_system=false;
   if (fSystem) {
      fKinematics = fSystem->GetKinematics();
   }
   else {
      adhoc_system=true;
      fKinematics = new KV2Body(system);
      fKinematics->SetBit(kCanDelete); // clean up in destructor
      fKinematics->CalculateKinematics();
   }
   fRun = nullptr;
   if(fAnalysisClass->IsOptGiven("Run"))
   {
      KVString run = fAnalysisClass->GetOpt("Run");
      fRun = gExpDB->GetDBRun(run.Atoi());
   }
   else if(adhoc_system)
   {
      // ad hoc systems are not in the database and not associated to any run
      // we take first run of first physical (reaction) system (?)
      KVDBSystem* sys;
      TIter nxt_sys(gExpDB->GetSystems());
      while((sys = (KVDBSystem*)nxt_sys()))
      {
         if(sys->IsCollision())
         {
            fRun = (KVDBRun*)sys->GetRuns().First();
            break;
         }
      }
   }
   if(fRun)
      fAnalysisClass->SetCurrentRun(fRun);
 
   KVMultiDetArray::MakeMultiDetector(gDataSet->GetName(), fRun ? fRun->GetNumber() : -1);
   // put detector array in simulation mode
   gMultiDetArray->SetSimMode();
}
 
 
 
 
void KVSimDirFilterAnalyser::preAnalysis()
{
   // Called by KVEventSelector just after reading new event and just before calling user analysis
   //
   // Copy calculated energy losses of all particles into the detectors
 
   for (auto& n : EventIterator(fAnalysisClass->GetEvent())) {
      for (auto& p : *n.GetParameters()) {
         auto d = gMultiDetArray->GetDetector(p.GetName());
         if (d) {
            // sum up energy losses in each detector
            d->SetEnergyLoss(p.GetDouble() + d->GetEnergyLoss());
         }
      }
   }
}
 
 
 
 
void KVSimDirFilterAnalyser::Make(const Char_t* kvsname)
{
   // Generate a new filtered analysis selector class
 
   KVClassFactory cf(kvsname, "Analysis of filtered simulated events", "",
                     kTRUE, "ROOT6FilteredEventAnalysisTemplate");
   cf.AddImplIncludeFile("KVReconstructedNucleus.h");
   cf.AddImplIncludeFile("KVBatchSystem.h");
 
   cf.GenerateCode();
}
 
 
 
 
void KVSimDirFilterAnalyser::SetTriggerConditionsForRun(int run)
{
   // When called from the InitRun() method of a user's analysis class, this method will ensure that only data
   // compatible with the experimental trigger will be provided for analysis in the user's Analysis() method.
   //
   // This will be done by searching for a KVTriggerConditions plugin class defined for the currently-analysed
   // dataset, defined like so:
   //
   //~~~~
   //+Plugin.KVTriggerConditions:   [dataset]   [classname]  [libname]   "[default constructor]()"
   //~~~~
   //
   // An object of the plugin class will be instantiated, and then its overridden
   // KVTriggerConditions::SetTriggerConditionsForRun() method will be called with 3 arguments:
   //   - a pointer to the user's analysis class derived from KVEventSelector;
   //   - the number of the run currently being analysed
   //   - the 3rd optional argument will be set to kTRUE to indicate that we are analysing filtered simulated data
 
   TPluginHandler* ph = KVBase::LoadPlugin("KVTriggerConditions", gDataSet->GetName());
   if (!ph) {
      Info("SetTriggerConditionsForRun",
           "No definition of trigger conditions available for dataset %s",
           gDataSet->GetName());
      return;
   }
   std::unique_ptr<KVTriggerConditions> trig((KVTriggerConditions*) ph->ExecPlugin(0));
   trig->SetTriggerConditionsForRun(fAnalysisClass, run, kTRUE);
}
 
//____________________________________________________________________________//