Reference Manual

Classes
class	BinToBin

class	BinToBin1percent

struct	CheapValueSnapshot

class	Chi2

class	KS

class	StatisticalTest

class	unpickler

Functions
def	ask_ok

bool	checkModel (const RooStats::ModelConfig &model, bool throwOnFail=false)

void	copyAttributes (const RooAbsArg &from, RooAbsArg &to)

void	factorizeFunc (const RooArgSet &observables, RooAbsReal &pdf, RooArgList &obsTerms, RooArgList &otherTerms, bool debug=false)
	factorize a RooAbsReal More...

RooAbsPdf *	factorizePdf (const RooArgSet &observables, RooAbsPdf &pdf, RooArgList &constraints)

void	factorizePdf (RooStats::ModelConfig &model, RooAbsPdf &pdf, RooArgList &obsTerms, RooArgList &constraints, bool debug=false)
	collect factors depending on observables in obsTerms, and all others in constraints More...

void	factorizePdf (const RooArgSet &observables, RooAbsPdf &pdf, RooArgList &obsTerms, RooArgList &constraints, bool debug=false)

RooAbsReal *	fullCloneFunc (const RooAbsReal *pdf, RooArgSet &holder, bool cloneLeafNodes=false)

RooAbsPdf *	fullClonePdf (const RooAbsPdf *pdf, RooArgSet &holder, bool cloneLeafNodes=false)

def	get_relval_cmssw_version

def	get_relval_id

def	get_relval_max_version

def	get_relval_version
	-------------—— Make files pairs: RelVal utils ---------------—— More...

def	get_relvaldata_cmssw_version

def	get_relvaldata_id
	-----------—— Make files pairs: RelValData utils --------------—— More...

def	get_relvaldata_max_version

def	get_relvaldata_version

void	getClients (const RooAbsCollection &values, const RooAbsCollection &allObjects, RooAbsCollection &clients)
	add to 'clients' all object within allObjects that directly depend on values More...

def	getNbins

void	guessChannelMode (RooSimultaneous &simPdf, RooAbsData &simData, bool verbose=false)

def	is_empty

def	is_relvaldata
	----------------------— Make files pairs -----------------------— More...

def	is_sparse

def	literal2root

def	logger

def	make_files_pairs

RooAbsPdf *	makeNuisancePdf (RooStats::ModelConfig &model, const char *name="nuisancePdf")

RooAbsPdf *	makeNuisancePdf (RooAbsPdf &pdf, const RooArgSet &observables, const char *name="nuisancePdf")

RooAbsPdf *	makeObsOnlyPdf (RooStats::ModelConfig &model, const char *name="obsPdf")
	Note: doesn't recompose Simultaneous pdfs properly, for that use factorizePdf method. More...

std::vector< RooPlot * >	makePlots (const RooAbsPdf &pdf, const RooAbsData &data, const char signalSel=0, const char backgroundSel=0, float rebinFactor=1.0)
	make plots, if possible More...

void	printPdf (RooAbsPdf *pdf)

void	printPdf (RooStats::ModelConfig &model)

void	printPdf (RooWorkspace w, const char pdfName)

void	printRAD (const RooAbsData *d)

void	printRDH (RooAbsData *data)

def	profile2histo

RooSimultaneous *	rebuildSimPdf (const RooArgSet &observables, RooSimultaneous *pdf)

bool	setAllConstant (const RooAbsCollection &coll, bool constant=true)
	set all RooRealVars to constants. return true if at least one changed status More...

def	setTDRStyle

void	tdrStyle ()
	set style for plots More...

def	wget

Variables
int	_log_level = 10

	theargv = sys.argv

Function Documentation

def utils.ask_ok	(	prompt,
		retries = `4`,
		complaint = `'yes or no'`
	)

Definition at line 423 of file utils.py.

 
 def ask_ok(prompt, retries=4, complaint='yes or no'):
     while True:
         ok = raw_input(prompt)
         if ok in ('y', 'ye', 'yes'):
             return True
         if ok in ('n', 'no'):
             return False
         retries = retries - 1
         if retries < 0:
             raise IOError('refusenik user')
         print complaint
 
 #-------------------------------------------------------------------------------

utils.ask_ok

def ask_ok

Definition: utils.py:423

bool utils::checkModel	(	const RooStats::ModelConfig &	model,
		bool	throwOnFail = `false`
	)

Performs the following checks:

global observables, if any, are RooRealVars and are const
nuisances, if any, are RooRealVars and are floating
parameters of interest are all RooRealVars and are floating
there are no other floating parameters except observables, nuisances and POI

Definition at line 261 of file utils.cc.

References a, gather_cfg::cout, benchmark_cfg::errors, convertSQLiteXML::ok, and v.

