#include <Exercises3.h>

Public Member Functions
void	calibrateCalibratables (TChain &sourceTree, const std::string &exercisefile)

void	evaluateCalibrator (SpaceManagerPtr s, CalibratorPtr c, TTree &tree, Calibratable *calibrated, DetectorElementPtr ecal, DetectorElementPtr hcal, DetectorElementPtr offset, CalibrationProvenance cp, CalibrationProvenance cpCorr=NONE)

void	evaluateSpaceManager (SpaceManagerPtr s, const std::vector< DetectorElementPtr > &detEls)

	Exercises3 (IO *options)

void	getCalibrations (SpaceManagerPtr s)

void	setTarget (CalibrationTarget t)

virtual	~Exercises3 ()

Private Member Functions
	Exercises3 (const Exercises3 &)

void	operator= (const Exercises3 &)

Private Attributes
std::ofstream	calibResultsFile_

PFClusterCalibration	clusterCalibration_

unsigned	debug_

std::vector< DetectorElementPtr >	elements_

IO *	options_

CalibrationTarget	target_

unsigned	threshold_

bool	withOffset_

Detailed Description

Definition at line 22 of file Exercises3.h.

Constructor & Destructor Documentation

Exercises3::Exercises3 ( IO * options )

Definition at line 33 of file Exercises3.cc.

                                   :
     withOffset_(false), target_(CLUSTER), threshold_(30), options_(options),
             debug_(0) {
 
     options_->GetOpt("exercises", "withOffset", withOffset_);
     options_->GetOpt("exercises", "threshold", threshold_);
     options_->GetOpt("exercises", "debug", debug_);
 
     /* Initialise PFClusterCalibration appropriately. */
     double g0, g1, e0, e1;
     options_->GetOpt("correction", "globalP0", g0);
     options_->GetOpt("correction", "globalP1", g1);
     options_->GetOpt("correction", "lowEP0", e0);
     options_->GetOpt("correction", "lowEP1", e1);
     clusterCalibration_.setCorrections(e0, e1, g0, g1);
 
     double ecalECut, hcalECut;
     options_->GetOpt("evolution", "ecalECut", ecalECut);
     options_->GetOpt("evolution", "hcalECut", hcalECut);
     clusterCalibration_.setEcalHcalEnergyCuts(ecalECut, hcalECut);
 
     int allowNegative(0);
     options_->GetOpt("correction", "allowNegativeEnergy", allowNegative);
     clusterCalibration_.setAllowNegativeEnergy(allowNegative);
 
     int doCorrection(1);
     options_->GetOpt("correction", "doCorrection", doCorrection);
     clusterCalibration_.setDoCorrection(doCorrection);
 
     int doEtaCorrection(0);
     options_->GetOpt("correction", "doEtaCorrection", doEtaCorrection);
     clusterCalibration_.setDoEtaCorrection(doEtaCorrection);
 
     double barrelEta;
     options_->GetOpt("evolution", "barrelEndcapEtaDiv", barrelEta);
     clusterCalibration_.setBarrelBoundary(barrelEta);
 
     double maxEToCorrect(100.0);
     options_->GetOpt("correction", "maxEToCorrect", maxEToCorrect);
     clusterCalibration_.setMaxEToCorrect(maxEToCorrect);
 
     std::vector<std::string>* names = clusterCalibration_.getKnownSectorNames();
     for (std::vector<std::string>::iterator i = names->begin(); i
             != names->end(); ++i) {
         std::string sector = *i;
         std::vector<double> params;
         options_->GetOpt("evolution", sector.c_str(), params);
         clusterCalibration_.setEvolutionParameters(sector, params);
     }
 
     std::vector<double> etaParams;
     options_->GetOpt("evolution", "etaCorrection", etaParams);
     clusterCalibration_.setEtaCorrectionParameters(etaParams);
 
     std::cout << clusterCalibration_ << "\n";
 
     std::string outputFileName;
     options_->GetOpt("results", "calibParamOutput", outputFileName);
     calibResultsFile_.open(outputFileName.c_str());
     calibResultsFile_ << "//Hello from your friendly PFClusterTools!\n";
     if (debug_ > 0)
         std::cout << __PRETTY_FUNCTION__ << ": finished.\n";
 
 }

