diff --git a/inc/LauFlavTag.hh b/inc/LauFlavTag.hh index e334932..b849fd5 100644 --- a/inc/LauFlavTag.hh +++ b/inc/LauFlavTag.hh @@ -1,239 +1,237 @@ /* Copyright 2017 University of Warwick Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ /* Laura++ package authors: John Back Paul Harrison Thomas Latham */ /*! \file LauFlavTag.hh \brief File containing declaration of LauFlavTag class. */ /*! \class LauFlavTag \brief Class for defining the flavour tagging approach. Define the flavour tagging categories and all associated parameters to be passed to the relevant fit models. */ #ifndef LAU_FLAVTAG #define LAU_FLAVTAG #include #include #include #include #include "TString.h" #include "TStopwatch.h" #include "TSystem.h" #include "LauConstants.hh" #include "LauParameter.hh" #include "LauFitDataTree.hh" #include "LauAbsFitModel.hh" #include "LauDecayTimePdf.hh" #include "LauAbsPdf.hh" class LauFlavTag { public: //! Constructor LauFlavTag();//, const TString& tagVarName = "tagFlv", const TString& tagCatVarName = "tagCat"); //! Destructor virtual ~LauFlavTag(); void initialise(); //! Change the dilutions, delta dilutions and tagCatFrac for signal if needed /*! \param [in] name the name of the tagger \param [in] tagVarName the tagging variable name of the tagger in the ntuple \param [in] mistagVarName the associated mistag variable name of the same tagger in the ntuple \param [in] etapdf the mistag distribution for the tagger \param [in] tagEff_b0 tagging efficiency for particle decays \param [in] calib_p0_b0 the calibration parameter p0 for particle decays \param [in] calib_p1_b0 the calibration parameter p1 for particle decays \param [in] tagEff_b0bar tagging efficiency for anti-particle decays - leave blank to share particle parameter \param [in] calib_p0_b0bar the calibration parameter p0 for anti-particle decays - leave blank to share particle parameter \param [in] calib_p1_b0bar the calibration parameter p1 for anti-particle decays - leave blank to share particle parameter */ // Need to set remember the position in the vector using a map for later reference void addTagger(const TString name, const TString tagVarName, const TString mistagVarName, LauAbsPdf* etapdf, const Double_t tagEff_b0=1.0, const Double_t calib_p0_b0=1.0, const Double_t calib_p1_b0=1.0, const Double_t tagEff_b0bar=-1.0, const Double_t calib_p0_b0bar=-1.0, const Double_t calib_p1_b0bar=-1.0); //! Set up alternative calibration parameters if requested void useAveDeltaPars(Int_t position); //! Read in the input fit data variables, e.g. m13Sq and m23Sq void cacheInputFitVars(LauFitDataTree* inputFitData); void updateEventInfo(UInt_t iEvt); typedef std::map< Int_t, LauParameter> LauTagCatParamMap; const std::vector getTagVarNames(){return tagVarName_;}; const std::vector getMistagVarNames(){return mistagVarName_;}; const TString& getTrueTagVarName(){return trueTagVarName_;}; Int_t getCurEvtTrueTagFlv(){return curEvtTrueTagFlv_;}; std::vector getCurEvtTagFlv(){return curEvtTagFlv_;}; std::vector getCurEvtMistag(){return curEvtMistag_;}; std::vector getCurEvtMistagPrime(){return curEvtMistagPrime_;}; Int_t getNTaggers(){return tagVarName_.size();} //! Get map of calibration parameters for each tagging category std::vector getCalibP0B0(){return calib_p0_B0_;}; std::vector getCalibP0B0bar(){return calib_p0_B0bar_;}; std::vector getCalibP1B0(){return calib_p1_B0_;}; std::vector getCalibP1B0bar(){return calib_p1_B0bar_;}; //! Get map of alternative calibration parameters for each tagging category std::vector getCalibP0Ave(){return calib_p0_ave_;}; std::vector getCalibP0Delta(){return calib_p0_delta_;}; std::vector getCalibP1Ave(){return calib_p1_ave_;}; std::vector getCalibP1Delta(){return calib_p1_delta_;}; //! Get map of alternative calibration parameters for each tagging category std::vector getTagEffAve(){return tagEff_ave_;}; std::vector getTagEffDelta(){return tagEff_delta_;}; std::vector getTagEffB0(){return tagEff_B0_;}; std::vector getTagEffB0bar(){return tagEff_B0bar_;}; std::vector< Double_t> getPerEvtAvgMistag() const {return perEvtAvgMistag_;}; std::vector< Double_t> getPerEvtAvgMistagPrime() const {return perEvtAvgMistagPrime_;}; Double_t getOmega(const Int_t position, const Int_t flag);// const; Double_t getCapitalOmega(const Int_t position, const Int_t flag);// const; - Double_t getOmegaGen(const Int_t position, const Double_t eta, const Int_t flag);// const; - Double_t getCapitalOmegaGen(const Int_t position, const Double_t etaprime, const Int_t curEvtTagFlv, const Int_t flag);// const; Double_t getEtaGen(Int_t position) const; Double_t getEtaPrimeGen(Int_t position) const; //! Use the alternative tagging calibration parameters void useAveDelta(){useAveDelta_ = kTRUE;}; //! Use the alternative tagging efficiency parameters void useAveTagEffDeltaTagEff(){useAveTagEffDeltaTagEff_ = kTRUE;}; //! Return the Boolean controlling if we use the alternative tagging calibration parameters Bool_t getUseAveDelta(){return useAveDelta_;}; //! Return the Boolean controlling if we use the alternative tagging calibration parameters Bool_t getUseAveTagEffDeltaTagEff(){return useAveTagEffDeltaTagEff_;}; void setTrueTagVarName(TString trueTagVarName); protected: //! Check that the background tagging category fractions are all present and sum to unity /*! \param [in] theMap the container of tagcat fractions */ Bool_t checkTagCatFracMap(const LauTagCatParamMap& theMap) const; //! Calculates the fraction of the first tagging category based on the others /*! \param [in] theMap the container of tagcat fractions */ void setFirstTagCatFrac(LauTagCatParamMap& theMap); private: //! Map to link taggers to their vector position std::map taggerPosition_; //! Flavour tagging variable name std::vector tagVarName_; //! Per event mistag variable name std::vector mistagVarName_; //! True tag variable name for normalisation decays TString trueTagVarName_; //! Vector of flavour tags for each event std::vector< std::vector > evtTagFlv_; //! Flavour tag for current event std::vector curEvtTagFlv_; //! Vector of mistags for each event std::vector< std::vector > evtMistag_; //! Vector of transformed mistags for each event std::vector< std::vector > evtMistagPrime_; //! Per event mistag for current event std::vector curEvtMistag_; //! Per event transformed mistag for current event std::vector curEvtMistagPrime_; //! Vector of true tags for each event std::vector< Int_t > evtTrueTagFlv_; //! True tag from normalisation mode for current event Int_t curEvtTrueTagFlv_; //! Use per event mistag Bool_t usePerEvtMistag_; //! Per-event average mistag value (eta hat) std::vector perEvtAvgMistag_; //! Per-event average transformed mistag value (eta prime hat) std::vector perEvtAvgMistagPrime_; //! Calibration parameters std::vector calib_p0_B0_; std::vector calib_p0_B0bar_; std::vector calib_p1_B0_; std::vector calib_p1_B0bar_; //! Alternative calibration parameters std::vector calib_p0_ave_; std::vector calib_p0_delta_; std::vector calib_p1_ave_; std::vector calib_p1_delta_; //! Flag to use alternative calibration parameters Bool_t useAveDelta_; //! Flag to use alternative tagging efficiency parameters Bool_t useAveTagEffDeltaTagEff_; //! Tagging efficiency parameters std::vector tagEff_B0_; std::vector tagEff_B0bar_; std::vector tagEff_ave_; std::vector tagEff_delta_; //! Eta PDFs std::vector etaPdfs_; //! Eta Prime PDFs std::vector etaPrimePdfs_; ClassDef(LauFlavTag,0) // Flavour tagging set up }; #endif diff --git a/src/LauFlavTag.cc b/src/LauFlavTag.cc index 02b4461..0fce102 100644 --- a/src/LauFlavTag.cc +++ b/src/LauFlavTag.cc @@ -1,493 +1,421 @@ /* Copyright 2017 University of Warwick Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ /* Laura++ package authors: John Back Paul Harrison Thomas Latham */ /*! \file LauFlavTag.cc \brief File containing implementation of LauFlavTag class. */ #include #include #include #include #include #include "TFile.h" #include "TMinuit.h" #include "TRandom.h" #include "TSystem.h" #include "TVirtualFitter.h" #include "TH1D.h" #include "LauAbsBkgndDPModel.hh" #include "LauAbsCoeffSet.hh" #include "LauAbsPdf.hh" #include "LauAsymmCalc.hh" #include "LauComplex.hh" #include "LauConstants.hh" #include "LauDPPartialIntegralInfo.hh" #include "LauDaughters.hh" #include "LauDecayTimePdf.hh" #include "LauFitNtuple.hh" #include "LauGenNtuple.hh" #include "LauIsobarDynamics.hh" #include "LauKinematics.hh" #include "LauPrint.hh" #include "LauRandom.hh" #include "LauScfMap.hh" #include "LauFlavTag.hh" #include "Lau1DHistPdf.hh" ClassImp(LauFlavTag) LauFlavTag::LauFlavTag() : taggerPosition_(), tagVarName_(), mistagVarName_(), curEvtTagFlv_(), curEvtMistag_(), curEvtMistagPrime_(), curEvtTrueTagFlv_(), perEvtAvgMistag_(), perEvtAvgMistagPrime_(), calib_p0_B0_(), calib_p0_B0bar_(), calib_p1_B0_(), calib_p1_B0bar_(), calib_p0_ave_(), calib_p0_delta_(), calib_p1_ave_(), calib_p1_delta_(), useAveDelta_(kFALSE), etaPdfs_(), etaPrimePdfs_() { } LauFlavTag::~LauFlavTag() { } void LauFlavTag::initialise() { } void LauFlavTag::addTagger(const TString name, const TString tagVarName, const TString mistagVarName, LauAbsPdf* etapdf, const Double_t tagEff_b0, const Double_t calib_p0_b0, const Double_t calib_p1_b0, const Double_t tagEff_b0bar, const Double_t calib_p0_b0bar, const Double_t calib_p1_b0bar) { // Find how many taggers have already been added Int_t position = tagVarName_.size(); // Update map to relate tagger name and position in the vectors taggerPosition_[position]=name; // Fill vectors tagVarName_.push_back(tagVarName); mistagVarName_.push_back(mistagVarName); if (etapdf){ etaPdfs_.push_back(etapdf); Lau1DHistPdf* etahistpdf = dynamic_cast(etapdf); if (etahistpdf){ perEvtAvgMistag_.push_back(etahistpdf->getMean()); } else { std::cerr << "WARNING in LauFlavTag::addTagger : Couldn't determine average eta value from PDF. Setting it to 0.4." << std::endl; perEvtAvgMistag_.push_back(0.4); } } else { std::cerr << "ERROR in LauFlavTag::addTagger : Eta PDF pointer is NULL" << std::endl; gSystem->Exit(EXIT_FAILURE); } //eta prime pdf TH1D* etaprimehist = new TH1D("etaprimehist"+name,"",1000,-10.0,10.0); Double_t eta(0.0); Int_t nmax = 1000000; for (Int_t i=0; iFill(-1.0*TMath::Log((1.0/eta)-1.0)); } Lau1DHistPdf* etaPrimePdf = new Lau1DHistPdf("etaprimehist",etaprimehist,-10.0,10.0,kTRUE,kFALSE); etaPrimePdfs_.push_back(etaPrimePdf); perEvtAvgMistagPrime_.push_back(etaPrimePdf->getMean()); // LauParameters TString tagEff_b0Name("tagEff_b0_"+name); TString tagEff_b0barName("tagEff_b0bar_"+name); TString calib_p0_b0Name("calib_p0_b0_"+name); TString calib_p0_b0barName("calib_p0_b0bar_"+name); TString calib_p1_b0Name("calib_p1_b0_"+name); TString calib_p1_b0barName("calib_p1_b0bar_"+name); LauParameter* tageffb0 = new LauParameter(tagEff_b0Name,tagEff_b0,0.0,1.0,kTRUE); tagEff_B0_.push_back(tageffb0); tagEff_B0_[position]->initValue(tagEff_b0); tagEff_B0_[position]->genValue(tagEff_b0); tagEff_B0_[position]->fixed(kTRUE); //Update once full code in place LauParameter* calibp0b0 = new LauParameter(calib_p0_b0Name,calib_p0_b0,0.0,1.0,kTRUE); calib_p0_B0_.push_back(calibp0b0); calib_p0_B0_[position]->initValue(calib_p0_b0); calib_p0_B0_[position]->genValue(calib_p0_b0); calib_p0_B0_[position]->fixed(kTRUE); //Update once full code in place LauParameter* calibp1b0 = new LauParameter(calib_p1_b0Name,calib_p1_b0,0.0,1.5,kTRUE); calib_p1_B0_.push_back(calibp1b0); calib_p1_B0_[position]->initValue(calib_p1_b0); calib_p1_B0_[position]->genValue(calib_p1_b0); calib_p1_B0_[position]->fixed(kTRUE); //Update once full code in place if (tagEff_b0bar==-1.0 && calib_p0_b0bar==-1.0 && calib_p1_b0bar==-1.0){ tagEff_B0bar_.push_back(tagEff_B0_[position]->createClone(tagEff_b0barName)); calib_p0_B0bar_.push_back(calib_p0_B0_[position]->createClone(calib_p0_b0barName)); calib_p1_B0bar_.push_back(calib_p1_B0_[position]->createClone(calib_p1_b0barName)); } else { LauParameter* tageffb0bar = new LauParameter(tagEff_b0barName,tagEff_b0bar,0.0,1.0,kTRUE); tagEff_B0bar_.push_back(tageffb0bar); tagEff_B0bar_[position]->initValue(tagEff_b0bar); tagEff_B0bar_[position]->genValue(tagEff_b0bar); tagEff_B0bar_[position]->fixed(kTRUE); //Update once full code in place LauParameter* calibp0b0bar = new LauParameter(calib_p0_b0barName,calib_p0_b0bar,0.0,1.0,kTRUE); calib_p0_B0bar_.push_back(calibp0b0bar); calib_p0_B0bar_[position]->initValue(calib_p0_b0bar); calib_p0_B0bar_[position]->genValue(calib_p0_b0bar); calib_p0_B0bar_[position]->fixed(kTRUE); //Update once full code in place LauParameter* calibp1b0bar = new LauParameter(calib_p1_b0barName,calib_p1_b0bar,0.0,1.5,kTRUE); calib_p1_B0bar_.push_back(calibp1b0bar); calib_p1_B0bar_[position]->initValue(calib_p1_b0bar); calib_p1_B0bar_[position]->genValue(calib_p1_b0bar); calib_p1_B0bar_[position]->fixed(kTRUE); //Update once full code in place } // Use average and delta variables if required if (useAveDelta_){ this->useAveDeltaPars(position); } std::cout<<"INFO in LauFlavTag::addTagger : Added tagger with name "<< name << std::endl; } void LauFlavTag::useAveDeltaPars(Int_t position) { TString tagEff_ave("tagEff_ave_"+taggerPosition_[position]); TString tagEff_delta("tagEff_delta_"+taggerPosition_[position]); TString calib_p0_ave("calib_p0_ave_"+taggerPosition_[position]); TString calib_p0_delta("calib_p0_delta_"+taggerPosition_[position]); TString calib_p1_ave("calib_p1_ave_"+taggerPosition_[position]); TString calib_p1_delta("calib_p1_delta_"+taggerPosition_[position]); Double_t ave = ((tagEff_B0_[position]->unblindValue() + tagEff_B0bar_[position]->unblindValue())/2); LauParameter* tageffave = new LauParameter(tagEff_ave,ave,0.0,1.0,kTRUE); tagEff_ave_.push_back(tageffave); tagEff_ave_[position]->initValue(ave); tagEff_ave_[position]->genValue(ave); tagEff_ave_[position]->fixed(tagEff_B0_[position]->fixed()); //Update once full code in place Double_t delta = (tagEff_B0_[position]->unblindValue() - tagEff_B0bar_[position]->unblindValue()); LauParameter* tageffdelta = new LauParameter(tagEff_delta,delta,0.0,1.0,kTRUE); tagEff_delta_.push_back(tageffdelta); tagEff_delta_[position]->initValue(delta); tagEff_delta_[position]->genValue(delta); tagEff_delta_[position]->fixed(tagEff_B0_[position]->fixed()); //Update once full code in place ave = ((calib_p0_B0_[position]->unblindValue() + calib_p0_B0bar_[position]->unblindValue())/2); LauParameter* calibp0ave = new LauParameter(calib_p0_ave,ave,0.0,1.0,kTRUE); calib_p0_ave_.push_back(calibp0ave); calib_p0_ave_[position]->initValue(ave); calib_p0_ave_[position]->genValue(ave); calib_p0_ave_[position]->fixed(calib_p0_B0_[position]->fixed()); //Update once full code in place delta = (calib_p0_B0_[position]->unblindValue() - calib_p0_B0bar_[position]->unblindValue()); LauParameter* calibp0delta = new LauParameter(calib_p0_delta,delta,0.0,1.0,kTRUE); calib_p0_delta_.push_back(calibp0delta); calib_p0_delta_[position]->initValue(delta); calib_p0_delta_[position]->genValue(delta); calib_p0_delta_[position]->fixed(calib_p0_B0_[position]->fixed()); //Update once full code in place ave = ((calib_p1_B0_[position]->unblindValue() + calib_p1_B0bar_[position]->unblindValue())/2); LauParameter* calibp1ave = new LauParameter(calib_p1_ave,ave,0.0,1.0,kTRUE); calib_p1_ave_.push_back(calibp1ave); calib_p1_ave_[position]->initValue(ave); calib_p1_ave_[position]->genValue(ave); calib_p1_ave_[position]->fixed(calib_p1_B0_[position]->fixed()); //Update once full code in place delta = (calib_p1_B0_[position]->unblindValue() - calib_p1_B0bar_[position]->unblindValue()); LauParameter* calibp1delta = new LauParameter(calib_p1_delta,delta,0.0,1.0,kTRUE); calib_p1_delta_.push_back(calibp1delta); calib_p1_delta_[position]->initValue(delta); calib_p1_delta_[position]->genValue(delta); calib_p1_delta_[position]->fixed(calib_p1_B0_[position]->fixed()); //Update once full code in place } void LauFlavTag::cacheInputFitVars(LauFitDataTree* inputFitData) { evtTagFlv_.clear(); evtMistag_.clear(); evtMistagPrime_.clear(); evtTrueTagFlv_.clear(); // Loop over the taggers to check the branches for (UInt_t i=0; i < tagVarName_.size(); ++i){ if ( ! inputFitData->haveBranch( tagVarName_[i] ) ) { std::cerr << "ERROR in LauFlavTag::cacheInputFitVars : Input data does not contain branch \"" << tagVarName_[i] << "\"." << std::endl; gSystem->Exit(EXIT_FAILURE); } if ( ! inputFitData->haveBranch( mistagVarName_[i] ) ) { std::cerr << "ERROR in LauFlavTag::cacheInputFitVars : Input data does not contain branch \"" << mistagVarName_[i] << "\"." << std::endl; gSystem->Exit(EXIT_FAILURE); } } if ( ! inputFitData->haveBranch( trueTagVarName_ ) ) { std::cerr << "ERROR in LauFlavTag::cacheInputFitVars : Input data does not contain branch \"" << trueTagVarName_ << "\"." << std::endl; gSystem->Exit(EXIT_FAILURE); } UInt_t nEvents = inputFitData->nEvents(); evtTagFlv_.reserve( nEvents ); evtMistag_.reserve( nEvents ); evtMistagPrime_.reserve( nEvents ); evtTrueTagFlv_.reserve( nEvents ); LauFitData::const_iterator fitdata_iter; for (UInt_t iEvt = 0; iEvt < nEvents; iEvt++) { const LauFitData& dataValues = inputFitData->getData(iEvt); //Clear vectors curEvtTagFlv_.clear(); curEvtMistag_.clear(); curEvtMistagPrime_.clear(); // For untagged events see if we have a truth tag for normalisation modes curEvtTrueTagFlv_ = 0; fitdata_iter = dataValues.find( trueTagVarName_ ); curEvtTrueTagFlv_ = static_cast( fitdata_iter->second ); if ( curEvtTrueTagFlv_ > 1 ) { std::cerr << "WARNING in LauFlavTag::cacheInputFitVars : Invalid true tagging output " << curEvtTrueTagFlv_ << " for event " << iEvt << ", setting it to +1" << std::endl; curEvtTrueTagFlv_ = +1; } else if ( curEvtTrueTagFlv_ < -1 ){ std::cerr << "WARNING in LauFlavTag::cacheInputFitVars : Invalid true tagging output " << curEvtTrueTagFlv_ << " for event " << iEvt << ", setting it to -1" << std::endl; curEvtTrueTagFlv_ = -1; } evtTrueTagFlv_.push_back(curEvtTrueTagFlv_); for (UInt_t i=0; i < tagVarName_.size(); ++i){ fitdata_iter = dataValues.find( tagVarName_[i] ); curEvtTagFlv_.push_back(static_cast( fitdata_iter->second )); if ( curEvtTagFlv_[i] > 1 ) { std::cerr << "WARNING in LauFlavTag::cacheInputFitVars : Invalid tagging output " << curEvtTagFlv_[i] << " for event " << iEvt << ", setting it to +1" << std::endl; curEvtTagFlv_[i] = +1; } else if ( curEvtTagFlv_[i] < -1 ) { std::cerr << "WARNING in LauFlavTag::cacheInputFitVars : Invalid tagging output " << curEvtTagFlv_[i] << " for event " << iEvt << ", setting it to -1" << std::endl; curEvtTagFlv_[i] = -1; } fitdata_iter = dataValues.find( mistagVarName_[i]); curEvtMistag_.push_back(static_cast( fitdata_iter->second )); if (curEvtMistag_[i] > 0.5){ std::cerr<<"WARNING in LauFlavTag::cacheInputFitVars : Mistag value "<value( calib_p0_ave_[position]->unblindValue() + 0.5*calib_p0_delta_[position]->unblindValue() ); calib_p0_B0bar_[position]->value( calib_p0_ave_[position]->unblindValue() - 0.5*calib_p0_delta_[position]->unblindValue() ); calib_p1_B0_[position]->value( calib_p1_ave_[position]->unblindValue() + 0.5*calib_p1_delta_[position]->unblindValue() ); calib_p1_B0bar_[position]->value( calib_p1_ave_[position]->unblindValue() - 0.5*calib_p1_delta_[position]->unblindValue() ); } if (flag == 1){ return calib_p0_B0_[position]->unblindValue() + calib_p1_B0_[position]->unblindValue() * (curEvtMistagPrime_[position] - perEvtAvgMistagPrime_[position]); } else{ return calib_p0_B0bar_[position]->unblindValue() + calib_p1_B0bar_[position]->unblindValue() * (curEvtMistagPrime_[position] - perEvtAvgMistagPrime_[position]); } std::cerr << "ERROR in LauFlavTag::getOmega : Current event flavour tag not defined" << std::endl; return 0.0; } Double_t LauFlavTag::getCapitalOmega(const Int_t position, const Int_t flag) //const { if (TMath::Abs(flag) != 1){ std::cerr << "ERROR in LauFlavTag::getCapitalOmega : Invalid flag, you must request either Omega (+1) or Omega bar (-1) to be returned" << std::endl; return 0.0; } //Delta functions to control which terms contribute Int_t deltap1(0), deltam1(0), delta0(0); if (curEvtTagFlv_[position] == -1){ deltam1 = 1; } else if(curEvtTagFlv_[position] == 1){ deltap1 = 1; } else{ delta0 = 1; } //Efficiency Double_t eff=0.0; if (useAveDelta_){ tagEff_B0_[position]->value( tagEff_ave_[position]->unblindValue() + 0.5*tagEff_delta_[position]->unblindValue() ); tagEff_B0bar_[position]->value( tagEff_ave_[position]->unblindValue() - 0.5*tagEff_delta_[position]->unblindValue() ); } if (flag==1){ eff = tagEff_B0_[position]->unblindValue(); } else { eff = tagEff_B0bar_[position]->unblindValue(); } //Little omega Double_t omega = this->getOmega(position, flag); //Transform to omega prime Double_t omegaPrime = (1/(1+TMath::Exp(-1.0*omega))); //eta PDF value std::vector abs; abs.push_back(curEvtMistagPrime_[position]); etaPrimePdfs_[position]->calcLikelihoodInfo(abs); Double_t h = etaPrimePdfs_[position]->getLikelihood(); //Put it together if (flag == 1){ //Particle return (deltap1*eff*(1-omegaPrime) + deltam1*eff*omegaPrime)*h + delta0*(1-eff); } else { return (deltam1*eff*(1-omegaPrime) + deltap1*eff*omegaPrime)*h + delta0*(1-eff); } } -Double_t LauFlavTag::getOmegaGen(const Int_t position, const Double_t eta, const Int_t flag) //const -{ - if (TMath::Abs(flag) != 1){ - std::cerr << "ERROR in LauFlavTag::getOmegaGen : Invalid flag, you must request either omega (+1) or omega bar (-1) to be returned" << std::endl; - return 0.0; - } - //If we are floating average omega and delta omega we need to use those parameters instead - if (useAveDelta_){ - calib_p0_B0_[position]->value( calib_p0_ave_[position]->unblindValue() + 0.5*calib_p0_delta_[position]->unblindValue() ); - calib_p0_B0bar_[position]->value( calib_p0_ave_[position]->unblindValue() - 0.5*calib_p0_delta_[position]->unblindValue() ); - calib_p1_B0_[position]->value( calib_p1_ave_[position]->unblindValue() + 0.5*calib_p1_delta_[position]->unblindValue() ); - calib_p1_B0bar_[position]->value( calib_p1_ave_[position]->unblindValue() - 0.5*calib_p1_delta_[position]->unblindValue() ); - } - if (flag == 1){ - return calib_p0_B0_[position]->unblindValue() + calib_p1_B0_[position]->unblindValue() * (eta - perEvtAvgMistagPrime_[position]); - } - else{ - return calib_p0_B0bar_[position]->unblindValue() + calib_p1_B0bar_[position]->unblindValue() * (eta - perEvtAvgMistagPrime_[position]); - } - std::cerr << "ERROR in LauFlavTag::getOmegaGen : Current event flavour tag not defined" << std::endl; - return 0.0; -} - -Double_t LauFlavTag::getCapitalOmegaGen(const Int_t position, const Double_t etaprime, const Int_t curEvtTagFlv, const Int_t flag) -{ - if (TMath::Abs(flag) != 1){ - std::cerr << "ERROR in LauFlavTag::getCapitalOmegaGen : Invalid flag, you must request either Omega (+1) or Omega bar (-1) to be returned" << std::endl; - return 0.0; - } - //Delta functions to control which terms contribute - Int_t deltap1(0), deltam1(0), delta0(0); - - if (curEvtTagFlv == -1){ - deltam1 = 1; - } else if(curEvtTagFlv == 1){ - deltap1 = 1; - } else{ - delta0 = 1; - } - - //Efficiency - Double_t eff=0.0; - if (useAveDelta_){ - tagEff_B0_[position]->value( tagEff_ave_[position]->unblindValue() + 0.5*tagEff_delta_[position]->unblindValue() ); - tagEff_B0bar_[position]->value( tagEff_ave_[position]->unblindValue() - 0.5*tagEff_delta_[position]->unblindValue() ); - } - if (flag==1){ - eff = tagEff_B0_[position]->unblindValue(); - } else { - eff = tagEff_B0bar_[position]->unblindValue(); - } - - //Little omega - Double_t omega = this->getOmegaGen(position, etaprime, flag); - //Transform to omega prime - Double_t omegaPrime = (1/(1+TMath::Exp(-1.0*omega))); - - //eta PDF value - std::vector abs; - abs.push_back(etaprime); - etaPrimePdfs_[position]->calcLikelihoodInfo(abs); - Double_t h = etaPrimePdfs_[position]->getLikelihood(); - - //Put it together - if (flag == 1){ - return (deltap1*eff*(1-omegaPrime) + deltam1*eff*omegaPrime)*h + delta0*(1-eff)*0.5; - } else { - return (deltam1*eff*(1-omegaPrime) + deltap1*eff*omegaPrime)*h + delta0*(1-eff)*0.5; - } - //return(0.); -} - Double_t LauFlavTag::getEtaGen(Int_t position) const { LauFitData data = etaPdfs_[position]->generate(0); //TODO Add DP dependence? Double_t etagen = data.find(etaPdfs_[position]->varName())->second; if (etagen > 0.5){etagen = 0.5;} if (etagen < 0.0){etagen = 0.001;} return etagen; } Double_t LauFlavTag::getEtaPrimeGen(Int_t position) const { LauFitData data = etaPrimePdfs_[position]->generate(0); //TODO Add DP dependence? Double_t etagen = data.find(etaPrimePdfs_[position]->varName())->second; return etagen; } void LauFlavTag::setTrueTagVarName(TString trueTagVarName){ trueTagVarName_ = trueTagVarName; }