Referenced by Combine::run().

                                                                          {
     bool ok = true; std::ostringstream errors; 
     std::auto_ptr<TIterator> iter;
     RooAbsPdf *pdf = model.GetPdf(); if (pdf == 0) throw std::invalid_argument("Model without Pdf");
     RooArgSet allowedToFloat; 
     if (model.GetObservables() == 0) { 
         ok = false; errors << "ERROR: model does not define observables.\n"; 
         std::cout << errors.str() << std::endl;
         if (throwOnFail) throw std::invalid_argument(errors.str()); else return false; 
     } else {
         allowedToFloat.add(*model.GetObservables());
     }
     if (model.GetParametersOfInterest() == 0) { 
         ok = false; errors << "ERROR: model does not define parameters of interest.\n";  
     } else {
         iter.reset(model.GetParametersOfInterest()->createIterator());
         for (RooAbsArg *a = (RooAbsArg *) iter->Next(); a != 0; a = (RooAbsArg *) iter->Next()) {
             RooRealVar *v = dynamic_cast<RooRealVar *>(a);
             if (!v) { ok = false; errors << "ERROR: parameter of interest " << a->GetName() << " is a " << a->ClassName() << " and not a RooRealVar\n"; continue; }
             if (v->isConstant()) { ok = false; errors << "ERROR: parameter of interest " << a->GetName() << " is constant\n"; continue; }
             if (!pdf->dependsOn(*v)) { ok = false; errors << "ERROR: pdf does not depend on parameter of interest " << a->GetName() << "\n"; continue; }
             allowedToFloat.add(*v);
         }
     }
     if (model.GetNuisanceParameters() != 0) { 
         iter.reset(model.GetNuisanceParameters()->createIterator());
         for (RooAbsArg *a = (RooAbsArg *) iter->Next(); a != 0; a = (RooAbsArg *) iter->Next()) {
             RooRealVar *v = dynamic_cast<RooRealVar *>(a);
             if (!v) { ok = false; errors << "ERROR: nuisance parameter " << a->GetName() << " is a " << a->ClassName() << " and not a RooRealVar\n"; continue; }
             if (v->isConstant()) { ok = false; errors << "ERROR: nuisance parameter " << a->GetName() << " is constant\n"; continue; }
             if (!pdf->dependsOn(*v)) { errors << "WARNING: pdf does not depend on nuisance parameter " << a->GetName() << "\n"; continue; }
             allowedToFloat.add(*v);
         }
     }
     if (model.GetGlobalObservables() != 0) { 
         iter.reset(model.GetGlobalObservables()->createIterator());
         for (RooAbsArg *a = (RooAbsArg *) iter->Next(); a != 0; a = (RooAbsArg *) iter->Next()) {
             RooRealVar *v = dynamic_cast<RooRealVar *>(a);
             if (!v) { ok = false; errors << "ERROR: global observable " << a->GetName() << " is a " << a->ClassName() << " and not a RooRealVar\n"; continue; }
             if (!v->isConstant()) { ok = false; errors << "ERROR: global observable " << a->GetName() << " is not constant\n"; continue; }
             if (!pdf->dependsOn(*v)) { errors << "WARNING: pdf does not depend on global observable " << a->GetName() << "\n"; continue; }
         }
     }
     std::auto_ptr<RooArgSet> params(pdf->getParameters(*model.GetObservables()));
     iter.reset(params->createIterator());
     for (RooAbsArg *a = (RooAbsArg *) iter->Next(); a != 0; a = (RooAbsArg *) iter->Next()) {
         if (a->getAttribute("flatParam") && a->isConstant()) {
             ok = false; errors << "ERROR: parameter " << a->GetName() << " is declared as flatParam but is constant.\n";
         }
         if (a->isConstant() || allowedToFloat.contains(*a)) continue;
         if (a->getAttribute("flatParam")) {
             RooRealVar *rrv = dynamic_cast<RooRealVar *>(a);
             if (rrv->getVal() > rrv->getMax() || rrv->getVal() < rrv->getMin()) {
                 ok = false; errors << "ERROR: flatParam " << rrv->GetName() << " has a value " << rrv->getVal() << 
                                       " outside of the defined range [" << rrv->getMin() << ", " << rrv->getMax() << "]\n";
             }
         } else {
             errors << "WARNING: pdf parameter " << a->GetName() << " (type " << a->ClassName() << ") is not allowed to float (it's not nuisance, poi, observable or global observable\n"; 
         }
     }
     iter.reset();
     std::cout << errors.str() << std::endl;
     if (!ok && throwOnFail) throw std::invalid_argument(errors.str()); 
     return ok;
 }

void utils::copyAttributes	(	const RooAbsArg &	from,
		RooAbsArg &	to
	)

Definition at line 364 of file utils.cc.

Referenced by factorizePdf(), and rebuildSimPdf().

                                                                {
     if (&from == &to) return;
     const std::set<std::string> attribs = from.attributes();
     if (!attribs.empty()) {
         for (std::set<std::string>::const_iterator it = attribs.begin(), ed = attribs.end(); it != ed; ++it) to.setAttribute(it->c_str());
     }
     const std::map<std::string, std::string> strattribs = from.stringAttributes();
     if (!strattribs.empty()) {
         for (std::map<std::string,std::string>::const_iterator it = strattribs.begin(), ed = strattribs.end(); it != ed; ++it) to.setStringAttribute(it->first.c_str(), it->second.c_str());
     }
 }

void utils::factorizeFunc	(	const RooArgSet &	observables,
		RooAbsReal &	pdf,
		RooArgList &	obsTerms,
		RooArgList &	otherTerms,
		bool	debug = `false`
	)

factorize a RooAbsReal

Definition at line 177 of file utils.cc.

References makeMuonMisalignmentScenario::components, factorizePdf(), and parseEventContent::prod.

Referenced by cacheutils::CachingAddNLL::setup_().

                                                                                                                                    {
     RooAbsPdf *pdf = dynamic_cast<RooAbsPdf *>(&func);
     if (pdf != 0) { 
         factorizePdf(observables, *pdf, obsTerms, constraints, debug); 
         return; 
     }
     const std::type_info & id = typeid(func);
     if (id == typeid(RooProduct)) {
         RooProduct *prod = dynamic_cast<RooProduct *>(&func);
         RooArgSet components(prod->components());
         //std::cout << "Function " << func.GetName() << " is a RooProduct with " << components.getSize() << " components." << std::endl;
         std::auto_ptr<TIterator> iter(components.createIterator());
         for (RooAbsReal *funci = (RooAbsReal *) iter->Next(); funci != 0; funci = (RooAbsReal *) iter->Next()) {
             //std::cout << "  component " << funci->GetName() << " of type " << funci->ClassName() << std::endl;
             factorizeFunc(observables, *funci, obsTerms, constraints);
         }
     } else if (func.dependsOn(observables)) {
         if (!obsTerms.contains(func)) obsTerms.add(func);
     } else {
         if (!constraints.contains(func)) constraints.add(func);
     }
 }

RooAbsPdf * utils::factorizePdf	(	const RooArgSet &	observables,
		RooAbsPdf &	pdf,
		RooArgList &	constraints
	)

Create a pdf which depends only on observables, and collect the other constraint terms Will return 0 if it's all constraints, &pdf if it's all observables, or a new pdf if it's something mixed In the last case, you're the owner of the returned pdf.

Definition at line 80 of file utils.cc.

References copyAttributes(), i, list(), n, pileupCalc::nbins, parseEventContent::prod, and run_regression::ret.

