Skip to content
Snippets Groups Projects
ActionTransferSystematics.cxx 5.13 KiB
Newer Older
#include "QFramework/TQFolder.h"
#include "QFramework/TQIterator.h"
#include "QFramework/TQUtils.h"
#include "QFramework/TQStringUtils.h"

#include "SFramework/TSStatisticsManager.h"

namespace TSBaseActions {

  class TransferSystematics : public TSStatisticsManager::Action {

    bool isExcepted(TQFolder* f,const std::vector<TString>& exceptions, const TString&prefix = "") const {
      bool except = false;
      for(const auto& x:exceptions){
        if(TQStringUtils::matches(f->GetName(),prefix+x)){
          except = true;
          break;
        }
      }
      return except;
    }

    bool execute(TQFolder * config) const override {

      TQFolder* model = models()->getFolder(config->GetName());
      if(!model){
        manager->error(TString::Format("no such model available: '%s'",config->GetName()));
      }

      TQFolderIterator transfers = config->getListOfFolders("?");
      int nOK = 0;
      while(transfers.hasNext()){
        TQFolder* transfer = transfers.readNext();
        if(!transfer) continue;
        nOK += performTransfer(transfer,model);
      }

      return nOK;
    }
      
    bool performTransfer(TQFolder * config,TQFolder* model) const {
      
      std::vector<TString> exceptRegions = config->getTagVString("except.Channels");
      std::vector<TString> exceptSamples = config->getTagVString("except.Samples");
      std::vector<TString> exceptSystematics = config->getTagVString("except.OverallSys");

      manager->info(TString::Format("performing transfer '%s'",config->GetName()));
      
      std::vector<TString> targetSamples = config->getTagVString("select.Samples");
      if(targetSamples.empty()){
        targetSamples.push_back("*");
      }
      std::vector<TString> targetChannels = config->getTagVString("select.Channels");
      if(targetChannels.empty()){
        targetChannels.push_back("*");
      }

      TString sourceSample;
      if(!config->getTagString("source",sourceSample)){
        manager->error(TString::Format("missing required 'source' information on transfer '%s'",config->GetName()));
        return false;
      }

      TString mark;
      bool marked = config->getTagString("selectTag.OverallSys",mark);

      int i=0;

      bool verbose = config->getTagBoolDefault("verbose",false);

      for(const auto& channelExp:targetChannels){
        TQFolderIterator regions(model->getListOfFolders("Channel."+channelExp),true);
        while(regions.hasNext()){
          TQFolder* region = regions.readNext();
          if(!region) continue;
          if(isExcepted(region,exceptRegions,"Channel.")) continue;
          if(verbose) manager->info(TString::Format("transferring in region '%s'",region->GetName()));
          TQFolder* source = region->getFolder("Sample."+sourceSample);
          if(!source){
            manager->warn(TString::Format("unable to find source '%s' in channel '%s', skipping!",sourceSample.Data(),region->GetName()));
            continue;
          }
          for(const auto& sampleExp:targetSamples){
            TQFolderIterator samples(region->getListOfFolders("Sample."+sampleExp),true);
            while(samples.hasNext()){
              TQFolder* sample = samples.readNext();
              if(!sample) continue;
              if(isExcepted(sample,exceptSamples,"Sample.")) continue;
              if(verbose) manager->info(TString::Format("\tfor sample '%s'",sample->GetName()));
              sample->deleteObject(".Dropped!");
              std::vector<TQFolder*> remove;
              {
                TQFolderIterator oldsystematics(sample->getListOfFolders("OverallSys.*"),true);
                while(oldsystematics.hasNext()){
                  TQFolder* systematic = oldsystematics.readNext();
                  if(!systematic) continue;
                  if(isExcepted(region,exceptSystematics,"OverallSys.")) continue;
                  if(marked && !systematic->getTagBoolDefault(mark,false)) continue;
                  if(verbose) manager->info(TString::Format("\t\tremoving '%s'",systematic->GetName()));
                  remove.push_back(systematic);
                }
              }
              for(auto systematic:remove){
                systematic->detachFromBase();
                delete systematic;
              }
              {
                TQFolderIterator newsystematics(source->getListOfFolders("OverallSys.*"),true);
                while(newsystematics.hasNext()){
                  TQFolder* systematic = newsystematics.readNext();
                  if(!systematic) continue;
                  if(isExcepted(region,exceptSystematics,"OverallSys.")) continue;
                  if(marked && !systematic->getTagBoolDefault(mark,false)) continue;
                  if(verbose) manager->info(TString::Format("\t\tcopying '%s'",systematic->GetName()));
                  TQFolder* copy = systematic->copy();
                  i++;
                  sample->addFolder(copy);
                  copy->setTagString("transferred",source->GetName());
                }
              }
            }
          }
        }
      }
      return (i>0);
    }
  };
  namespace {
    bool available = TSStatisticsManager::registerAction(new TransferSystematics(),"TransferSystematics");
  }
}