Exercises3::~Exercises3 ( )

virtual

Definition at line 29 of file Exercises3.cc.

References calibResultsFile_.

                         {
     calibResultsFile_.close();
 }

pftools::Exercises3::Exercises3 ( const Exercises3 & )

private

Member Function Documentation

void Exercises3::calibrateCalibratables	(	TChain &	sourceTree,
		const std::string &	exercisefile
	)

Definition at line 98 of file Exercises3.cc.

References EnergyCorrector::c, pftools::TreeUtility::convertCalibratablesToParticleDeposits(), gather_cfg::cout, debug_, pftools::ECAL, patCandidatesForDimuonsSequences_cff::ecal, elements_, evaluateCalibrator(), evaluateSpaceManager(), pftools::TreeUtility::getCalibratablesFromRootFile(), getCalibrations(), pftools::IO::GetOpt(), pftools::HCAL, patCandidatesForDimuonsSequences_cff::hcal, pftools::LINEAR, pftools::LINEARCORR, pftools::OFFSET, HLT_25ns14e33_v1_cff::offset, options_, resetElement3(), target_, MainPageGenerator::tree, and withOffset_.

                                        {
 
     if (debug_ > 0) {
         std::cout << "Welcome to "<< __PRETTY_FUNCTION__ << "\n";
         std::cout << "Opening TTree...\n";
     }
 //  //open tfile
 //  TFile* source = new TFile(sourcefile.c_str());
 //  if (source == 0) {
 //      std::string desc("Couldn't open file ");
 //      desc += sourcefile;
 //      PFToolsException e(desc);
 //      throw e;
 //  }
 //  if (debug_ > 0)
 //      std::cout << "Extracting calibratables...\n";
     //use tree utility to extract calibratables
     TreeUtility tu;
     std::vector<Calibratable> calibVec;
 
     tu.getCalibratablesFromRootFile(sourceTree, calibVec);
     if (debug_ > 0)
         std::cout << "Got a vector of calibratables of size "<< calibVec.size()
                 << "\n";
     //initialise detector elements
     DetectorElementPtr ecal(new DetectorElement(ECAL, 1.0));
     DetectorElementPtr hcal(new DetectorElement(HCAL, 1.0));
     DetectorElementPtr offset(new DetectorElement(OFFSET, 1.0));
 
     //convert calibratables to particle deposits
     std::vector<ParticleDepositPtr> pdVec;
     tu.convertCalibratablesToParticleDeposits(calibVec, pdVec, target_, offset,
             ecal, hcal, withOffset_);
     //source->Close();
 
     TFile* exercises = new TFile(exercisefile.c_str(), "recreate");
     TH1F droppedParticles("droppedParticles", "droppedParticles", 100000, 0,
             100000);
     if (debug_ > 0)
         std::cout << "Particle deposit vec has "<< pdVec.size() << " entries\n";
 
     //calibrate
     if (debug_ > 1)
         std::cout << "Creating calibrator clones and space managers\n";
     boost::shared_ptr<Calibrator> linCal(new LinearCalibrator());
 
     //Tell the calibrator which detector elements should be calibrated
     if (withOffset_) {
         linCal->addDetectorElement(offset);
 
     }
     linCal->addDetectorElement(ecal);
     linCal->addDetectorElement(hcal);
 
     double barrelEta;
     options_->GetOpt("evolution", "barrelEndcapEtaDiv", barrelEta);
     boost::shared_ptr<SpaceManager> sm(new SpaceManager("ecalAndHcal"));
     sm->setBarrelLimit(barrelEta);
     sm->createCalibrators(*linCal);
 
     if (debug_ > 1)
         std::cout << "Initialised SpaceManager and calibrators.\n";
     elements_.clear();
     if (withOffset_)
         elements_.push_back(offset);
     elements_.push_back(ecal);
     elements_.push_back(hcal);
 
     //Initialise calibrators with particles
     int dropped(0);
 
     double eCut(0.0);
     double hCut(0.0);
     options_->GetOpt("evolution", "ecalECut", eCut);
     options_->GetOpt("evolution", "hcalECut", hCut);
     if (debug_ > 0)
         std::cout << "Using a ECAL and HCAL energy cuts of "<< eCut << " and "
                 << hCut << " GeV\n";
     if (debug_ > 1)
         std::cout << "Assigning particles to space managers and calibrators.\n";
 
     //This is just a convenience plot to check on the hcal
     for (std::vector<ParticleDepositPtr>::const_iterator cit = pdVec.begin(); cit
             != pdVec.end(); ++cit) {
         ParticleDepositPtr pd = *cit;
         CalibratorPtr c = sm->findCalibrator(pd->getEta(), pd->getPhi(),
                 pd->getTruthEnergy());
         //std::cout << *pd << "\n";
         if (c == 0) {
             std::cout << "Couldn't find calibrator for particle?!\n";
             std::cout << "\t"<< *pd << "\n";
 
             dropped++;
         } else {
             c->addParticleDeposit(pd);
         }
 
     }
 
     if (debug_ > 1)
         std::cout << "Dropped "<< dropped << " particles.\n";
 
     /* Done assignments, now calibrate */
     if (debug_ > 1)
         std::cout
                 << "Assignments complete, starting calibration and analysis.\n";
 
     //calibrate
     std::map<SpaceVoxelPtr, CalibratorPtr> * smCalibrators =
             sm->getCalibrators();
 
     TTree tree("CalibratedParticles", "");
     Calibratable* calibrated = new Calibratable();
     tree.Branch("Calibratable", "pftools::Calibratable", &calibrated, 32000, 2);
     if (debug_ > 1)
         std::cout << "Initialised tree.\n";
 
     /* ECAL and HCAL */
     std::cout << "*** Performance for ECAL + HCAL calibration ***\n";
     getCalibrations(sm);
     exercises->cd("/");
     exercises->mkdir("ecalAndHcal");
     exercises->cd("/ecalAndHcal");
     evaluateSpaceManager(sm, elements_);
     for (std::map<SpaceVoxelPtr, CalibratorPtr>::iterator it =
             smCalibrators->begin(); it != smCalibrators->end(); ++it) {
         SpaceVoxelPtr sv = (*it).first;
         CalibratorPtr c = (*it).second;
         std::for_each(elements_.begin(), elements_.end(), resetElement3);
         evaluateCalibrator(sm, c, tree, calibrated, ecal, hcal, offset, LINEAR,
                 LINEARCORR);
 
         std::for_each(elements_.begin(), elements_.end(), resetElement3);
     }
     sm->printCalibrations(std::cout);
 
     exercises->cd("/");
 
     //save results
     std::cout << "Writing output tree...\n";
     tree.Write();
     droppedParticles.Write();
     //gaussianFits(*exercises, calibVec);
     exercises->Write();
     exercises->Close();
     std::cout << "Done."<< std::endl;
 
 }

