TreeFiller/src/FillMitTree.cc

// $Id: FillMitTree.cc,v 1.61 2011/05/05 12:43:25 rwolf Exp $

#include "MitProd/TreeFiller/interface/FillMitTree.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "MitProd/ObjectService/interface/ObjectService.h"
#include "MitProd/TreeFiller/interface/AssociationMaps.h"
#include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
#include "MitProd/TreeFiller/interface/FillerBeamSpot.h"
#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
#include "MitProd/TreeFiller/interface/FillerCaloTaus.h"
#include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
#include "MitProd/TreeFiller/interface/FillerConversions.h"
#include "MitProd/TreeFiller/interface/FillerConversionsDecay.h"
#include "MitProd/TreeFiller/interface/FillerDecayParts.h"
#include "MitProd/TreeFiller/interface/FillerElectrons.h"
#include "MitProd/TreeFiller/interface/FillerEvtSelData.h"
#include "MitProd/TreeFiller/interface/FillerGenJets.h"
#include "MitProd/TreeFiller/interface/FillerGenMet.h"
#include "MitProd/TreeFiller/interface/FillerJPTJets.h"
#include "MitProd/TreeFiller/interface/FillerMCEventInfo.h"
#include "MitProd/TreeFiller/interface/FillerMCParticles.h"
#include "MitProd/TreeFiller/interface/FillerMCVertexes.h"
#include "MitProd/TreeFiller/interface/FillerMet.h"
#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
#include "MitProd/TreeFiller/interface/FillerMuons.h"
#include "MitProd/TreeFiller/interface/FillerPFCandidates.h"
#include "MitProd/TreeFiller/interface/FillerPFJets.h"
#include "MitProd/TreeFiller/interface/FillerPFMet.h"
#include "MitProd/TreeFiller/interface/FillerPFTaus.h"
#include "MitProd/TreeFiller/interface/FillerNSVFit.h"
#include "MitProd/TreeFiller/interface/FillerPhotons.h"
#include "MitProd/TreeFiller/interface/FillerPileupInfo.h"
#include "MitProd/TreeFiller/interface/FillerPileupEnergyDensity.h"
#include "MitProd/TreeFiller/interface/FillerPixelHits.h"
#include "MitProd/TreeFiller/interface/FillerStableParts.h"
#include "MitProd/TreeFiller/interface/FillerStripHits.h"
#include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
#include "MitProd/TreeFiller/interface/FillerTracks.h"
#include "MitProd/TreeFiller/interface/FillerTrackJets.h"
#include "MitProd/TreeFiller/interface/FillerVertexes.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitAna/DataTree/interface/BranchTable.h"
#include "MitCommon/OptIO/interface/OptInt.h"

using namespace std;
using namespace edm;
using namespace mithep;

mithep::ObjectService *mithep::FillMitTree::os_ = 0;

//--------------------------------------------------------------------------------------------------
FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
  defactive_(cfg.getUntrackedParameter<bool>("defactive",1)),
  brtable_(0),
  acfnumber_(-1),
  tws_(new TreeWriter(Names::gkEvtTreeName,0))
{
  // Constructor.

  if (!configure(cfg)) {
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
      << "Could not configure fillers." << "\n";
  }
}

//--------------------------------------------------------------------------------------------------
FillMitTree::~FillMitTree()
{
  // Destructor.

  delete brtable_;
  delete tws_;
}

//--------------------------------------------------------------------------------------------------
bool FillMitTree::addActiveFiller(BaseFiller *bf)
{
  // Check if filler is active and add it to list of fillers. Otherwise delete it.

  if (!bf)
    return 0;

  if (bf->Active()) {
    fillers_.push_back(bf);
    return 1;
  }

  delete bf;
  bf = 0;
  return 0;
}

//--------------------------------------------------------------------------------------------------
void FillMitTree::beginRun(edm::Run const &run, edm::EventSetup const &setup)
{
  // Access and copy event content.

  // first step: Loop over the data fillers of the various components
  for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    (*iF)->FillRunBlock(run,setup);
  }
  
}

//--------------------------------------------------------------------------------------------------
void FillMitTree::analyze(const edm::Event      &event, 
                          const edm::EventSetup &setup)
{
  // Access and copy event content.
  
  //tree writer begin event actions
  tws_->BeginEvent(kTRUE);

  // first step: Loop over the data fillers of the various components
  for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    //printf("%s FillDataBlock\n",(*iF)->Name().c_str());
    (*iF)->FillDataBlock(event,setup);
  }

  // second step: Loop over the link resolution of the various components
  for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    //printf("%s ResolveLinks\n",(*iF)->Name().c_str());
    (*iF)->ResolveLinks(event,setup);
  }

  if (brtable_) { // only the first FillMitTree object has to deal with the branch table
    if (acfnumber_==-1) {
      brtable_->Rehash(brtable_->GetSize());
      if (0)
        brtable_->Print();
    }
    if (acfnumber_ != tws_->GetFileNumber()) {
      tws_->StoreObject(brtable_);
      acfnumber_ = tws_->GetFileNumber();
    }
  }

  //tree writer end of event actions
  tws_->EndEvent(kTRUE);
}

