class 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.
RooAbsAnaConvPdf 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.
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
Double_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)