Referenced by HybridNew::create(), factorizeFunc(), factorizePdf(), makeNuisancePdf(), makeObsOnlyPdf(), makePlots(), rebuildSimPdf(), GoodnessOfFit::runSaturatedModel(), cacheutils::CachingSimNLL::setup_(), toymcoptutils::SimPdfGenInfo::SimPdfGenInfo(), and SimplerLikelihoodRatioTestStatOpt::SimplerLikelihoodRatioTestStatOpt().

                                                                                                     {
     assert(&pdf);
     const std::type_info & id = typeid(pdf);
     if (id == typeid(RooProdPdf)) {
         //std::cout << " pdf is product pdf " << pdf.GetName() << std::endl;
         RooProdPdf *prod = dynamic_cast<RooProdPdf *>(&pdf);
         RooArgList newFactors; RooArgSet newOwned;
         RooArgList list(prod->pdfList());
         bool needNew = false;
         for (int i = 0, n = list.getSize(); i < n; ++i) {
             RooAbsPdf *pdfi = (RooAbsPdf *) list.at(i);
             RooAbsPdf *newpdf = factorizePdf(observables, *pdfi, constraints);
             //std::cout << "    for " << pdfi->GetName() << "   newpdf  " << (newpdf == 0 ? "null" : (newpdf == pdfi ? "old" : "new"))  << std::endl;
             if (newpdf == 0) { needNew = true; continue; }
             if (newpdf != pdfi) { needNew = true; newOwned.add(*newpdf); }
             newFactors.add(*newpdf);
         }
         if (!needNew) { copyAttributes(pdf, *prod); return prod; }
         else if (newFactors.getSize() == 0) return 0;
         else if (newFactors.getSize() == 1) {
             RooAbsPdf *ret = (RooAbsPdf *) newFactors.first()->Clone(TString::Format("%s_obsOnly", pdf.GetName()));
             copyAttributes(pdf, *ret);
             return ret;
         }
         RooProdPdf *ret = new RooProdPdf(TString::Format("%s_obsOnly", pdf.GetName()), "", newFactors);
         ret->addOwnedComponents(newOwned);
         copyAttributes(pdf, *ret);
         return ret;
     } else if (id == typeid(RooSimultaneous) || id == typeid(RooSimultaneousOpt)) {
         RooSimultaneous *sim  = dynamic_cast<RooSimultaneous *>(&pdf);
         RooAbsCategoryLValue *cat = (RooAbsCategoryLValue *) sim->indexCat().Clone();
         int nbins = cat->numBins((const char *)0);
         TObjArray factorizedPdfs(nbins); RooArgSet newOwned;
         bool needNew = false;
         for (int ic = 0, nc = nbins; ic < nc; ++ic) {
             cat->setBin(ic);
             RooAbsPdf *pdfi = sim->getPdf(cat->getLabel());
             RooAbsPdf *newpdf = factorizePdf(observables, *pdfi, constraints);
             factorizedPdfs[ic] = newpdf;
             if (newpdf == 0) { throw std::runtime_error(std::string("ERROR: channel ") + cat->getLabel() + " factorized to zero."); }
             if (newpdf != pdfi) { needNew = true; newOwned.add(*newpdf); }
         }
         RooSimultaneous *ret = sim;
         if (needNew) {
             ret = new RooSimultaneous(TString::Format("%s_obsOnly", pdf.GetName()), "", (RooAbsCategoryLValue&) sim->indexCat());
             for (int ic = 0, nc = nbins; ic < nc; ++ic) {
                 cat->setBin(ic);
                 RooAbsPdf *newpdf = (RooAbsPdf *) factorizedPdfs[ic];
                 if (newpdf) ret->addPdf(*newpdf, cat->getLabel());
             }
             ret->addOwnedComponents(newOwned);
         }
         delete cat;
         if (id == typeid(RooSimultaneousOpt)) {
             RooSimultaneousOpt *newret = new RooSimultaneousOpt(*ret);
             newret->addOwnedComponents(RooArgSet(*ret));
             ret = newret;
         }
         copyAttributes(pdf, *ret);
         return ret;
     } else if (pdf.dependsOn(observables)) {
         return &pdf;
     } else {
         if (!constraints.contains(pdf)) constraints.add(pdf);
         return 0;
     }
 
 }

void utils::factorizePdf	(	RooStats::ModelConfig &	model,
		RooAbsPdf &	pdf,
		RooArgList &	obsTerms,
		RooArgList &	constraints,
		bool	debug = `false`
	)

collect factors depending on observables in obsTerms, and all others in constraints

Definition at line 149 of file utils.cc.

References createBeamHaloJobs::constraints, debug, and factorizePdf().

                                                                                                                               {
     return factorizePdf(*model.GetObservables(), pdf, obsTerms, constraints, debug);
 }

void utils::factorizePdf	(	const RooArgSet &	observables,
		RooAbsPdf &	pdf,
		RooArgList &	obsTerms,
		RooArgList &	constraints,
		bool	debug = `false`
	)

Definition at line 152 of file utils.cc.

References factorizePdf(), i, list(), n, and parseEventContent::prod.

                                                                                                                                 {
     assert(&pdf);
     const std::type_info & id = typeid(pdf);
     if (id == typeid(RooProdPdf)) {
         RooProdPdf *prod = dynamic_cast<RooProdPdf *>(&pdf);
         RooArgList list(prod->pdfList());
         for (int i = 0, n = list.getSize(); i < n; ++i) {
             RooAbsPdf *pdfi = (RooAbsPdf *) list.at(i);
             factorizePdf(observables, *pdfi, obsTerms, constraints);
         }
     } else if (id == typeid(RooSimultaneous) || id == typeid(RooSimultaneousOpt)) {
         RooSimultaneous *sim  = dynamic_cast<RooSimultaneous *>(&pdf);
         RooAbsCategoryLValue *cat = (RooAbsCategoryLValue *) sim->indexCat().Clone();
         for (int ic = 0, nc = cat->numBins((const char *)0); ic < nc; ++ic) {
             cat->setBin(ic);
             RooAbsPdf *pdfi = sim->getPdf(cat->getLabel());
             if (pdfi != 0) factorizePdf(observables, *pdfi, obsTerms, constraints);
         }
         delete cat;
     } else if (pdf.dependsOn(observables)) {
         if (!obsTerms.contains(pdf)) obsTerms.add(pdf);
     } else {
         if (!constraints.contains(pdf)) constraints.add(pdf);
     }
 }

RooAbsReal * utils::fullCloneFunc	(	const RooAbsReal *	pdf,
		RooArgSet &	holder,
		bool	cloneLeafNodes = `false`
	)

Definition at line 226 of file utils.cc.

References tmp.

                                                                                               {
   // Clone all FUNC compents by copying all branch nodes
   RooArgSet tmp("RealBranchNodeList") ;
   pdf->branchNodeServerList(&tmp);
   tmp.snapshot(holder, cloneLeafNodes); 
   // Find the top level FUNC in the snapshot list
   return (RooAbsReal*) holder.find(pdf->GetName());
 }

RooAbsPdf * utils::fullClonePdf	(	const RooAbsPdf *	pdf,
		RooArgSet &	holder,
		bool	cloneLeafNodes = `false`
	)

Definition at line 218 of file utils.cc.

References tmp.

Referenced by SimplerLikelihoodRatioTestStatOpt::SimplerLikelihoodRatioTestStatOpt().

                                                                                            {
   // Clone all FUNC compents by copying all branch nodes
   RooArgSet tmp("RealBranchNodeList") ;
   pdf->branchNodeServerList(&tmp);
   tmp.snapshot(holder, cloneLeafNodes); 
   // Find the top level FUNC in the snapshot list
   return (RooAbsPdf*) holder.find(pdf->GetName());
 }

def utils.get_relval_cmssw_version ( file )

Definition at line 536 of file utils.py.

 
 def get_relval_cmssw_version(file):
     cmssw_release = re.findall('(CMSSW_\d*_\d*_\d*(?:_[\w\d]*)?)-', file)
     gr_r_version = re.findall('CMSSW_\d*_\d*_\d*(?:_[\w\d]*)?-([\w\d]*)_V\d*\w?(_[\w\d]*)?-v', file)
     if cmssw_release and gr_r_version:
         return (cmssw_release[0], gr_r_version[0])

utils.get_relval_cmssw_version

def get_relval_cmssw_version

Definition: utils.py:536

def utils.get_relval_id ( file )

Returns unique relval ID (dataset name) for a given file.

Definition at line 542 of file utils.py.

 
 def get_relval_id(file):
     """Returns unique relval ID (dataset name) for a given file."""
     dataset_name = re.findall('R\d{9}__([\w\d]*)__CMSSW_', file)
     return dataset_name[0]

utils.get_relval_id

def get_relval_id

Definition: utils.py:542

def utils.get_relval_max_version ( files )

Returns file with maximum version at a) beggining of the file,
e.g. DQM_V000M b) at the end of run, e.g. _run2012-vM. M has to be max.

Definition at line 524 of file utils.py.

References get_relval_version().

 
 def get_relval_max_version(files):
     """Returns file with maximum version at a) beggining of the file,
     e.g. DQM_V000M b) at the end of run, e.g. _run2012-vM. M has to be max."""
     max_file = files[0]
     max_v = get_relval_version(files[0])
     for file in files:
         file_v = get_relval_version(file)
         if file_v[1] > max_v[1] or ((file_v[1] == max_v[1]) and (file_v[0] > max_v[0])):
             max_file = file
             max_v = file_v
     return max_file

utils.get_relval_version

def get_relval_version

-------------—— Make files pairs: RelVal utils ---------------——

Definition: utils.py:517

utils.get_relval_max_version

def get_relval_max_version

Definition: utils.py:524

def utils.get_relval_version ( file )

-------------—— Make files pairs: RelVal utils ---------------——

Returns tuple (CMSSW version, run version) for specified file.

Definition at line 517 of file utils.py.

Referenced by get_relval_max_version().

 
 def get_relval_version(file):
     """Returns tuple (CMSSW version, run version) for specified file."""
     cmssw_version = re.findall('DQM_V(\d*)_', file)
     run_version = re.findall('CMSSW_\d*_\d*_\d*(?:_[\w\d]*)?-[\w\d]*_V\d*\w?(?:_[\w\d]*)?-v(\d*)__', file)
     if cmssw_version and run_version:
         return (int(cmssw_version[0]), int(run_version[0]))

utils.get_relval_version

def get_relval_version

-------------—— Make files pairs: RelVal utils ---------------——

Definition: utils.py:517

def utils.get_relvaldata_cmssw_version ( file )

Returns tuple (CMSSW release, GR_R version) for specified RelValData file.

Definition at line 486 of file utils.py.

 
 def get_relvaldata_cmssw_version(file):
     """Returns tuple (CMSSW release, GR_R version) for specified RelValData file."""
     cmssw_release = re.findall('(CMSSW_\d*_\d*_\d*(?:_[\w\d]*)?)-', file)
     gr_r_version = re.findall('-(GR_R_\d*_V\d*\w?)(?:_RelVal)?_', file)
     if not gr_r_version:
         gr_r_version = re.findall('CMSSW_\d*_\d*_\d*(?:_[\w\d]*)?-(\w*)_RelVal_', file)
     if cmssw_release and gr_r_version:
         return (cmssw_release[0], gr_r_version[0])

utils.get_relvaldata_cmssw_version

def get_relvaldata_cmssw_version

Definition: utils.py:486

def utils.get_relvaldata_id ( file )

-----------—— Make files pairs: RelValData utils --------------——

Returns unique relvaldata ID for a given file.

Definition at line 476 of file utils.py.

 
 def get_relvaldata_id(file):
     """Returns unique relvaldata ID for a given file."""
     run_id = re.search('R\d{9}', file)
     run = re.search('_RelVal_([\w\d]*)-v\d__', file)
     if not run:
         run = re.search('GR_R_\d*_V\d*C?_([\w\d]*)-v\d__', file)
     if run_id and run:
         return (run_id.group(), run.group(1))
     return None

utils.get_relvaldata_id

def get_relvaldata_id

-----------—— Make files pairs: RelValData utils --------------——

Definition: utils.py:476

def utils.get_relvaldata_max_version ( files )

Returns file with maximum version at a) beggining of the file,
e.g. DQM_V000M b) at the end of run, e.g. _run2012-vM. M has to be max.

Definition at line 504 of file utils.py.

References get_relvaldata_version().

 
 def get_relvaldata_max_version(files):
     """Returns file with maximum version at a) beggining of the file,
     e.g. DQM_V000M b) at the end of run, e.g. _run2012-vM. M has to be max."""
     max_file = files[0]
     max_v = get_relvaldata_version(files[0])
     for file in files:
         file_v = get_relvaldata_version(file)
         if file_v[1] > max_v[1] or ((file_v[1] == max_v[1]) and (file_v[0] > max_v[0])):
             max_file = file
             max_v = file_v
     return max_file

utils.get_relvaldata_version

def get_relvaldata_version

Definition: utils.py:495

utils.get_relvaldata_max_version

def get_relvaldata_max_version

Definition: utils.py:504

def utils.get_relvaldata_version ( file )

Returns tuple (CMSSW version, run version) for specified file.

Definition at line 495 of file utils.py.

Referenced by get_relvaldata_max_version().

 
 def get_relvaldata_version(file):
     """Returns tuple (CMSSW version, run version) for specified file."""
     cmssw_version = re.findall('DQM_V(\d*)_', file)
     run_version = re.findall('_RelVal_[\w\d]*-v(\d)__', file)
     if not run_version:
         run_version = re.findall('GR_R_\d*_V\d*C?_[\w\d]*-v(\d)__', file)
     if cmssw_version and run_version:
         return (int(cmssw_version[0]), int(run_version[0]))

