Docs | All | Real | Category | PDF | DataSet | Plot | Container | Misc | Aux | User |
RooAbsAnaConvPdfclass description - source file - inheritance tree (.pdf) class RooAbsAnaConvPdf : public RooAbsPdf
This is an abstract class, constructors will not be documented. Look at the header to check for available constructors. protected: Data Membersprotected: Class DescriptionRooAbsAnaConvPdf is the base class of for PDFs that represents a physics model that can be analytically convolved with a resolution model To achieve factorization between the physics model and the resolution model, each physics model must be able to be written in the form _ _ _ _ Phys(x,a,b) = Sum_k coef_k(a) * basis_k(x,b) where basis_k are a limited number of functions in terms of the variable to be convoluted and coef_k are coefficients independent of the convolution variable. Classes derived from RooResolutionModel implement _ _ _ _ R_k(x,b,c) = Int(dx') basis_k(x',b) * resModel(x-x',c) which RooAbsAnaConvPdf uses to construct the pdf for [ Phys (x) R ] : _ _ _ _ _ _ PDF(x,a,b,c) = Sum_k coef_k(a) * R_k(x,b,c) A minimal implementation of a RooAbsAnaConvPdf physics model consists of - A constructor that declares the required basis functions using the declareBasis() method. The declareBasis() function assigns a unique identifier code to each declare basis - An implementation of coefficient(Int_t code) returning the coefficient value for each declared basis function Optionally, analytical integrals can be provided for the coefficient functions. The interface for this is quite similar to that for integrals of regular PDFs. Two functions, Int_t getCoefAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars) Double_t coefAnalyticalIntegral(Int_t coef, Int_t code), advertise the coefficient integration capabilities and implement them respectively. Please see RooAbsPdf for additional details. Advertised analytical integrals must be valid for all coefficients. ~RooAbsAnaConvPdf() Destructor Int_t declareBasis(const char* expression, const RooArgList& params) Declare a basis function for use in this physics model. The string expression must be a valid RooFormulVar expression representing the basis function, referring to the convolution variable as '@0', and any additional parameters (supplied in 'params' as '@1','@2' etc. The return value is a unique identifier code, that will be passed to coefficient() to identify the basis function for which the coefficient is requested. If the resolution model used does not support the declared basis function, code -1 is returned. Bool_t changeModel(const RooResolutionModel& newModel) Change the resolution model to given model RooAbsGenContext* genContext(const RooArgSet &vars, const RooDataSet *prototype, const RooArgSet* auxProto, Bool_t verbose) const Bool_t isDirectGenSafe(const RooAbsArg& arg) const All direct generation of convolution arg if model is truth model const RooRealVar* convVar() const Return a pointer to the convolution variable instance used in the resolution model Double_t evaluate() const Calculate the current unnormalized value of the PDF PDF = sum_k coef_k * [ basis_k (x) ResModel ] Int_t getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, const RooArgSet* normSet2, const char* /*rangeName*/) const Handle trivial no-integration scenario Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const Return analytical integral defined by given scenario code. For unnormalized integrals this is _ _ PDF = sum_k Int(dx) coef_k * Int(dy) [ basis_k (x) ResModel ]. _ where x is the set of coefficient dependents to be integrated and y the set of basis function dependents to be integrated. For normalized integrals this becomes sum_k Int(dx) coef_k * Int(dy) [ basis_k (x) ResModel ]. PDF = -------------------------------------------------------- sum_k Int(dv) coef_k * Int(dw) [ basis_k (x) ResModel ]. where x is the set of coefficient dependents to be integrated, y the set of basis function dependents to be integrated, v is the set of coefficient dependents over which is normalized and w is the set of basis function dependents over which is normalized. Set x must be contained in v and set y must be contained in w. Int_t getCoefAnalyticalIntegral(RooArgSet& /*allVars*/, RooArgSet& /*analVars*/, const char* /*rangeName*/) const Default implementation of function advertising integration capabilities: no integrals are advertised. Double_t coefAnalyticalIntegral(Int_t coef, Int_t code, const char* /*rangeName*/) const Default implementation of function implementing advertised integrals. Only the pass-through scenario (no integration) is implemented. Bool_t forceAnalyticalInt(const RooAbsArg& /*dep*/) const This function forces RooRealIntegral to offer all integration dependents to RooAbsAnaConvPdf::getAnalyticalIntegralWN() for consideration for analytical integration, if RRI considers this to be unsafe (e.g. due to hidden Jacobian terms). RooAbsAnaConvPdf will not attempt to actually integrate all these dependents but feed them to the resolution models integration interface, which will make the final determination on how to integrate these dependents. Double_t getCoefNorm(Int_t coefIdx, const RooArgSet* nset, const char* rangeName) const void makeCoefVarList() const Build complete list of coefficient variables Bool_t redirectServersHook(const RooAbsCollection& /*newServerList*/, Bool_t /*mustReplaceAll*/, Bool_t /*nameChange*/, Bool_t /*isRecursive*/) Throw away cache of coefCoefVars and normalization integrals constructed in terms of those coefficients Bool_t syncNormalizationPreHook(RooAbsReal* /*norm*/,const RooArgSet* nset) const Overload of hook function in RooAbsPdf::syncNormalization(). This functions serves two purposes: - Modify default normalization behaviour of RooAbsPdf: integration requests over unrelated variables are properly executed (introducing a trivial multiplication for each unrelated dependent). This is necessary if composite resolution models are used in which the components do not necessarily all have the same set of dependents. - Built the sub set of normalization dependents that is contained the basis function resolution model convolution (to be used in syncNormalizationPostHook(). void syncNormalizationPostHook(RooAbsReal* /*norm*/,const RooArgSet* /*nset*/) const Overload of hook function in RooAbsPdf::syncNormalization(). This function propagates the syncNormalization() call to all basis-function/resolution-model convolution component objects and fixes the physics models client-server links by adding each variable that serves any of the convolution objects normalizations. PDFs by default have all client-server links that control the unnormalized value (as returned by evaluate()), but convoluted PDFs have a non-trivial normalization term that may introduce dependencies on additional server that exclusively appear in the normalization. void printToStream(ostream& os, PrintOption opt, TString indent) const Print info about this object to the specified stream. In addition to the info from RooAbsPdf::printToStream() we add: Verbose : detailed information on convolution integrals Inline FunctionsDouble_t getCoefNorm(Int_t coefIdx, const RooArgSet* nset = 0, const char* rangeName = "0") const Double_t coefficient(Int_t basisIndex) const RooArgSet* parseIntegrationRequest(const RooArgSet& intSet, Int_t& coefCode, RooArgSet* analVars = 0) const TClass* Class() TClass* IsA() const void ShowMembers(TMemberInspector& insp, char* parent) void Streamer(TBuffer& b) void StreamerNVirtual(TBuffer& b)
|
Page maintained by Wouter Verkerke and David Kirkby |