void Exercises3::evaluateCalibrator	(	SpaceManagerPtr	s,
		CalibratorPtr	c,
		TTree &	tree,
		Calibratable *	calibrated,
		DetectorElementPtr	ecal,
		DetectorElementPtr	hcal,
		DetectorElementPtr	offset,
		CalibrationProvenance	cp,
		CalibrationProvenance	cpCorr = `NONE`
	)

Definition at line 393 of file Exercises3.cc.

Referenced by calibrateCalibratables().

                                                                 {
 
     if (c->hasParticles() > static_cast<int>(threshold_)) {
         std::map<DetectorElementPtr, double> calibs = s->getCalibration(c);
 
         std::vector<ParticleDepositPtr> csParticles = c->getParticles();
         unsigned count(0);
         int mode(0);
         options_->GetOpt("spaceManager", "interpolationMode", mode);
         if (debug_ > 1) {
             std::cout << "Using interpolation mode " << mode << "\n";
         }
 
         for (std::vector<ParticleDepositPtr>::iterator zit = csParticles.begin(); zit
                 != csParticles.end(); ++zit) {
             ParticleDepositPtr pd = *zit;
             calibrated->reset();
             calibrated->rechits_meanEcal_.energy_ = pd->getRecEnergy(ecal);
             calibrated->rechits_meanHcal_.energy_ = pd->getRecEnergy(hcal);
             calibrated->sim_energyEvent_ = pd->getTruthEnergy();
             calibrated->sim_etaEcal_ = pd->getEta();
 
             for (std::map<DetectorElementPtr, double>::iterator deit =
                     calibs.begin(); deit != calibs.end(); ++deit) {
                 DetectorElementPtr de = (*deit).first;
                 de->setCalib(1.0);
             }
 
             CalibrationResultWrapper crwPre;
             crwPre.ecalEnergy_ = pd->getRecEnergy(ecal);
             crwPre.hcalEnergy_ = pd->getRecEnergy(hcal);
             crwPre.particleEnergy_ = pd->getRecEnergy();
             crwPre.truthEnergy_ = pd->getTruthEnergy();
             crwPre.provenance_ = UNCALIBRATED;
             crwPre.targetFuncContrib_ = pd->getTargetFunctionContrib();
             crwPre.target_ = target_;
             crwPre.compute();
             calibrated->calibrations_.push_back(crwPre);
 
             double tempEnergy = pd->getRecEnergy();
             //evaluate calibration
             for (std::map<DetectorElementPtr, double>::iterator deit =
                     calibs.begin(); deit != calibs.end(); ++deit) {
                 DetectorElementPtr de = (*deit).first;
 
                 if (mode == 1)
                     de->setCalib(s->interpolateCoefficient(de,
                             pd->getTruthEnergy(), pd->getEta(), pd->getPhi()));
                 else if (mode == 2|| mode == 3|| mode == 4)
                     de->setCalib(s->evolveCoefficient(de, tempEnergy,
                             pd->getEta(), pd->getPhi()));
                 else
                     de->setCalib((*deit).second);
             }
             if (debug_ > 8) {
                 std::cout << "POST ECAL HCAL coeff: " << ecal->getCalib() << ", " << hcal->getCalib() << "\n";
             }
 
             CalibrationResultWrapper crwPos;
             crwPos.ecalEnergy_ = pd->getRecEnergy(ecal);
             crwPos.hcalEnergy_ = pd->getRecEnergy(hcal);
             crwPos.b_ = ecal->getCalib();
             crwPos.c_ = hcal->getCalib();
             crwPos.particleEnergy_ = pd->getRecEnergy();
             crwPos.truthEnergy_ = pd->getTruthEnergy();
             crwPos.provenance_ = cp;
             crwPos.compute();
 
             crwPos.targetFuncContrib_ = pd->getTargetFunctionContrib();
             crwPos.target_ = target_;
             calibrated->calibrations_.push_back(crwPos);
 
             //same again, but applying correction
             if (cpCorr != NONE) {
                 CalibrationResultWrapper crwCorr;
 
                 crwCorr.ecalEnergy_
                         = clusterCalibration_.getCalibratedEcalEnergy(
                                 crwPre.ecalEnergy_, crwPre.hcalEnergy_,
                                 pd->getEta(), pd->getPhi());
                 crwCorr.hcalEnergy_
                         = clusterCalibration_.getCalibratedHcalEnergy(
                                 crwPre.ecalEnergy_, crwPre.hcalEnergy_,
                                 pd->getEta(), pd->getPhi());
                 if (debug_ > 8) {
                     if(crwPre.ecalEnergy_  > 0 && crwPre.hcalEnergy_ >0)
                     std::cout << "CORR ECAL HCAL coeff: " << crwCorr.ecalEnergy_ / crwPre.ecalEnergy_  << ", " << crwCorr.hcalEnergy_/ crwPre.hcalEnergy_ << "\n\n";
                 }
 
                 crwCorr.particleEnergy_
                         = clusterCalibration_.getCalibratedEnergy(
                                 crwPre.ecalEnergy_, crwPre.hcalEnergy_,
                                 pd->getEta(), pd->getPhi());
 
                 crwCorr.b_ = ecal->getCalib();
                 crwCorr.c_ = hcal->getCalib();
 
                 crwCorr.truthEnergy_ = pd->getTruthEnergy();
                 crwCorr.provenance_ = cpCorr;
                 crwCorr.targetFuncContrib_ = pd->getTargetFunctionContrib();
                 crwCorr.target_ = target_;
                 crwCorr.compute();
                 calibrated->calibrations_.push_back(crwCorr);
 
                 crwPos.targetFuncContrib_ = pd->getTargetFunctionContrib();
                 crwPos.target_ = target_;
                 calibrated->calibrations_.push_back(crwPos);
             }
             tree.Fill();
             ++count;
 
         }
     }
 }