//--------------------------------------------------------------------------------------------------
void FillMitTree::beginJob()
{
  // Access the tree and book branches.

  if (os_==0) { // only the first FillMitTree object has to deal with this
    Service<ObjectService> os;
    if (!os.isAvailable()) {
      throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
        << "Could not get object service. " 
        << "Do you have the ObjectService defined in your config?" << "\n";
      return;
    }
    os_ = &(*os);
    brtable_ = new BranchTable;
    brtable_->SetName(Names::gkBranchTable);
    brtable_->SetOwner();
    os->add(brtable_, brtable_->GetName());
  }

  // loop over the various components and book the branches
  for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    edm::LogInfo("FillMitTree::beginJob") << "Booking for " << (*iF)->Name() << endl;
    (*iF)->BookDataBlock(*tws_);
  }

  // call branch ref for the event tree
  if (brtable_ && tws_->GetTree())
    tws_->GetTree()->BranchRef();
  
}

//--------------------------------------------------------------------------------------------------
bool FillMitTree::configure(const edm::ParameterSet &cfg)
{

  // Configure TreeWriter
  const std::string twsConfigName("TreeWriter");
  ParameterSet twsConfig;
  if (cfg.existsAs<ParameterSet>(twsConfigName,0))
    twsConfig = cfg.getUntrackedParameter<ParameterSet>(twsConfigName);
  
  configureTreeWriter(twsConfig);
  
  // Configure our fillers according to given parameter ("fillers").

  std::vector<std::string> pars;
  if (cfg.exists("fillers"))
    pars=cfg.getUntrackedParameter<vector<string> >("fillers");
  else
    cfg.getParameterSetNames(pars, false);

  // loop over psets
  for (unsigned int i = 0; i<pars.size(); ++i) {

    const string name(pars.at(i));

    string ftype("Filler" + name);
    if (cfg.existsAs<ParameterSet>(name,0)) {
      ParameterSet next(cfg.getUntrackedParameter<ParameterSet>(name));
      if (!next.exists("fillerType")) {
        edm::LogError("FillMitTree") << "Cannot determine fillerType for pset named "
                                     << name << std::endl;
        throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
          << "Cannot determine fillerType for pset named "
          << name << std::endl;
      }
      ftype = next.getUntrackedParameter<string>("fillerType");
    }

    edm::LogInfo("FillMitTree") << "Attempting to configure '" << ftype 
                                << "' for '" << name << "'" << std::endl;

    if (ftype.compare("FillerMetaInfos")==0) {
      FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMetaInfos);
      continue;
    }

    if (ftype.compare("FillerMCParticles")==0) {
      FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMCParticles);
      continue;
    }

    if (ftype.compare("FillerMCEventInfo")==0) {
      FillerMCEventInfo *fillerMCEventInfo = new FillerMCEventInfo(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMCEventInfo);
      continue;
    }

    if (ftype.compare("FillerMCVertexes")==0) {
      FillerMCVertexes *fillerMCVertexes = new FillerMCVertexes(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMCVertexes);
      continue;
    }  

    if (ftype.compare("FillerEvtSelData")==0) {
      FillerEvtSelData *fillerEvtSelData = new FillerEvtSelData(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerEvtSelData);
      continue;
    }

    if (ftype.compare("FillerBeamSpot")==0) {
      FillerBeamSpot *fillerBeamSpot = new FillerBeamSpot(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerBeamSpot);
      continue;
    }

    if (ftype.compare("FillerVertexes")==0) {
      FillerVertexes *fillerVertexes = new FillerVertexes(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerVertexes);
      continue;
    }  

    if (ftype.compare("FillerCaloTowers")==0) {
      FillerCaloTowers *fillerCaloTowers = new FillerCaloTowers(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloTowers);
      continue;
    }  

    if (ftype.compare("FillerGenJets")==0) {
      FillerGenJets *fillerGenJets = new FillerGenJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerGenJets);
      continue;
    }  

    if (ftype.compare("FillerCaloJets")==0) {
      FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloJets);
      continue;
    }  
    
    if (ftype.compare("FillerMet")==0) {
      FillerMet *fillerMet = new FillerMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMet);
      continue;
    }  
    
    if (ftype.compare("FillerGenMet")==0) {
      FillerGenMet *fillerGenMet = new FillerGenMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerGenMet);
      continue;
    }  

    if (ftype.compare("FillerCaloMet")==0) {
      FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloMet);
      continue;
    }
    
    if (ftype.compare("FillerPFMet")==0) {
      FillerPFMet *fillerPFMet = new FillerPFMet(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFMet);
      continue;
    }  

    if (ftype.compare("FillerBasicClusters")==0) {
      FillerBasicClusters *fillerBasicClusters = 
        new FillerBasicClusters(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerBasicClusters);
      continue;
    }  

    if (ftype.compare("FillerSuperClusters")==0) {
      FillerSuperClusters *fillerSuperClusters =  
        new FillerSuperClusters(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerSuperClusters);
      continue;
    }  

    if (ftype.compare("FillerPixelHits")==0) {
      FillerPixelHits *fillerPixelHits =  
        new FillerPixelHits(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPixelHits);
      continue;
    }  

    if (ftype.compare("FillerPileupInfo")==0) {
      FillerPileupInfo *fillerPileupInfo =  
        new FillerPileupInfo(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPileupInfo);
      continue;
    }  

    if (ftype.compare("FillerPileupEnergyDensity")==0) {
      FillerPileupEnergyDensity *fillerPileupEnergyDensity =  
        new FillerPileupEnergyDensity(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPileupEnergyDensity);
      continue;
    }  

    if (ftype.compare("FillerStripHits")==0) {
      FillerStripHits *fillerStripHits =  
        new FillerStripHits(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerStripHits);
      continue;
    }  

    if (ftype.compare("FillerTracks")==0) {
      FillerTracks *fillerTracks = new FillerTracks(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerTracks);
      continue;
    }  

    if (ftype.compare("FillerMuons")==0) {
      FillerMuons *fillerMuons = new FillerMuons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerMuons);
      continue;
    }  

    if (ftype.compare("FillerElectrons")==0) {
      FillerElectrons *fillerElectrons = new FillerElectrons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerElectrons);
      continue;
    }  

    if (ftype.compare("FillerConversions")==0) {
      FillerConversions *fillerConversions = new FillerConversions(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerConversions);
      continue;
    } 
    
    if (ftype.compare("FillerConversionsDecay")==0) {
      FillerConversionsDecay *fillerConversionsDecay = new FillerConversionsDecay(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerConversionsDecay);
      continue;
    }    

    if (ftype.compare("FillerPhotons")==0) { 
      FillerPhotons *fillerPhotons = new FillerPhotons(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPhotons);
      continue;
    }  

    if (ftype.compare("FillerStableParts")==0) {
      FillerStableParts *fillerStableParts = new FillerStableParts(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerStableParts);
      continue;
    }  

    if (ftype.compare("FillerDecayParts")==0) {
      FillerDecayParts *fillerDecayParts = new FillerDecayParts(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerDecayParts);
      continue;
    }  
    
    if (ftype.compare("FillerPFCandidates")==0) {
      FillerPFCandidates *fillerPFCands = new FillerPFCandidates(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFCands);
      continue;
    }  

    if (ftype.compare("FillerPFJets")==0) {
      FillerPFJets *fillerPFJets = new FillerPFJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFJets);
      continue;
    }  

    if (ftype.compare("FillerJPTJets")==0) {
      FillerJPTJets *fillerJPTJets = new FillerJPTJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerJPTJets);
      continue;
    }  

    if (ftype.compare("FillerCaloTaus")==0) {
      FillerCaloTaus *fillerCaloTaus = new FillerCaloTaus(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerCaloTaus);
      continue;
    }
    
    if (ftype.compare("FillerPFTaus")==0) {
      FillerPFTaus *fillerPFTaus = new FillerPFTaus(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerPFTaus);
      continue;
    }  

    if (ftype.compare("FillerNSVFit")==0) {
      FillerNSVFit *fillerNSVFit = new FillerNSVFit(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerNSVFit);
      continue;
    }  

    if (ftype.compare("FillerTrackJets")==0) {
      FillerTrackJets *fillerTrackJets = new FillerTrackJets(cfg, name.c_str(), defactive_);
      addActiveFiller(fillerTrackJets);
      continue;
    }
    
    edm::LogError("FillMitTree") 
      << "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
    throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
      << "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
  }

  return 1;
}

