JSeparateCuts.cc File Reference

Program for extracting disjoint output files without overlapping cuts
from a list of Monte-Carlo files with overlapping cuts. More...

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <stdio.h>
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"
#include "km3net-dataformat/definitions/trkmembers.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "Jeep/JeepToolkit.hh"
#include "JLang/JException.hh"
#include "JTools/JRange.hh"
#include "JSupport/JMeta.hh"
#include "JSupport/JSupport.hh"
#include "JSupport/JFileRecorder.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JEvtWeightFileScanner.hh"
#include "JSupport/JEvtWeightFileScannerSet.hh"
#include "JAAnet/JHead.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Program for extracting disjoint output files without overlapping cuts
from a list of Monte-Carlo files with overlapping cuts.

Note: Already existing disjoint output files which have been extracted previously will be overwritten.

Author

bjung

Definition in file JSeparateCuts.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 360 of file JSeparateCuts.cc.

{
  using namespace std;
  using namespace JPP;
  
  JMultipleFileScanner_t  inputFiles;
  string                  outputFile;
  char                    wildcard;
  bool                    replace;
 
  int                     debug;
 
  try {
    
    JParser<> zap;
    
    zap['f'] = make_field(inputFiles);
    zap['o'] = make_field(outputFile)         = "%.root";
    zap['w'] = make_field(wildcard)           = '%';
    zap['r'] = make_field(replace);
    zap['d'] = make_field(debug)              = 1;
 
    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }
 
  const size_t pos = outputFile.find(wildcard);
 
  if (pos == string::npos) {
    FATAL("Valid wildcard must be specified (<" << outputFile << "> does not contain \'" << wildcard << "\').");
  }
 
  
  // Create set of files ordered based on header-info
  
  JEvtWeightFileScannerSet<> scanners(inputFiles);
 
  // Split files with overlapping cuts into separate files with disjoint cuts.
 
  set<string>   buffer;
  JSeparateCuts separator(outputFile, wildcard, JMeta(argc, argv));
 
  for (JEvtWeightFileScannerSet<>::iterator scanner1 = next(scanners.begin()); scanner1 != scanners.end(); ++scanner1) {
 
    JEvtWeightFileScannerSet<>::iterator scanner0 = prev(scanner1);
    
    if (scanner0->hasNext() && scanner1->hasNext()) {      
      
      const string identifier = scanners.getUniqueIdentifier(scanner0) + MAKE_STRING(".cut" << wildcard);
      const string name       = string(outputFile).replace(pos, 1, identifier.c_str());
      
      separator.setFilenameTemplate(name);
 
      const size_t N = (separator.separate(*scanner0, *scanner1, &JHead::cut_primary) +
                        separator.separate(*scanner0, *scanner1, &JHead::cut_seamuon) +
                        separator.separate(*scanner0, *scanner1, &JHead::cut_in)      +
                        separator.separate(*scanner0, *scanner1, &JHead::cut_nu));
 
      STATUS("\rExtracted "        << N << " output files with"            <<
             " disjoint cuts for " << getFilename(scanner0->getFilename()) <<
             " and "               << getFilename(scanner1->getFilename())); DEBUG(endl);
 
      if (N > 0) {
        
        buffer.insert(scanner0->getFilename());
        buffer.insert(scanner1->getFilename());
      }
    }
  }
  
  for (set<string>::const_iterator i = buffer.begin(); replace && i != buffer.end(); ++i) {
      
    if (remove(i->c_str()) != 0) {
      FATAL(endl << "Error removing file " << *i);
    } else {
      NOTICE(endl << "Removing file " << *i);
    }
  }
 
  return 0;
}