void Exercises3::evaluateSpaceManager	(	SpaceManagerPtr	s,
		const std::vector< DetectorElementPtr > &	detEls
	)

Definition at line 264 of file Exercises3.cc.

References assert(), pftools::BARREL_POS, prof2calltree::count, gather_cfg::cout, debug_, pftools::DetElNames, pftools::ECAL, pftools::ENDCAP_POS, pftools::IO::GetOpt(), pftools::HCAL, i, alignBH_cfg::mode, mergeVDriftHistosByStation::name, options_, pftools::RegionNames, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by calibrateCalibratables().

                                                      {
 
     int autoFit(0);
     options_->GetOpt("evolution", "autoFit", autoFit);
     std::cout << "AutoFit option = "<< autoFit << "\n";
 
     std::vector<double> ecalBarrel;
     std::vector<double> ecalEndcap;
     std::vector<double> hcalBarrel;
     std::vector<double> hcalEndcap;
 
     double minE, maxE;
     options_->GetOpt("evolution", "evolutionFunctionMinE", minE);
     options_->GetOpt("evolution", "evolutionFunctionMaxE", maxE);
 
     int basePlots(0);
     options_->GetOpt("evolution", "basePlots", basePlots);
 
     int useTruth(1);
     options_->GetOpt("evolution", "basePlotsUseTruth", useTruth);
 
     if (debug_ > 1&& basePlots > 0)
         std::cout << "Option to generate evolution plots invoked.\n";
 
     if (autoFit == 0) {
         std::cout << "Fixing parameters for evolution functions.\n";
 
         options_->GetOpt("evolution", "ecalHcalEcalBarrel", ecalBarrel);
         options_->GetOpt("evolution", "ecalHcalEcalEndcap", ecalEndcap);
         options_->GetOpt("evolution", "ecalHcalHcalBarrel", hcalBarrel);
         options_->GetOpt("evolution", "ecalHcalHcalEndcap", hcalEndcap);
         assert(ecalBarrel.size() == 6 && ecalEndcap.size() == 6);
         assert(hcalBarrel.size() == 6 && hcalEndcap.size() == 6);
 
         for (std::vector<DetectorElementPtr>::const_iterator i = detEls.begin(); i
                 != detEls.end(); ++i) {
             DetectorElementPtr d = *i;
             std::cout << "Fixing evolution for "<< *d << "\n";
             int mode(0);
             options_->GetOpt("spaceManager", "interpolationMode", mode);
 
             std::string name("Func_");
             name.append(DetElNames[d->getType()]);
             name.append("_");
 
             /* Fitting for barrel */
             std::string barrelName(name);
             barrelName.append(RegionNames[BARREL_POS]);
             std::cout << "\tFixing "<< RegionNames[BARREL_POS]<< "\n";
             TF1
                     fBarrel(barrelName.c_str(),
                             "([0]*[5]*x)*([5]*x<[1])+([2]+[3]*exp([4]*[5]*x))*([5]*x>[1])");
 
             if (d->getType() == ECAL) {
                 unsigned count(0);
                 for (std::vector<double>::const_iterator dit =
                         ecalBarrel.begin(); dit!= ecalBarrel.end(); ++dit) {
                     fBarrel.FixParameter(count, *dit);
                     ++count;
                 }
 
             }
             if (d->getType() == HCAL) {
                 unsigned count(0);
                 for (std::vector<double>::const_iterator dit =
                         hcalBarrel.begin(); dit!= hcalBarrel.end(); ++dit) {
                     fBarrel.FixParameter(count, *dit);
                     ++count;
                 }
 
             }
             if (useTruth)
                 fBarrel.FixParameter(5, 1.0);
 
             fBarrel.SetMinimum(0);
             s->addEvolution(d, BARREL_POS, fBarrel);
 
             if (basePlots > 0) {
                 TH1* slices = s->extractEvolution(d, BARREL_POS, fBarrel,
                         useTruth);
                 slices->Write();
             }
             fBarrel.Write();
 
             /* Fitting for endcap */
             std::string endcapName(name);
             endcapName.append(RegionNames[ENDCAP_POS]);
             std::cout << "\tFixing "<< RegionNames[ENDCAP_POS]<< "\n";
             TF1
                     fEndcap(endcapName.c_str(),
                             "([0]*[5]*x)*([5]*x<[1])+([2]+[3]*exp([4]*[5]*x))*([5]*x>[1])");
             
 
             if (d->getType() == ECAL) {
                 unsigned count(0);
                 for (std::vector<double>::const_iterator dit =
                         ecalEndcap.begin(); dit!= ecalEndcap.end(); ++dit) {
                     fEndcap.FixParameter(count, *dit);
                     ++count;
                 }
 
             }
             if (d->getType() == HCAL) {
                 unsigned count(0);
                 for (std::vector<double>::const_iterator dit =
                         hcalEndcap.begin(); dit!= hcalEndcap.end(); ++dit) {
                     fEndcap.FixParameter(count, *dit);
                     ++count;
                 }
 
             }
             if (useTruth)
                 fEndcap.FixParameter(5, 1.0);
 
             fEndcap.SetMinimum(0);
             s->addEvolution(d, ENDCAP_POS, fEndcap);
             if (basePlots > 0) {
                 TH1* slices = s->extractEvolution(d, ENDCAP_POS, fEndcap,
                         useTruth);
                 slices->Write();
             }
             fEndcap.Write();
         }
 
     }
 
 }