utils.get_relvaldata_version

def get_relvaldata_version

Definition: utils.py:495

void utils::getClients	(	const RooAbsCollection &	values,
		const RooAbsCollection &	allObjects,
		RooAbsCollection &	clients
	)

add to 'clients' all object within allObjects that directly depend on values

Definition at line 236 of file utils.cc.

References a, and v.

Referenced by SimplerLikelihoodRatioTestStatOpt::SimplerLikelihoodRatioTestStatOpt().

                                                                                                                     {
     std::auto_ptr<TIterator> iterAll(allObjects.createIterator());
     std::auto_ptr<TIterator> iterVal(values.createIterator());
     for (RooAbsArg *v = (RooAbsArg *) iterVal->Next(); v != 0; v = (RooAbsArg *) iterVal->Next()) {
         if (typeid(*v) != typeid(RooRealVar)) continue;
         std::auto_ptr<TIterator> clientIter(v->clientIterator());
         for (RooAbsArg *a = (RooAbsArg *) clientIter->Next(); a != 0; a = (RooAbsArg *) clientIter->Next()) {
             if (allObjects.containsInstance(*a) && !clients.containsInstance(*a)) clients.add(*a);
         }
     }
 }

def utils.getNbins ( h )

Definition at line 92 of file utils.py.

Referenced by utils.Chi2.absval(), utils.BinToBin.do_test(), utils.BinToBin1percent.do_test(), and utils.StatisticalTest.get_rank().

 
 def getNbins(h):
   biny=h.GetNbinsY()
   if biny>1:biny+=1
   binz=h.GetNbinsZ()
   if binz>1:binz+=1
   return (h.GetNbinsX()+1)*(biny)*(binz)
 
 #-------------------------------------------------------------------------------
 

utils.getNbins

def getNbins

Definition: utils.py:92

void utils::guessChannelMode	(	RooSimultaneous &	simPdf,
		RooAbsData &	simData,
		bool	verbose = `false`
	)

Definition at line 376 of file utils.cc.

References gather_cfg::cout, i, n, and split.

Referenced by Combine::run().

 {
     RooAbsCategoryLValue &cat = const_cast<RooAbsCategoryLValue &>(simPdf.indexCat());
     TList *split = simData.split(cat, kTRUE);
     for (int i = 0, n = cat.numBins((const char *)0); i < n; ++i) {
         cat.setBin(i);
         RooAbsPdf *pdf = simPdf.getPdf(cat.getLabel());
         if (pdf->getAttribute("forceGenBinned") || pdf->getAttribute("forceGenUnbinned")) {
             if (verbose) std::cout << " - " << cat.getLabel() << " has generation mode already set" << std::endl;
             continue;
         }
         RooAbsData *spl = (RooAbsData *) split->FindObject(cat.getLabel());
         if (spl == 0) { 
             if (verbose) std::cout << " - " << cat.getLabel() << " has no dataset, cannot guess" << std::endl; 
             continue;
         }
         if (spl->numEntries() != spl->sumEntries()) {
             if (verbose) std::cout << " - " << cat.getLabel() << " has " << spl->numEntries() << " num entries of sum " << spl->sumEntries() << ", mark as binned" << std::endl;
             pdf->setAttribute("forceGenBinned");
         } else {
             if (verbose) std::cout << " - " << cat.getLabel() << " has " << spl->numEntries() << " num entries of sum " << spl->sumEntries() << ", mark as unbinned" << std::endl;
             pdf->setAttribute("forceGenUnbinned");
         }
     }
 }

def utils.is_empty ( h )

Definition at line 171 of file utils.py.

Referenced by DTSectColl.addTSTheta(), DEcompare< T >.get_ncand(), utils.StatisticalTest.get_rank(), and DEcompare< T >.SortCollections().

 
 def is_empty(h):
   for i in xrange(1,getNbins(h)):
     if h.GetBinContent(i)!=0: return False
   return True
   #return h.GetSumOfWeights()==0
 
 #-------------------------------------------------------------------------------

utils.is_empty

def is_empty

Definition: utils.py:171

utils.getNbins

def getNbins

Definition: utils.py:92

def utils.is_relvaldata ( files )

----------------------— Make files pairs -----------------------—

Definition at line 548 of file utils.py.

References any.

Referenced by make_files_pairs().

 
 def is_relvaldata(files):
     is_relvaldata_re = re.compile('_RelVal_')
     return any([is_relvaldata_re.search(filename) for filename in files])

any

Definition: Histograms.cc:34

utils.is_relvaldata

def is_relvaldata

----------------------— Make files pairs -----------------------—

Definition: utils.py:548

def utils.is_sparse ( h )

Definition at line 179 of file utils.py.

 
 def is_sparse(h):
   filled_bins=0.
   nbins=h.GetNbinsX()
   for ibin in xrange(nbins):
     if h.GetBinContent(ibin)>0:
       filled_bins+=1
   #print "%s %s --> %s" %(filled_bins,nbins,filled_bins/nbins)
   if filled_bins/nbins < .5:
     return True
   else:
     return False
 
 #-------------------------------------------------------------------------------

utils.is_sparse

def is_sparse

Definition: utils.py:179

def utils.literal2root	(	literal,
		rootType
	)

Definition at line 69 of file utils.py.

 
 def literal2root (literal,rootType):
   bitsarray = array.array('B')
   bitsarray.fromstring(literal.decode('hex'))
 
   tbuffer=0
   try:  
       tbuffer = TBufferFile(TBufferFile.kRead, len(bitsarray), bitsarray, False,0)
   except:
       print "could not transform to object array:"
       print [ i for i in  bitsarray ]
   
   # replace a couple of shortcuts with the real root class name
   if rootType == 'TPROF':
       rootType = 'TProfile'
   if rootType == 'TPROF2D':
       rootType = 'TProfile2D'
   
   root_class=eval(rootType+'.Class()')
   
   return tbuffer.ReadObject(root_class)
   
 #-------------------------------------------------------------------------------

utils.literal2root

def literal2root

Definition: utils.py:69

def utils.logger	(	msg_level,
		message
	)

Definition at line 47 of file utils.py.

Referenced by utils.StatisticalTest.get_rank(), and utils.StatisticalTest.get_status().

 
 def logger(msg_level,message):
   if msg_level>=_log_level:
     print "[%s] %s" %(asctime(),message)
 
#-------------------------------------------------------------------------------

utils.logger

def logger

Definition: utils.py:47

def utils.make_files_pairs	(	files,
		verbose = `True`
	)