//--------------------------------------------------------------------------------------------------
bool FillMitTree::configureTreeWriter(const edm::ParameterSet &cfg)
{
  // Configure tree writer with options from config file.

  tws_->SetPrefix(cfg.getUntrackedParameter<string>("fileName","mit-test"));
  tws_->SetBaseURL(cfg.getUntrackedParameter<string>("pathName","."));
  tws_->SetMaxSize((Long64_t)cfg.getUntrackedParameter<unsigned>("maxSize",1024)*1024*1024);
  tws_->SetCompressLevel(cfg.getUntrackedParameter<unsigned>("compLevel",9));
  tws_->SetDefaultSL(cfg.getUntrackedParameter<unsigned>("splitLevel",99));
  tws_->SetDefaultBrSize(cfg.getUntrackedParameter<unsigned>("brSize",16*1024));
  
  if (OptInt::IsActivated()) {
    OptInt::SetZipMode(cfg.getUntrackedParameter<unsigned>("zipMode",99));
    OptInt::SetGzipFraction(cfg.getUntrackedParameter<double>("gZipThres",1.0));
    OptInt::SetBzipFraction(cfg.getUntrackedParameter<double>("bZipThres",-1.0));
    OptInt::SetLzoFraction(cfg.getUntrackedParameter<double>("lzoThres",-1.0));
    OptInt::SetLzmaFraction(cfg.getUntrackedParameter<double>("lzmaThres",0.95));
    OptInt::SetVerbose(cfg.getUntrackedParameter<unsigned>("optIOVerbose",0));

  } else {

    if (cfg.exists("zipMode")   || cfg.exists("bZipThres") ||
        cfg.exists("gZipThres") || cfg.exists("lzoThres")  ||
        cfg.exists("lzmaThres")) {
      edm::LogError("FillMitTree") << 
        "OptIO interface not properly pre-loaded, ignoring given settings." << std::endl;
    }
  }
  
  return 1;
}