void Exercises3::getCalibrations ( SpaceManagerPtr s )

Definition at line 248 of file Exercises3.cc.

References EnergyCorrector::c, elements_, resetElement3(), and threshold_.

Referenced by calibrateCalibratables().

                                                   {
 
     std::map<SpaceVoxelPtr, CalibratorPtr>* smCalibrators = s->getCalibrators();
 
     for (std::map<SpaceVoxelPtr, CalibratorPtr>::iterator it =
             smCalibrators->begin(); it != smCalibrators->end(); ++it) {
         CalibratorPtr c= (*it).second;
         std::for_each(elements_.begin(), elements_.end(), resetElement3);
         if (c->hasParticles() > static_cast<int>(threshold_)) {
             std::map<DetectorElementPtr, double> calibs =
                     c->getCalibrationCoefficients();
             s->assignCalibration(c, calibs);
         }
     }
 }

void pftools::Exercises3::operator= ( const Exercises3 & )

private

void pftools::Exercises3::setTarget ( CalibrationTarget t )

inline

Definition at line 42 of file Exercises3.h.

References edmStreamStallGrapher::t, and target_.

                                         {
         target_ = t;
     }

Member Data Documentation

std::ofstream pftools::Exercises3::calibResultsFile_

private

Definition at line 60 of file Exercises3.h.