Definition at line 552 of file utils.py.

References python.multivaluedict.append(), python.multivaluedict.dict, cmsRelvalreport.exit, is_relvaldata(), max(), and runtimedef.set().

Referenced by ValidationMatrix.get_filenames_from_pool().

 
 def make_files_pairs(files, verbose=True):
     ## Select functions to use
     if is_relvaldata(files):
         is_relval_data = True
         get_cmssw_version = get_relvaldata_cmssw_version
         get_id = get_relvaldata_id
         get_max_version = get_relvaldata_max_version
         # print 'Pairing Data RelVal files.'
     else:
         is_relval_data = False
         get_cmssw_version = get_relval_cmssw_version
         get_id = get_relval_id
         get_max_version = get_relval_max_version
         # print 'Pairing Monte Carlo RelVal files.'
 
     ## Divide files into groups
     versions_files = dict()
     for file in files:
         version = get_cmssw_version(file)
         if versions_files.has_key(version):
             versions_files[version].append(file)
         else:
             versions_files[version] = [file]
 
     ## Print the division into groups
     if verbose:
         print '\nFound versions:'
         for version in versions_files:
             print '%s: %d files' % (str(version),  len(versions_files[version]))
 
     if len(versions_files.keys()) <= 1:
         print '\nFound too little versions, there is nothing to pair. Exiting...\n'
         exit()
 
     ## Select two biggest groups.
     versions = versions_files.keys()
     sizes = [len(value) for value in versions_files.values()]
     v1 = versions[sizes.index(max(sizes))]
     versions.remove(v1)
     sizes.remove(max(sizes))
     v2 = versions[sizes.index(max(sizes))]
 
     ## Print two biggest groups.
     if verbose:
         print '\nPairing %s (%d files) and %s (%d files)' % (str(v1),
                 len(versions_files[v1]), str(v2), len(versions_files[v2]))
 
     ## Pairing two versions
     print '\nGot pairs:'
     pairs = []
     for unique_id in set([get_id(file) for file in versions_files[v1]]):
         if is_relval_data:
             dataset_re = re.compile(unique_id[0]+'_')
             run_re = re.compile(unique_id[1])
             c1_files = [file for file in versions_files[v1] if dataset_re.search(file) and run_re.search(file)]
             c2_files = [file for file in versions_files[v2] if dataset_re.search(file) and run_re.search(file)]
         else:
             dataset_re = re.compile(unique_id+'_')
             c1_files = [file for file in versions_files[v1] if dataset_re.search(file)]
             c2_files = [file for file in versions_files[v2] if dataset_re.search(file)]
 
         if len(c1_files) > 0 and len(c2_files) > 0:
             first_file = get_max_version(c1_files)
             second_file = get_max_version(c2_files)
             print '%s\n%s\n' % (first_file, second_file)
             pairs.extend((first_file, second_file))
     if verbose:
         print "Paired and got %d files.\n" % len(pairs)
     return pairs

RooAbsPdf * utils::makeNuisancePdf	(	RooStats::ModelConfig &	model,
		const char *	name = `"nuisancePdf"`
	)

Definition at line 200 of file utils.cc.

References mergeVDriftHistosByStation::name.

Referenced by asimovutils::asimovDatasetWithFit(), HybridNew::create(), BayesianToyMC::run(), ProfileLikelihood::run(), Combine::run(), and MaxLikelihoodFit::runSpecific().

                                                                               { 
     return utils::makeNuisancePdf(*model.GetPdf(), *model.GetObservables(), name);
 }

RooAbsPdf * utils::makeNuisancePdf	(	RooAbsPdf &	pdf,
		const RooArgSet &	observables,
		const char *	name = `"nuisancePdf"`
	)

Definition at line 204 of file utils.cc.

References createBeamHaloJobs::constraints, and factorizePdf().

                                                                                                 { 
     assert(&pdf);
     RooArgList obsTerms, constraints;
     factorizePdf(observables, pdf, obsTerms, constraints);
     if (constraints.getSize() == 0) return 0;
     return new RooProdPdf(name,"", constraints);
 }

RooAbsPdf * utils::makeObsOnlyPdf	(	RooStats::ModelConfig &	model,
		const char *	name = `"obsPdf"`
	)

Note: doesn't recompose Simultaneous pdfs properly, for that use factorizePdf method.

Definition at line 212 of file utils.cc.

References createBeamHaloJobs::constraints, and factorizePdf().

                                                                              { 
     RooArgList obsTerms, constraints;
     factorizePdf(model, *model.GetPdf(), obsTerms, constraints);
     return new RooProdPdf(name,"", obsTerms);
 }

std::vector< RooPlot * > utils::makePlots	(	const RooAbsPdf &	pdf,
		const RooAbsData &	data,
		const char *	signalSel = `0`,
		const char *	backgroundSel = `0`,
		float	rebinFactor = `1.0`
	)

make plots, if possible

Definition at line 403 of file utils.cc.

References createBeamHaloJobs::constraints, RecoTau_DiTaus_pt_20-420_cfg::datasets, factorizePdf(), pileupCalc::nbins, GetRecoTauVFromDQM_MC_cff::next, run_regression::ret, and x.

Referenced by MaxLikelihoodFit::runSpecific().

                                                                                                                                   {
     std::vector<RooPlot *> ret;
     RooArgList constraints;
     RooAbsPdf *facpdf = factorizePdf(*data.get(0), const_cast<RooAbsPdf &>(pdf), constraints);
 
     const std::type_info & id = typeid(*facpdf);
     if (id == typeid(RooSimultaneous) || id == typeid(RooSimultaneousOpt)) {
         const RooSimultaneous *sim  = dynamic_cast<const RooSimultaneous *>(&pdf);
         const RooAbsCategoryLValue &cat = (RooAbsCategoryLValue &) sim->indexCat();
         TList *datasets = data.split(cat, true);
         TIter next(datasets);
         for (RooAbsData *ds = (RooAbsData *) next(); ds != 0; ds = (RooAbsData *) next()) {
             RooAbsPdf *pdfi  = sim->getPdf(ds->GetName());
             std::auto_ptr<RooArgSet> obs(pdfi->getObservables(ds));
             if (obs->getSize() == 0) break;
             RooRealVar *x = dynamic_cast<RooRealVar *>(obs->first());
             if (x == 0) continue;
             int nbins = x->numBins(); if (nbins == 0) nbins = 100;
             if (nbins/rebinFactor > 6) nbins = ceil(nbins/rebinFactor);
             ret.push_back(x->frame(RooFit::Title(ds->GetName()), RooFit::Bins(nbins)));
             ret.back()->SetName(ds->GetName());
             ds->plotOn(ret.back());
             if (signalSel && strlen(signalSel))         pdfi->plotOn(ret.back(), RooFit::LineColor(209), RooFit::Components(signalSel));
             if (backgroundSel && strlen(backgroundSel)) pdfi->plotOn(ret.back(), RooFit::LineColor(206), RooFit::Components(backgroundSel));
             pdfi->plotOn(ret.back());
             delete ds;
         }
         delete datasets;
     } else if (pdf.canBeExtended()) {
         std::auto_ptr<RooArgSet> obs(pdf.getObservables(&data));
         RooRealVar *x = dynamic_cast<RooRealVar *>(obs->first());
         if (x != 0) {
             ret.push_back(x->frame());
             ret.back()->SetName("data");
             data.plotOn(ret.back());
             if (signalSel && strlen(signalSel))         pdf.plotOn(ret.back(), RooFit::LineColor(209), RooFit::Components(signalSel));
             if (backgroundSel && strlen(backgroundSel)) pdf.plotOn(ret.back(), RooFit::LineColor(206), RooFit::Components(backgroundSel));
             pdf.plotOn(ret.back());
         }
     }
     if (facpdf != &pdf) { delete facpdf; }
     return ret;
 
 }