//--------------------------------------------------------------------------------------------------
void FillMitTree::endJob()
{
  // Delete fillers.

  for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
    delete *iF;
  }

  tws_->Clear();
  
  edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
}
Revision:	1.62
Committed:	Mon Sep 12 15:21:38 2011 UTC (13 years, 7 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_025a, Mit_025, Mit_025pre2, Mit_025pre1
Changes since 1.61:	+3 -1 lines
Log Message:	minimal changes for 440pre9
#	User	Rev	Content
1	bendavid	1.62	// $Id: FillMitTree.cc,v 1.61 2011/05/05 12:43:25 rwolf Exp $
2	paus	1.1
3	loizides	1.3	#include "MitProd/TreeFiller/interface/FillMitTree.h"
4	paus	1.1	#include "FWCore/MessageLogger/interface/MessageLogger.h"
5	loizides	1.32	#include "FWCore/ParameterSet/interface/ParameterSet.h"
6	paus	1.1	#include "FWCore/ServiceRegistry/interface/Service.h"
7	loizides	1.16	#include "MitProd/ObjectService/interface/ObjectService.h"
8	loizides	1.6	#include "MitProd/TreeFiller/interface/AssociationMaps.h"
9	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerBasicClusters.h"
10	bendavid	1.28	#include "MitProd/TreeFiller/interface/FillerBeamSpot.h"
11	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerCaloJets.h"
12			#include "MitProd/TreeFiller/interface/FillerCaloMet.h"
13	bendavid	1.41	#include "MitProd/TreeFiller/interface/FillerCaloTaus.h"
14	sixie	1.20	#include "MitProd/TreeFiller/interface/FillerCaloTowers.h"
15	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerConversions.h"
16	bendavid	1.58	#include "MitProd/TreeFiller/interface/FillerConversionsDecay.h"
17	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerDecayParts.h"
18	loizides	1.6	#include "MitProd/TreeFiller/interface/FillerElectrons.h"
19	loizides	1.52	#include "MitProd/TreeFiller/interface/FillerEvtSelData.h"
20	sixie	1.22	#include "MitProd/TreeFiller/interface/FillerGenJets.h"
21	bendavid	1.44	#include "MitProd/TreeFiller/interface/FillerGenMet.h"
22	bendavid	1.57	#include "MitProd/TreeFiller/interface/FillerJPTJets.h"
23	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerMCEventInfo.h"
24			#include "MitProd/TreeFiller/interface/FillerMCParticles.h"
25	loizides	1.48	#include "MitProd/TreeFiller/interface/FillerMCVertexes.h"
26	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerMet.h"
27			#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
28	loizides	1.45	#include "MitProd/TreeFiller/interface/FillerMetaInfos.h"
29	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerMuons.h"
30			#include "MitProd/TreeFiller/interface/FillerPFCandidates.h"
31	bendavid	1.33	#include "MitProd/TreeFiller/interface/FillerPFJets.h"
32	bendavid	1.34	#include "MitProd/TreeFiller/interface/FillerPFMet.h"
33	bendavid	1.41	#include "MitProd/TreeFiller/interface/FillerPFTaus.h"
34	rwolf	1.61	#include "MitProd/TreeFiller/interface/FillerNSVFit.h"
35	bendavid	1.8	#include "MitProd/TreeFiller/interface/FillerPhotons.h"
36	mzanetti	1.59	#include "MitProd/TreeFiller/interface/FillerPileupInfo.h"
37	mzanetti	1.60	#include "MitProd/TreeFiller/interface/FillerPileupEnergyDensity.h"
38	loizides	1.48	#include "MitProd/TreeFiller/interface/FillerPixelHits.h"
39	paus	1.13	#include "MitProd/TreeFiller/interface/FillerStableParts.h"
40	loizides	1.51	#include "MitProd/TreeFiller/interface/FillerStripHits.h"
41	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerSuperClusters.h"
42	bendavid	1.56	#include "MitProd/TreeFiller/interface/FillerTracks.h"
43	bendavid	1.55	#include "MitProd/TreeFiller/interface/FillerTrackJets.h"
44	loizides	1.37	#include "MitProd/TreeFiller/interface/FillerVertexes.h"
45	loizides	1.35	#include "MitAna/DataTree/interface/Names.h"
46			#include "MitAna/DataTree/interface/BranchTable.h"
47	bendavid	1.49	#include "MitCommon/OptIO/interface/OptInt.h"
48	loizides	1.21
49	paus	1.1	using namespace std;
50			using namespace edm;
51			using namespace mithep;
52
53	loizides	1.16	mithep::ObjectService *mithep::FillMitTree::os_ = 0;
54
55	loizides	1.9	//--------------------------------------------------------------------------------------------------
56	loizides	1.7	FillMitTree::FillMitTree(const edm::ParameterSet &cfg) :
57	loizides	1.35	defactive_(cfg.getUntrackedParameter<bool>("defactive",1)),
58	loizides	1.40	brtable_(0),
59	bendavid	1.49	acfnumber_(-1),
60			tws_(new TreeWriter(Names::gkEvtTreeName,0))
61	paus	1.1	{
62	loizides	1.6	// Constructor.
63	loizides	1.15
64	loizides	1.3	if (!configure(cfg)) {
65			throw edm::Exception(edm::errors::Configuration, "FillMitTree::FillMitTree()\n")
66			<< "Could not configure fillers." << "\n";
67			}
68	paus	1.1	}
69
70	loizides	1.9	//--------------------------------------------------------------------------------------------------
71	paus	1.1	FillMitTree::~FillMitTree()
72			{
73	loizides	1.35	// Destructor.
74
75			delete brtable_;
76	bendavid	1.49	delete tws_;
77	paus	1.1	}
78
79	loizides	1.9	//--------------------------------------------------------------------------------------------------
80	loizides	1.17	bool FillMitTree::addActiveFiller(BaseFiller *bf)
81			{
82			// Check if filler is active and add it to list of fillers. Otherwise delete it.
83
84	loizides	1.35	if (!bf)
85			return 0;
86
87	loizides	1.17	if (bf->Active()) {
88			fillers_.push_back(bf);
89			return 1;
90			}
91
92			delete bf;
93			bf = 0;
94			return 0;
95			}
96
97			//--------------------------------------------------------------------------------------------------
98	bendavid	1.53	void FillMitTree::beginRun(edm::Run const &run, edm::EventSetup const &setup)
99			{
100			// Access and copy event content.
101
102			// first step: Loop over the data fillers of the various components
103			for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
104			(*iF)->FillRunBlock(run,setup);
105			}
106	bendavid	1.56
107	bendavid	1.53	}
108
109			//--------------------------------------------------------------------------------------------------
110	loizides	1.3	void FillMitTree::analyze(const edm::Event &event,
111			const edm::EventSetup &setup)
112			{
113			// Access and copy event content.
114	bendavid	1.49
115			//tree writer begin event actions
116			tws_->BeginEvent(kTRUE);
117	loizides	1.3
118	loizides	1.32	// first step: Loop over the data fillers of the various components
119	loizides	1.3	for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
120	bendavid	1.62	//printf("%s FillDataBlock\n",(*iF)->Name().c_str());
121	loizides	1.3	(*iF)->FillDataBlock(event,setup);
122			}
123
124	loizides	1.32	// second step: Loop over the link resolution of the various components
125	loizides	1.3	for (std::vector<BaseFiller*>::const_iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
126	bendavid	1.62	//printf("%s ResolveLinks\n",(*iF)->Name().c_str());
127	loizides	1.3	(*iF)->ResolveLinks(event,setup);
128			}
129	loizides	1.38
130	loizides	1.40	if (brtable_) { // only the first FillMitTree object has to deal with the branch table
131			if (acfnumber_==-1) {
132			brtable_->Rehash(brtable_->GetSize());
133			if (0)
134			brtable_->Print();
135			}
136			if (acfnumber_ != tws_->GetFileNumber()) {
137			tws_->StoreObject(brtable_);
138			acfnumber_ = tws_->GetFileNumber();
139			}
140			}
141	mzanetti	1.59
142	bendavid	1.49	//tree writer end of event actions
143			tws_->EndEvent(kTRUE);
144	loizides	1.3	}
145
146	loizides	1.9	//--------------------------------------------------------------------------------------------------
147	yilmaz	1.54	void FillMitTree::beginJob()
148	paus	1.1	{
149	loizides	1.2	// Access the tree and book branches.
150
151	loizides	1.40	if (os_==0) { // only the first FillMitTree object has to deal with this
152	loizides	1.16	Service<ObjectService> os;
153			if (!os.isAvailable()) {
154			throw edm::Exception(edm::errors::Configuration, "FillMitTree::beginJob()\n")
155	loizides	1.17	<< "Could not get object service. "
156			<< "Do you have the ObjectService defined in your config?" << "\n";
157	loizides	1.16	return;
158			}
159			os_ = &(*os);
160	loizides	1.40	brtable_ = new BranchTable;
161			brtable_->SetName(Names::gkBranchTable);
162			brtable_->SetOwner();
163	loizides	1.35	os->add(brtable_, brtable_->GetName());
164	loizides	1.16	}
165
166	bendavid	1.56	// loop over the various components and book the branches
167			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
168			edm::LogInfo("FillMitTree::beginJob") << "Booking for " << (*iF)->Name() << endl;
169			(iF)->BookDataBlock(tws_);
170			}
171
172			// call branch ref for the event tree
173			if (brtable_ && tws_->GetTree())
174			tws_->GetTree()->BranchRef();
175
176	paus	1.1	}
177
178	loizides	1.9	//--------------------------------------------------------------------------------------------------
179	loizides	1.3	bool FillMitTree::configure(const edm::ParameterSet &cfg)
180	paus	1.1	{
181	bendavid	1.49
182			// Configure TreeWriter
183			const std::string twsConfigName("TreeWriter");
184			ParameterSet twsConfig;
185			if (cfg.existsAs<ParameterSet>(twsConfigName,0))
186			twsConfig = cfg.getUntrackedParameter<ParameterSet>(twsConfigName);
187
188			configureTreeWriter(twsConfig);
189
190	loizides	1.36	// Configure our fillers according to given parameter ("fillers").
191	loizides	1.3
192	bendavid	1.33	std::vector<std::string> pars;
193	loizides	1.36	if (cfg.exists("fillers"))
194			pars=cfg.getUntrackedParameter<vector<string> >("fillers");
195	bendavid	1.33	else
196			cfg.getParameterSetNames(pars, false);
197	loizides	1.32
198			// loop over psets
199			for (unsigned int i = 0; i<pars.size(); ++i) {
200
201			const string name(pars.at(i));
202
203	loizides	1.37	string ftype("Filler" + name);
204			if (cfg.existsAs<ParameterSet>(name,0)) {
205			ParameterSet next(cfg.getUntrackedParameter<ParameterSet>(name));
206			if (!next.exists("fillerType")) {
207	loizides	1.42	edm::LogError("FillMitTree") << "Cannot determine fillerType for pset named "
208	loizides	1.37	<< name << std::endl;
209			throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
210	loizides	1.42	<< "Cannot determine fillerType for pset named "
211	loizides	1.37	<< name << std::endl;
212			}
213			ftype = next.getUntrackedParameter<string>("fillerType");
214	loizides	1.32	}
215	loizides	1.2
216	loizides	1.37	edm::LogInfo("FillMitTree") << "Attempting to configure '" << ftype
217			<< "' for '" << name << "'" << std::endl;
218	loizides	1.35
219	loizides	1.32	if (ftype.compare("FillerMetaInfos")==0) {
220			FillerMetaInfos *fillerMetaInfos = new FillerMetaInfos(cfg, name.c_str(), defactive_);
221			addActiveFiller(fillerMetaInfos);
222			continue;
223			}
224	loizides	1.37
225	loizides	1.32	if (ftype.compare("FillerMCParticles")==0) {
226			FillerMCParticles *fillerMCParticles = new FillerMCParticles(cfg, name.c_str(), defactive_);
227			addActiveFiller(fillerMCParticles);
228			continue;
229			}
230	loizides	1.37
231			if (ftype.compare("FillerMCEventInfo")==0) {
232			FillerMCEventInfo *fillerMCEventInfo = new FillerMCEventInfo(cfg, name.c_str(), defactive_);
233			addActiveFiller(fillerMCEventInfo);
234			continue;
235			}
236
237	loizides	1.48	if (ftype.compare("FillerMCVertexes")==0) {
238			FillerMCVertexes *fillerMCVertexes = new FillerMCVertexes(cfg, name.c_str(), defactive_);
239			addActiveFiller(fillerMCVertexes);
240			continue;
241			}
242
243	loizides	1.52	if (ftype.compare("FillerEvtSelData")==0) {
244			FillerEvtSelData *fillerEvtSelData = new FillerEvtSelData(cfg, name.c_str(), defactive_);
245			addActiveFiller(fillerEvtSelData);
246			continue;
247			}
248
249	loizides	1.32	if (ftype.compare("FillerBeamSpot")==0) {
250			FillerBeamSpot *fillerBeamSpot = new FillerBeamSpot(cfg, name.c_str(), defactive_);
251			addActiveFiller(fillerBeamSpot);
252			continue;
253			}
254	loizides	1.52
255	loizides	1.32	if (ftype.compare("FillerVertexes")==0) {
256			FillerVertexes *fillerVertexes = new FillerVertexes(cfg, name.c_str(), defactive_);
257			addActiveFiller(fillerVertexes);
258			continue;
259			}
260
261			if (ftype.compare("FillerCaloTowers")==0) {
262			FillerCaloTowers *fillerCaloTowers = new FillerCaloTowers(cfg, name.c_str(), defactive_);
263			addActiveFiller(fillerCaloTowers);
264			continue;
265			}
266
267			if (ftype.compare("FillerGenJets")==0) {
268			FillerGenJets *fillerGenJets = new FillerGenJets(cfg, name.c_str(), defactive_);
269			addActiveFiller(fillerGenJets);
270			continue;
271			}
272
273			if (ftype.compare("FillerCaloJets")==0) {
274			FillerCaloJets *fillerCaloJets = new FillerCaloJets(cfg, name.c_str(), defactive_);
275			addActiveFiller(fillerCaloJets);
276			continue;
277			}
278	bendavid	1.34
279			if (ftype.compare("FillerMet")==0) {
280			FillerMet *fillerMet = new FillerMet(cfg, name.c_str(), defactive_);
281			addActiveFiller(fillerMet);
282			continue;
283			}
284	bendavid	1.44
285			if (ftype.compare("FillerGenMet")==0) {
286			FillerGenMet *fillerGenMet = new FillerGenMet(cfg, name.c_str(), defactive_);
287			addActiveFiller(fillerGenMet);
288			continue;
289			}
290	bendavid	1.34
291	loizides	1.32	if (ftype.compare("FillerCaloMet")==0) {
292			FillerCaloMet *fillerCaloMet = new FillerCaloMet(cfg, name.c_str(), defactive_);
293			addActiveFiller(fillerCaloMet);
294			continue;
295	bendavid	1.34	}
296
297			if (ftype.compare("FillerPFMet")==0) {
298			FillerPFMet *fillerPFMet = new FillerPFMet(cfg, name.c_str(), defactive_);
299			addActiveFiller(fillerPFMet);
300			continue;
301	loizides	1.32	}
302
303			if (ftype.compare("FillerBasicClusters")==0) {
304			FillerBasicClusters *fillerBasicClusters =
305			new FillerBasicClusters(cfg, name.c_str(), defactive_);
306			addActiveFiller(fillerBasicClusters);
307			continue;
308			}
309
310			if (ftype.compare("FillerSuperClusters")==0) {
311			FillerSuperClusters *fillerSuperClusters =
312			new FillerSuperClusters(cfg, name.c_str(), defactive_);
313			addActiveFiller(fillerSuperClusters);
314			continue;
315			}
316
317	loizides	1.48	if (ftype.compare("FillerPixelHits")==0) {
318			FillerPixelHits *fillerPixelHits =
319			new FillerPixelHits(cfg, name.c_str(), defactive_);
320			addActiveFiller(fillerPixelHits);
321			continue;
322			}
323
324	mzanetti	1.59	if (ftype.compare("FillerPileupInfo")==0) {
325			FillerPileupInfo *fillerPileupInfo =
326			new FillerPileupInfo(cfg, name.c_str(), defactive_);
327			addActiveFiller(fillerPileupInfo);
328			continue;
329			}
330
331	mzanetti	1.60	if (ftype.compare("FillerPileupEnergyDensity")==0) {
332			FillerPileupEnergyDensity *fillerPileupEnergyDensity =
333			new FillerPileupEnergyDensity(cfg, name.c_str(), defactive_);
334			addActiveFiller(fillerPileupEnergyDensity);
335			continue;
336			}
337
338	loizides	1.51	if (ftype.compare("FillerStripHits")==0) {
339			FillerStripHits *fillerStripHits =
340			new FillerStripHits(cfg, name.c_str(), defactive_);
341			addActiveFiller(fillerStripHits);
342			continue;
343			}
344
345	loizides	1.32	if (ftype.compare("FillerTracks")==0) {
346			FillerTracks *fillerTracks = new FillerTracks(cfg, name.c_str(), defactive_);
347			addActiveFiller(fillerTracks);
348			continue;
349			}
350
351			if (ftype.compare("FillerMuons")==0) {
352			FillerMuons *fillerMuons = new FillerMuons(cfg, name.c_str(), defactive_);
353			addActiveFiller(fillerMuons);
354			continue;
355			}
356
357			if (ftype.compare("FillerElectrons")==0) {
358			FillerElectrons *fillerElectrons = new FillerElectrons(cfg, name.c_str(), defactive_);
359			addActiveFiller(fillerElectrons);
360			continue;
361			}
362
363			if (ftype.compare("FillerConversions")==0) {
364			FillerConversions *fillerConversions = new FillerConversions(cfg, name.c_str(), defactive_);
365			addActiveFiller(fillerConversions);
366			continue;
367	bendavid	1.58	}
368
369			if (ftype.compare("FillerConversionsDecay")==0) {
370			FillerConversionsDecay *fillerConversionsDecay = new FillerConversionsDecay(cfg, name.c_str(), defactive_);
371			addActiveFiller(fillerConversionsDecay);
372			continue;
373			}
374	loizides	1.32
375			if (ftype.compare("FillerPhotons")==0) {
376			FillerPhotons *fillerPhotons = new FillerPhotons(cfg, name.c_str(), defactive_);
377			addActiveFiller(fillerPhotons);
378			continue;
379			}
380
381			if (ftype.compare("FillerStableParts")==0) {
382			FillerStableParts *fillerStableParts = new FillerStableParts(cfg, name.c_str(), defactive_);
383			addActiveFiller(fillerStableParts);
384			continue;
385			}
386
387			if (ftype.compare("FillerDecayParts")==0) {
388			FillerDecayParts *fillerDecayParts = new FillerDecayParts(cfg, name.c_str(), defactive_);
389			addActiveFiller(fillerDecayParts);
390			continue;
391			}
392	bendavid	1.33
393			if (ftype.compare("FillerPFCandidates")==0) {
394	loizides	1.35	FillerPFCandidates *fillerPFCands = new FillerPFCandidates(cfg, name.c_str(), defactive_);
395			addActiveFiller(fillerPFCands);
396	bendavid	1.33	continue;
397			}
398	loizides	1.32
399	bendavid	1.33	if (ftype.compare("FillerPFJets")==0) {
400			FillerPFJets *fillerPFJets = new FillerPFJets(cfg, name.c_str(), defactive_);
401			addActiveFiller(fillerPFJets);
402			continue;
403			}
404	bendavid	1.41
405	bendavid	1.57	if (ftype.compare("FillerJPTJets")==0) {
406			FillerJPTJets *fillerJPTJets = new FillerJPTJets(cfg, name.c_str(), defactive_);
407			addActiveFiller(fillerJPTJets);
408			continue;
409			}
410
411	bendavid	1.41	if (ftype.compare("FillerCaloTaus")==0) {
412			FillerCaloTaus *fillerCaloTaus = new FillerCaloTaus(cfg, name.c_str(), defactive_);
413			addActiveFiller(fillerCaloTaus);
414			continue;
415			}
416
417			if (ftype.compare("FillerPFTaus")==0) {
418			FillerPFTaus *fillerPFTaus = new FillerPFTaus(cfg, name.c_str(), defactive_);
419			addActiveFiller(fillerPFTaus);
420			continue;
421			}
422	bendavid	1.56
423	rwolf	1.61	if (ftype.compare("FillerNSVFit")==0) {
424			FillerNSVFit *fillerNSVFit = new FillerNSVFit(cfg, name.c_str(), defactive_);
425			addActiveFiller(fillerNSVFit);
426			continue;
427			}
428
429	bendavid	1.55	if (ftype.compare("FillerTrackJets")==0) {
430			FillerTrackJets *fillerTrackJets = new FillerTrackJets(cfg, name.c_str(), defactive_);
431			addActiveFiller(fillerTrackJets);
432			continue;
433	bendavid	1.56	}
434
435	loizides	1.32	edm::LogError("FillMitTree")
436			<< "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
437			throw edm::Exception(edm::errors::Configuration, "FillMitTree::configure\n")
438			<< "Unknown fillerType " << ftype << " for pset named " << name << std::endl;
439			}
440	paus	1.13
441	loizides	1.3	return 1;
442	paus	1.1	}
443
444	loizides	1.9	//--------------------------------------------------------------------------------------------------
445	bendavid	1.49	bool FillMitTree::configureTreeWriter(const edm::ParameterSet &cfg)
446			{
447	loizides	1.50	// Configure tree writer with options from config file.
448	bendavid	1.49
449			tws_->SetPrefix(cfg.getUntrackedParameter<string>("fileName","mit-test"));
450			tws_->SetBaseURL(cfg.getUntrackedParameter<string>("pathName","."));
451			tws_->SetMaxSize((Long64_t)cfg.getUntrackedParameter<unsigned>("maxSize",1024)10241024);
452			tws_->SetCompressLevel(cfg.getUntrackedParameter<unsigned>("compLevel",9));
453			tws_->SetDefaultSL(cfg.getUntrackedParameter<unsigned>("splitLevel",99));
454			tws_->SetDefaultBrSize(cfg.getUntrackedParameter<unsigned>("brSize",16*1024));
455
456			if (OptInt::IsActivated()) {
457			OptInt::SetZipMode(cfg.getUntrackedParameter<unsigned>("zipMode",99));
458			OptInt::SetGzipFraction(cfg.getUntrackedParameter<double>("gZipThres",1.0));
459			OptInt::SetBzipFraction(cfg.getUntrackedParameter<double>("bZipThres",-1.0));
460			OptInt::SetLzoFraction(cfg.getUntrackedParameter<double>("lzoThres",-1.0));
461			OptInt::SetLzmaFraction(cfg.getUntrackedParameter<double>("lzmaThres",0.95));
462			OptInt::SetVerbose(cfg.getUntrackedParameter<unsigned>("optIOVerbose",0));
463
464			} else {
465
466			if (cfg.exists("zipMode") \|\| cfg.exists("bZipThres") \|\|
467			cfg.exists("gZipThres") \|\| cfg.exists("lzoThres") \|\|
468			cfg.exists("lzmaThres")) {
469	loizides	1.50	edm::LogError("FillMitTree") <<
470			"OptIO interface not properly pre-loaded, ignoring given settings." << std::endl;
471	bendavid	1.49	}
472			}
473
474			return 1;
475			}
476
477			//--------------------------------------------------------------------------------------------------
478	paus	1.1	void FillMitTree::endJob()
479			{
480	loizides	1.2	// Delete fillers.
481
482			for (std::vector<BaseFiller*>::iterator iF = fillers_.begin(); iF != fillers_.end(); ++iF) {
483			delete *iF;
484			}
485
486	bendavid	1.49	tws_->Clear();
487
488	paus	1.1	edm::LogInfo("FillMitTree::endJob") << "Ending Job" << endl;
489			}