Referenced by Exercises3(), and ~Exercises3().

PFClusterCalibration pftools::Exercises3::clusterCalibration_

private

Definition at line 62 of file Exercises3.h.

Referenced by evaluateCalibrator(), and Exercises3().

unsigned pftools::Exercises3::debug_

private

Definition at line 61 of file Exercises3.h.

Referenced by calibrateCalibratables(), evaluateCalibrator(), evaluateSpaceManager(), and Exercises3().

std::vector<DetectorElementPtr> pftools::Exercises3::elements_

private

Definition at line 58 of file Exercises3.h.

Referenced by calibrateCalibratables(), and getCalibrations().

IO* pftools::Exercises3::options_

private

Definition at line 59 of file Exercises3.h.

Referenced by calibrateCalibratables(), evaluateCalibrator(), evaluateSpaceManager(), Exercises3(), valtools.webpage::parseArgs(), and batchmanager.BatchManager::ParseOptions().

CalibrationTarget pftools::Exercises3::target_

private

Definition at line 56 of file Exercises3.h.

Referenced by calibrateCalibratables(), evaluateCalibrator(), and setTarget().

unsigned pftools::Exercises3::threshold_

private

Definition at line 57 of file Exercises3.h.

Referenced by evaluateCalibrator(), Exercises3(), and getCalibrations().

bool pftools::Exercises3::withOffset_

private

Definition at line 55 of file Exercises3.h.

Referenced by calibrateCalibratables(), and Exercises3().

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation