TreeService/src/TreeService.cc

// $Id: TreeService.cc,v 1.12 2009/03/04 07:25:24 loizides Exp $

#include "MitProd/TreeService/interface/TreeService.h"
#include "DataFormats/Provenance/interface/ModuleDescription.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/MessageLogger/interface/JobReport.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "MitAna/DataUtil/interface/TreeWriter.h"
#include "MitAna/DataTree/interface/Names.h"
#include "MitCommon/OptIO/interface/OptInt.h"

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

//--------------------------------------------------------------------------------------------------
TreeService::TreeService(const ParameterSet &cfg, ActivityRegistry &ar) : 
  tws_(0),
  zipMode_(1),
  bZipThres_(1),
  gZipThres_(1),
  lzoThres_(1),
  lzmaThres_(1),
  optIOVerbose_(1),
  fDoReset_(cfg.getUntrackedParameter<bool>("doReset",1))
{
  // Constructor.

  if (cfg.exists("treeNames"))
    treeNames_=cfg.getUntrackedParameter<vector<string>   >("treeNames");
  else 
    treeNames_.push_back(Names::gkEvtTreeName);

  if (cfg.exists("fileNames"))
    fileNames_=cfg.getUntrackedParameter<vector<string>   >("fileNames");
  else
    fileNames_.push_back("mit-test");
    
  if (cfg.exists("pathNames"))
    pathNames_=cfg.getUntrackedParameter<vector<string>   >("pathNames");
  else
    pathNames_.push_back(".");

  if (cfg.exists("maxSizes"))
    maxSizes_=cfg.getUntrackedParameter<vector<unsigned> >("maxSizes");
  else 
    maxSizes_.push_back(1024);

  if (cfg.exists("compLevels"))
    compLevels_=cfg.getUntrackedParameter<vector<unsigned> >("compLevels");
  else 
    compLevels_.push_back(9);

  if (cfg.exists("splitLevels"))
    splitLevels_=cfg.getUntrackedParameter<vector<unsigned> >("splitLevels");
  else 
    splitLevels_.push_back(99);

  if (cfg.exists("brSizes"))
    brSizes_=cfg.getUntrackedParameter<vector<unsigned> >("brSizes");
  else 
    brSizes_.push_back(16*1024);

  if (treeNames_.size()!=fileNames_.size()) {
    throw edm::Exception(edm::errors::Configuration, "TreeService::TreeService()\n")
      << "Number of main trees should match number of files " << treeNames_.size() 
      << " " << fileNames_.size() << "\n";
    return;
  }

  if (OptInt::IsActivated()) {
    if (cfg.exists("zipMode"))
      zipMode_=cfg.getUntrackedParameter<unsigned>("zipMode");
    else 
      zipMode_ = 99;

    if (cfg.exists("bZipThres"))
      bZipThres_=cfg.getUntrackedParameter<double>("bZipThres");
    else 
      bZipThres_ = -1.0;

    if (cfg.exists("gZipThres"))
      gZipThres_=cfg.getUntrackedParameter<double>("gZipThres");
    else 
      gZipThres_ = 1.0;

    if (cfg.exists("lzoThres"))
      lzoThres_=cfg.getUntrackedParameter<double>("lzoThres");
    else 
      lzoThres_ = -1.0;

    if (cfg.exists("lzmaThres"))
      lzmaThres_=cfg.getUntrackedParameter<double>("lzmaThres");
    else 
      lzmaThres_ = 0.95;

    if (cfg.exists("optIOVerbose"))
      optIOVerbose_=cfg.getUntrackedParameter<unsigned>("optIOVerbose");
    else
      optIOVerbose_ = 0;

    OptInt::SetZipMode(zipMode_);
    OptInt::SetGzipFraction(gZipThres_);
    OptInt::SetBzipFraction(bZipThres_);
    OptInt::SetLzoFraction(lzoThres_);
    OptInt::SetLzmaFraction(lzmaThres_);
    OptInt::SetVerbose(optIOVerbose_);

  } else {

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

  // setup tw array
  tws_.SetOwner(kTRUE);
  tws_.Expand(treeNames_.size());

  // init tree writers 
  for (unsigned int i=0; i<treeNames_.size(); ++i) {

    TreeWriter *t = new TreeWriter(treeNames_.at(i).c_str(),0);
    t->SetPrefix(fileNames_.at(i).c_str());

    if (i<pathNames_.size())
      t->SetBaseURL(pathNames_.at(i).c_str());
    else if (pathNames_.size()>0)
      t->SetBaseURL(pathNames_.at(0).c_str());

    if (i<maxSizes_.size())
      t->SetMaxSize((Long64_t)maxSizes_.at(i)*1024*1024);
    else if (maxSizes_.size()>0)
      t->SetMaxSize((Long64_t)maxSizes_.at(0)*1024*1024);

    if (i<compLevels_.size())
      t->SetCompressLevel(compLevels_.at(i));
    else if (compLevels_.size()>0)
      t->SetCompressLevel(compLevels_.at(0));

    if (i<splitLevels_.size())
      t->SetDefaultSL(splitLevels_.at(i));
    else if (splitLevels_.size()>0)
      t->SetDefaultSL(splitLevels_.at(0));

    if (i<brSizes_.size())
      t->SetDefaultBrSize(brSizes_.at(i));
    else if (brSizes_.size()>0)
      t->SetDefaultBrSize(brSizes_.at(0));

    //t->Print();
    tws_.Add(t);
  }

  // set watchers
  ar.watchPreProcessEvent (this,&TreeService::preEventProcessing);
  ar.watchPostProcessEvent(this,&TreeService::postEventProcessing);
  ar.watchPostBeginJob    (this,&TreeService::postBeginJob);
  ar.watchPostEndJob      (this,&TreeService::postEndJob);
}

//--------------------------------------------------------------------------------------------------
TreeService::~TreeService() 
{
  // Destructor.
}

//--------------------------------------------------------------------------------------------------
TreeWriter *TreeService::get(const char *name) 
{
  // Get TreeWriter by name. If no name given, first one will be returned.

  if (tws_.GetEntries()<=0)
    return 0;

  if (name==0) 
    return dynamic_cast<TreeWriter*>(tws_.At(0));

  TObject *ret = tws_.FindObject(name);

  return dynamic_cast<TreeWriter*>(ret);
}

//--------------------------------------------------------------------------------------------------
void TreeService::postBeginJob()
{
  // Nothing to be done for now
}

//--------------------------------------------------------------------------------------------------
void TreeService::postEndJob()
{
  // Clear all TreeWriter objects.

  tws_.Clear();
}

//--------------------------------------------------------------------------------------------------
void TreeService::postEventProcessing(const Event&, const EventSetup&)
{
  // Loop over all TreeWriter objects before processing of an event.

  for (int i=0; i<tws_.GetEntries(); ++i) {
    TreeWriter *tw=dynamic_cast<TreeWriter*>(tws_.At(i));
    if (tw) {
      if (i<tws_.GetEntries()-1)
        tw->EndEvent();
      else // make sure objects are only reset at the end (if at all)
        tw->EndEvent(fDoReset_);
    }
  }
}

//--------------------------------------------------------------------------------------------------
void TreeService::preEventProcessing(const EventID&, const Timestamp&)
{
  // Loop over all TreeWriter objects after processing of a events.

  for (int i=0; i<tws_.GetEntries(); ++i) {
    TreeWriter *tw=dynamic_cast<TreeWriter*>(tws_.At(i));
    if (tw) {
      if (i==0) // make sure objects are only reset at the beginning (if at all)
        tw->BeginEvent(fDoReset_);
      else
        tw->BeginEvent();
    }
  }
}
Revision:	1.13
Committed:	Mon Mar 23 22:12:58 2009 UTC (16 years, 1 month ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_011a, Mit_011, Mit_010a, Mit_010, Mit_009c, Mit_009b, Mit_009a, Mit_009, Mit_008
Changes since 1.12:	+2 -2 lines
Log Message:	16K defaul branch size.
#	User	Rev	Content
1	loizides	1.13	// $Id: TreeService.cc,v 1.12 2009/03/04 07:25:24 loizides Exp $
2	loizides	1.1
3			#include "MitProd/TreeService/interface/TreeService.h"
4			#include "DataFormats/Provenance/interface/ModuleDescription.h"
5			#include "FWCore/ParameterSet/interface/ParameterSet.h"
6			#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
7			#include "FWCore/ServiceRegistry/interface/Service.h"
8			#include "FWCore/MessageLogger/interface/JobReport.h"
9	loizides	1.12	#include "FWCore/MessageLogger/interface/MessageLogger.h"
10	loizides	1.1	#include "MitAna/DataUtil/interface/TreeWriter.h"
11	loizides	1.6	#include "MitAna/DataTree/interface/Names.h"
12	bendavid	1.11	#include "MitCommon/OptIO/interface/OptInt.h"
13	loizides	1.1
14			using namespace edm;
15			using namespace std;
16			using namespace mithep;
17
18	paus	1.2	//--------------------------------------------------------------------------------------------------
19	loizides	1.8	TreeService::TreeService(const ParameterSet &cfg, ActivityRegistry &ar) :
20	loizides	1.10	tws_(0),
21	loizides	1.12	zipMode_(1),
22			bZipThres_(1),
23			gZipThres_(1),
24			lzoThres_(1),
25			lzmaThres_(1),
26			optIOVerbose_(1),
27	loizides	1.10	fDoReset_(cfg.getUntrackedParameter<bool>("doReset",1))
28	loizides	1.3	{
29	loizides	1.8	// Constructor.
30
31	loizides	1.6	if (cfg.exists("treeNames"))
32			treeNames_=cfg.getUntrackedParameter<vector<string> >("treeNames");
33			else
34			treeNames_.push_back(Names::gkEvtTreeName);
35
36			if (cfg.exists("fileNames"))
37			fileNames_=cfg.getUntrackedParameter<vector<string> >("fileNames");
38			else
39			fileNames_.push_back("mit-test");
40
41			if (cfg.exists("pathNames"))
42			pathNames_=cfg.getUntrackedParameter<vector<string> >("pathNames");
43			else
44			pathNames_.push_back(".");
45
46			if (cfg.exists("maxSizes"))
47			maxSizes_=cfg.getUntrackedParameter<vector<unsigned> >("maxSizes");
48			else
49			maxSizes_.push_back(1024);
50
51			if (cfg.exists("compLevels"))
52			compLevels_=cfg.getUntrackedParameter<vector<unsigned> >("compLevels");
53			else
54			compLevels_.push_back(9);
55
56			if (cfg.exists("splitLevels"))
57			splitLevels_=cfg.getUntrackedParameter<vector<unsigned> >("splitLevels");
58			else
59			splitLevels_.push_back(99);
60
61			if (cfg.exists("brSizes"))
62			brSizes_=cfg.getUntrackedParameter<vector<unsigned> >("brSizes");
63			else
64	loizides	1.13	brSizes_.push_back(16*1024);
65	bendavid	1.11
66	loizides	1.3	if (treeNames_.size()!=fileNames_.size()) {
67			throw edm::Exception(edm::errors::Configuration, "TreeService::TreeService()\n")
68			<< "Number of main trees should match number of files " << treeNames_.size()
69			<< " " << fileNames_.size() << "\n";
70			return;
71	loizides	1.1	}
72
73	loizides	1.12	if (OptInt::IsActivated()) {
74			if (cfg.exists("zipMode"))
75			zipMode_=cfg.getUntrackedParameter<unsigned>("zipMode");
76			else
77			zipMode_ = 99;
78
79			if (cfg.exists("bZipThres"))
80			bZipThres_=cfg.getUntrackedParameter<double>("bZipThres");
81			else
82			bZipThres_ = -1.0;
83
84			if (cfg.exists("gZipThres"))
85			gZipThres_=cfg.getUntrackedParameter<double>("gZipThres");
86			else
87			gZipThres_ = 1.0;
88
89			if (cfg.exists("lzoThres"))
90			lzoThres_=cfg.getUntrackedParameter<double>("lzoThres");
91			else
92			lzoThres_ = -1.0;
93
94			if (cfg.exists("lzmaThres"))
95			lzmaThres_=cfg.getUntrackedParameter<double>("lzmaThres");
96			else
97			lzmaThres_ = 0.95;
98
99			if (cfg.exists("optIOVerbose"))
100			optIOVerbose_=cfg.getUntrackedParameter<unsigned>("optIOVerbose");
101			else
102			optIOVerbose_ = 0;
103
104			OptInt::SetZipMode(zipMode_);
105			OptInt::SetGzipFraction(gZipThres_);
106			OptInt::SetBzipFraction(bZipThres_);
107			OptInt::SetLzoFraction(lzoThres_);
108			OptInt::SetLzmaFraction(lzmaThres_);
109			OptInt::SetVerbose(optIOVerbose_);
110
111			} else {
112
113			if (cfg.exists("zipMode") \|\| cfg.exists("bZipThres") \|\|
114			cfg.exists("gZipThres") \|\| cfg.exists("lzoThres") \|\|
115			cfg.exists("lzmaThres")) {
116			edm::LogError("TreeService") << "OptIO interface not properly pre-loaded, "
117			"ignoring given settings." << std::endl;
118			}
119			}
120
121	loizides	1.1	// setup tw array
122			tws_.SetOwner(kTRUE);
123			tws_.Expand(treeNames_.size());
124
125			// init tree writers
126	paus	1.2	for (unsigned int i=0; i<treeNames_.size(); ++i) {
127	loizides	1.1
128	loizides	1.10	TreeWriter *t = new TreeWriter(treeNames_.at(i).c_str(),0);
129	loizides	1.1	t->SetPrefix(fileNames_.at(i).c_str());
130	paus	1.2
131	loizides	1.7	if (i<pathNames_.size())
132	paus	1.2	t->SetBaseURL(pathNames_.at(i).c_str());
133			else if (pathNames_.size()>0)
134			t->SetBaseURL(pathNames_.at(0).c_str());
135
136	loizides	1.7	if (i<maxSizes_.size())
137	loizides	1.4	t->SetMaxSize((Long64_t)maxSizes_.at(i)10241024);
138	paus	1.2	else if (maxSizes_.size()>0)
139	loizides	1.4	t->SetMaxSize((Long64_t)maxSizes_.at(0)10241024);
140	paus	1.2
141	loizides	1.7	if (i<compLevels_.size())
142	paus	1.2	t->SetCompressLevel(compLevels_.at(i));
143			else if (compLevels_.size()>0)
144			t->SetCompressLevel(compLevels_.at(0));
145
146	loizides	1.7	if (i<splitLevels_.size())
147	paus	1.2	t->SetDefaultSL(splitLevels_.at(i));
148			else if (splitLevels_.size()>0)
149			t->SetDefaultSL(splitLevels_.at(0));
150
151	loizides	1.7	if (i<brSizes_.size())
152	paus	1.2	t->SetDefaultBrSize(brSizes_.at(i));
153			else if (brSizes_.size()>0)
154			t->SetDefaultBrSize(brSizes_.at(0));
155	loizides	1.1
156			//t->Print();
157			tws_.Add(t);
158			}
159
160			// set watchers
161	loizides	1.8	ar.watchPreProcessEvent (this,&TreeService::preEventProcessing);
162			ar.watchPostProcessEvent(this,&TreeService::postEventProcessing);
163			ar.watchPostBeginJob (this,&TreeService::postBeginJob);
164			ar.watchPostEndJob (this,&TreeService::postEndJob);
165	loizides	1.1	}
166
167	paus	1.2	//--------------------------------------------------------------------------------------------------
168	loizides	1.1	TreeService::~TreeService()
169			{
170	loizides	1.8	// Destructor.
171	loizides	1.1	}
172
173	paus	1.2	//--------------------------------------------------------------------------------------------------
174	loizides	1.9	TreeWriter TreeService::get(const char name)
175	loizides	1.1	{
176	loizides	1.8	// Get TreeWriter by name. If no name given, first one will be returned.
177
178	paus	1.2	if (tws_.GetEntries()<=0)
179			return 0;
180	loizides	1.1
181	paus	1.2	if (name==0)
182	loizides	1.1	return dynamic_cast<TreeWriter*>(tws_.At(0));
183
184			TObject *ret = tws_.FindObject(name);
185	paus	1.2
186	loizides	1.1	return dynamic_cast<TreeWriter*>(ret);
187			}
188
189	paus	1.2	//--------------------------------------------------------------------------------------------------
190	loizides	1.1	void TreeService::postBeginJob()
191			{
192	loizides	1.8	// Nothing to be done for now
193	loizides	1.1	}
194
195	paus	1.2	//--------------------------------------------------------------------------------------------------
196	loizides	1.1	void TreeService::postEndJob()
197			{
198	loizides	1.8	// Clear all TreeWriter objects.
199
200	loizides	1.1	tws_.Clear();
201			}
202
203	paus	1.2	//--------------------------------------------------------------------------------------------------
204	loizides	1.1	void TreeService::postEventProcessing(const Event&, const EventSetup&)
205			{
206	loizides	1.8	// Loop over all TreeWriter objects before processing of an event.
207
208	paus	1.2	for (int i=0; i<tws_.GetEntries(); ++i) {
209	loizides	1.1	TreeWriter tw=dynamic_cast<TreeWriter>(tws_.At(i));
210	loizides	1.10	if (tw) {
211			if (i<tws_.GetEntries()-1)
212			tw->EndEvent();
213			else // make sure objects are only reset at the end (if at all)
214			tw->EndEvent(fDoReset_);
215			}
216	loizides	1.1	}
217			}
218
219	paus	1.2	//--------------------------------------------------------------------------------------------------
220	loizides	1.1	void TreeService::preEventProcessing(const EventID&, const Timestamp&)
221			{
222	loizides	1.8	// Loop over all TreeWriter objects after processing of a events.
223
224	paus	1.2	for (int i=0; i<tws_.GetEntries(); ++i) {
225	loizides	1.1	TreeWriter tw=dynamic_cast<TreeWriter>(tws_.At(i));
226	loizides	1.10	if (tw) {
227			if (i==0) // make sure objects are only reset at the beginning (if at all)
228			tw->BeginEvent(fDoReset_);
229			else
230			tw->BeginEvent();
231			}
232	loizides	1.1	}
233			}