void utils::printPdf ( RooAbsPdf * pdf )

Definition at line 61 of file utils.cc.

References gather_cfg::cout.

Referenced by Combine::run().

                                    {
   std::cout << "Pdf " << pdf->GetName() << " parameters." << std::endl;
   std::auto_ptr<RooArgSet> params(pdf->getVariables());
   params->Print("V");
 }

void utils::printPdf ( RooStats::ModelConfig & model )

Definition at line 68 of file utils.cc.

References gather_cfg::cout.

                                             {
   std::cout << "ModelConfig " << mc.GetName() << " (" << mc.GetTitle() << "): pdf parameters." << std::endl;
   std::auto_ptr<RooArgSet> params(mc.GetPdf()->getVariables());
   params->Print("V");
 }

void utils::printPdf	(	RooWorkspace *	w,
		const char *	pdfName
	)

Definition at line 74 of file utils.cc.

References gather_cfg::cout.

                                                          {
   std::cout << "PDF " << pdfName << " parameters." << std::endl;
   std::auto_ptr<RooArgSet> params(w->pdf(pdfName)->getVariables());
   params->Print("V");
 }

void utils::printRAD ( const RooAbsData * d )

Definition at line 56 of file utils.cc.

References printRDH().

Referenced by Combine::run().

                                         {
   if (d->InheritsFrom("RooDataHist") || d->numEntries() != 1) printRDH(const_cast<RooAbsData*>(d));
   else d->get(0)->Print("V");
 }

void utils::printRDH ( RooAbsData * data )

Definition at line 30 of file utils.cc.

References a, newFWLiteAna::bin, i, and j.

Referenced by GoodnessOfFit::makeSaturatedPdf(), and printRAD().

                                      {
   std::vector<std::string> varnames, catnames;
   const RooArgSet *b0 = data->get();
   TIterator *iter = b0->createIterator();
   for (RooAbsArg *a = 0; (a = (RooAbsArg *)iter->Next()) != 0; ) {
     if (a->InheritsFrom("RooRealVar")) {
       varnames.push_back(a->GetName());
     } else if (a->InheritsFrom("RooCategory")) {
       catnames.push_back(a->GetName());
     }
   }
   delete iter;
   size_t nv = varnames.size(), nc = catnames.size();
   printf(" bin  ");
   for (size_t j = 0; j < nv; ++j) { printf("%16.16s  ", varnames[j].c_str()); }
   for (size_t j = 0; j < nc; ++j) { printf("%16.16s  ", catnames[j].c_str()); }
   printf("  weight\n");
   for (int i = 0, nb = data->numEntries(); i < nb; ++i) {
     const RooArgSet *bin = data->get(i);
     printf("%4d  ",i);
     for (size_t j = 0; j < nv; ++j) { printf("%16g  ",    bin->getRealValue(varnames[j].c_str())); }
     for (size_t j = 0; j < nc; ++j) { printf("%16.16s  ", bin->getCatLabel(catnames[j].c_str())); }
     printf("%8.3f\n", data->weight());
   }
 }

def utils.profile2histo ( profile )

Definition at line 220 of file utils.py.

 
 def profile2histo(profile):
   if not profile.InheritsFrom("TH1"):
     return profile
     
   bin_low_edges=[]
   n_bins=profile.GetNbinsX()
   
   for ibin in xrange(1,n_bins+2):
     bin_low_edges.append(profile.GetBinLowEdge(ibin))
   bin_low_edges=array.array('f',bin_low_edges)
   histo=TH1F(profile.GetName(),profile.GetTitle(),n_bins,bin_low_edges)
   for ibin in xrange(0,n_bins+1):
     histo.SetBinContent(ibin,profile.GetBinContent(ibin))
     histo.SetBinError(ibin,profile.GetBinError(ibin))    
   
   return histo
 #-------------------------------------------------------------------------------

utils.profile2histo

def profile2histo

Definition: utils.py:220

RooSimultaneous * utils::rebuildSimPdf	(	const RooArgSet &	observables,
		RooSimultaneous *	pdf
	)

Definition at line 327 of file utils.cc.

References createBeamHaloJobs::constraints, copyAttributes(), factorizePdf(), pileupCalc::nbins, and run_regression::ret.

Referenced by Combine::run().

                                                                                          {
     RooArgList constraints;
     RooAbsCategoryLValue *cat = (RooAbsCategoryLValue *) sim->indexCat().Clone();
     int nbins = cat->numBins((const char *)0);
     TObjArray factorizedPdfs(nbins); 
     RooArgSet newOwned;
     for (int ic = 0, nc = nbins; ic < nc; ++ic) {
         cat->setBin(ic);
         RooAbsPdf *pdfi = sim->getPdf(cat->getLabel());
         if (pdfi == 0) { factorizedPdfs[ic] = 0; continue; }
         RooAbsPdf *newpdf = factorizePdf(observables, *pdfi, constraints);
         factorizedPdfs[ic] = newpdf;
         if (newpdf == 0) { continue; }
         if (newpdf != pdfi) { newOwned.add(*newpdf);  }
     }
     RooSimultaneous *ret = new RooSimultaneous(TString::Format("%s_reloaded", sim->GetName()), "", (RooAbsCategoryLValue&) sim->indexCat());
     for (int ic = 0, nc = nbins; ic < nc; ++ic) {
         cat->setBin(ic);
         RooAbsPdf *newpdf = (RooAbsPdf *) factorizedPdfs[ic];
         if (newpdf) {
             if (constraints.getSize() > 0) {
                 RooArgList allfactors(constraints); allfactors.add(*newpdf);
                 RooProdPdf *newerpdf = new RooProdPdf(TString::Format("%s_plus_constr", newpdf->GetName()), "", allfactors);
                 ret->addPdf(*newerpdf, cat->getLabel());
                 copyAttributes(*newpdf, *newerpdf);
                 newOwned.add(*newerpdf);
             } else {
                 ret->addPdf(*newpdf, cat->getLabel());
             }
         }
     }
     ret->addOwnedComponents(newOwned);
     copyAttributes(*sim, *ret);
     delete cat;
     return ret;
 }

