KVDataPatchList.cpp

//Created by KVClassFactory on Thu Jan 30 11:06:10 2014
//Author: John Frankland,,,
 
#include "KVDataPatchList.h"
#include "KVDataPatch.h"
#include <TPluginManager.h>
 
ClassImp(KVDataPatchList)
 
KVUniqueNameList* KVDataPatchList::fPatchList = nullptr;
 
 
 
void KVDataPatchList::FillPatchList()
{
   // Fill static list of patches from KVDataPatch plugin list
 
   KVString plugins = GetListOfPlugins("KVDataPatch");
   if (plugins == "") {
      Info("FillPatchList", "No data patch plugins defined");
      return;
   }
   plugins.Begin(" ");
   while (!plugins.End()) {
      KVString plug = plugins.Next(kTRUE);
      TPluginHandler* h = LoadPlugin("KVDataPatch", GetPluginURI("KVDataPatch", plug));
      if (h) {
         KVDataPatch* p = (KVDataPatch*)h->ExecPlugin(0);
         fPatchList->Add(p);
      }
      else
         KVError::Warning(this, "FillPatchList", "Cannot load plugin data patch %s", plug.Data());
   }
}
 
 
 
 
void KVDataPatchList::init()
{
   fEventPatches = kFALSE;
   fParticlePatches = kFALSE;
   if (!fPatchList) {
      fPatchList = new KVUniqueNameList;
      FillPatchList();
   }
}
 
 
 
 
void KVDataPatchList::InitializePatchList(TString dataset, TString datatype, Int_t runnumber,
      TString dataseries, Int_t datareleasenumber, const TList* streamerinfolist)
{
   // Fill lists of active patches for given data
   //
   // If the configuration variable
   //
   //~~~
   // [dataset].DataAnalysis.ApplyDataPatches
   //~~~
   //
   // is set to a value equivalent to (bool)false (i.e. one of 'no', 'off', 'false'),
   // no patches will be initialised
 
   if(!GetDataSetEnv<bool>(dataset, "DataAnalysis.ApplyDataPatches"))
      return;
 
   KVError::Info(this, "InitializePatchList()",
        "Initializing patches for |%s|%s|%04d|%s|%02d|",
        dataset.Data(), datatype.Data(), runnumber, dataseries.Data(), datareleasenumber);
   fActiveEventPatches.Clear();
   fActiveParticlePatches.Clear();
   fEventPatches = kFALSE;
   fParticlePatches = kFALSE;
   TIter nxtP(fPatchList);
   KVDataPatch* patch;
   while ((patch = (KVDataPatch*)nxtP())) {
      if (patch->IsRequired(dataset, datatype, runnumber, dataseries, datareleasenumber, streamerinfolist)) {
         if (patch->IsEventPatch()) {
            fActiveEventPatches.Add(patch);
            fEventPatches = kTRUE;
         }
         if (patch->IsParticlePatch()) {
            fActiveParticlePatches.Add(patch);
            fParticlePatches = kTRUE;
         }
      }
   }
}
 
 
 
 
void KVDataPatchList::Apply(KVReconstructedEvent* event)
{
   // Apply all currently active patches to event
 
   if (fEventPatches) {
      // Apply event-level patches
      TIter nxt(&fActiveEventPatches);
      KVDataPatch* patch;
      while ((patch = (KVDataPatch*)nxt())) patch->ApplyToEvent(event);
   }
   if (fParticlePatches) {
      // Apply particle-level patches
      TIter nxt(&fActiveParticlePatches);
      KVDataPatch* patch;
      for(auto & rnuc : *event)
      {
         while ((patch = (KVDataPatch*)nxt())) patch->ApplyToParticle(&rnuc);
         nxt.Reset();
      }
   }
}
 
 
 
 
void KVDataPatchList::Print(Option_t*) const
{
   // Print list of currently active patches
   if (!fEventPatches && !fParticlePatches) {
      Info("Print", "No currently active data patches");
      return;
   }
   if (fEventPatches) {
      Info("Print", "Currently active event-level patches:");
      fActiveEventPatches.Print();
   }
   if (fParticlePatches) {
      Info("Print", "Currently active particle-level patches:");
      fActiveParticlePatches.Print();
   }
}