bool utils::setAllConstant	(	const RooAbsCollection &	coll,
		bool	constant = `true`
	)

set all RooRealVars to constants. return true if at least one changed status

Definition at line 248 of file utils.cc.

References a, and v.

Referenced by Asymptotic::asimovDataset(), asimovutils::asimovDatasetWithFit(), HybridNew::create(), ProfiledLikelihoodTestStatOpt::Evaluate(), and Combine::run().

                                                                       {
     bool changed = false;
     std::auto_ptr<TIterator> iter(coll.createIterator());
     for (RooAbsArg *a = (RooAbsArg *) iter->Next(); a != 0; a = (RooAbsArg *) iter->Next()) {
         RooRealVar *v = dynamic_cast<RooRealVar *>(a);
         if (v && (v->isConstant() != constant)) {
             changed = true;
             v->setConstant(constant);
         }
     }
     return changed;
 }

def utils.setTDRStyle ( )

Definition at line 52 of file utils.py.

References combineCards.dirname, and plotscripts.tdrStyle.

Referenced by FlavourHistograms< T >.plot(), and TrackIPTagPlotter.psPlot().

 
 def setTDRStyle():  
   this_dir=dirname(this_module_name)
   this_dir_one_up=this_dir[:this_dir.rfind("/")+1]
   #this_dir_two_up=this_dir_one_up[:this_dir_one_up.rfind("/")+1]
   style_file=''
   if os.environ.has_key("RELMON_SA"):
     style_file=this_dir_one_up+"data/tdrstyle_mod.C"
   else:
     style_file="%s/src/Utilities/RelMon/data/tdrstyle_mod.C"%(os.environ["CMSSW_BASE"])
   try:
     gROOT.ProcessLine(".L %s" %style_file)
     gROOT.ProcessLine("setTDRStyle()")
   except:
     "Print could not set the TDR style. File %s not found?" %style_file
     
 
#-------------------------------------------------------------------------------

combineCards.dirname

tuple dirname

Definition: combineCards.py:36

utils.setTDRStyle

def setTDRStyle

Definition: utils.py:52

void utils::tdrStyle ( )

set style for plots

—> gStyle->SetStatFontSize(0.025);

Definition at line 4 of file tdrstyle.cc.

Referenced by MaxLikelihoodFit::runSpecific().

                      {
     gStyle->SetPadTopMargin(0.05);
     gStyle->SetPadBottomMargin(0.13);
     gStyle->SetPadLeftMargin(0.16);
     gStyle->SetPadRightMargin(0.04);
     gStyle->SetPalette(1);
     gStyle->SetHistMinimumZero(1);
     gStyle->SetCanvasBorderMode(0);
     gStyle->SetCanvasColor(kWhite);
     gStyle->SetPadBorderMode(0);
     gStyle->SetPadColor(kWhite);
     gStyle->SetFrameBorderMode(0);
     gStyle->SetFrameBorderSize(1);
     gStyle->SetFrameFillColor(0);
     gStyle->SetStatColor(kWhite);
     gStyle->SetTitleColor(1);
     gStyle->SetTitleFillColor(10);
 
     gStyle->SetOptTitle(0);
 
     gStyle->SetStatFont(42);
     gStyle->SetStatFontSize(0.04);
     gStyle->SetTitleColor(1, "XYZ");
     gStyle->SetTitleFont(42, "XYZ");
     gStyle->SetTitleSize(0.06, "XYZ");
     // gStyle->SetTitleXSize(Float_t size = 0.02); // Another way to set the size?
     // gStyle->SetTitleYSize(Float_t size = 0.02);
     gStyle->SetTitleXOffset(0.9);
     gStyle->SetTitleYOffset(1.25);
     // gStyle->SetTitleOffset(1.1, "Y"); // Another way to set the Offset
 
     // For the axis labels:
 
     gStyle->SetLabelColor(1, "XYZ");
     gStyle->SetLabelFont(42, "XYZ");
     gStyle->SetLabelOffset(0.007, "XYZ");
     gStyle->SetLabelSize(0.05, "XYZ");
 
     // For the axis:
     gStyle->SetAxisColor(1, "XYZ");
     gStyle->SetStripDecimals(kTRUE);
     gStyle->SetTickLength(0.03, "XYZ");
     gStyle->SetNdivisions(510, "XYZ");
     gStyle->SetPadTickX(1);  // To get tick marks on the opposite side of the frame
     gStyle->SetPadTickY(1);
 }

def utils.wget ( url )

Fetch the WHOLE file, not in bunches... To be optimised.

Definition at line 451 of file utils.py.

References SiPixelLorentzAngle_cfi.read.

 
 def wget(url):
   """ Fetch the WHOLE file, not in bunches... To be optimised.
   """
   opener=build_opener(X509CertOpen())  
   datareq = Request(url)
   datareq.add_header('authenticated_wget', "The ultimate wgetter")    
   bin_content=None
   try:
     filename=basename(url)  
     print "Checking existence of file %s on disk..."%filename
     if not isfile("./%s"%filename):      
       bin_content=opener.open(datareq).read()
     else:
       print "File %s exists, skipping.." %filename
   except ValueError:
     print "Error: Unknown url %s" %url
   
   if bin_content!=None:  
     ofile = open(filename, 'wb')
     ofile.write(bin_content)
     ofile.close()
 
#-------------------------------------------------------------------------------

authentication.X509CertOpen

Definition: authentication.py:72

utils.wget

def wget

Definition: utils.py:451

SiPixelLorentzAngle_cfi.read

tuple read

Definition: SiPixelLorentzAngle_cfi.py:7

Classes

Functions

Variables

Function Documentation

Variable Documentation