Page MenuHomeHEPForge

No OneTemporary

Size
108 KB
Referenced Files
None
Subscribers
None
diff --git a/doc/ReleaseNotes.md b/doc/ReleaseNotes.md
index 6812314..cdb9343 100644
--- a/doc/ReleaseNotes.md
+++ b/doc/ReleaseNotes.md
@@ -1,857 +1,861 @@
# Laura++ release notes
+18th May 2021 Mark Whitehead
+* Add new MIPW example
+ - see https://phab.hepforge.org/T147
+
26th March 2021 Thomas Latham
* Fix bug in setting for linear interpolation in Lau1DHistPdf
- see https://phab.hepforge.org/T142
9th March 2021 Mark Whitehead
* Update particle properties to PDG 2020
- see https://phab.hepforge.org/T140
5th March 2021 Dan Johnson
* Alterations to allow Blatt-Weisskopf factor for parent to be created in a model with only a K-matrix
- see https://phab.hepforge.org/D52
4th February 2021 Dan Johnson
* Extend the K-matrix implementation to handle non-zero spin
- see https://phab.hepforge.org/T135
1st February 2021 Dan Johnson
* Allow floating of parameters in the K-matrix
- see https://phab.hepforge.org/T59
2nd December 2020 Thomas Latham
* Fix LauFormulaPar to follow change in behaviour of TFormula
- see https://phab.hepforge.org/T129
27th November 2020 Dan Johnson
* Allow slope of NR exponential model to vary negative - improves fit stability in low-statistics fits
- see https://phab.hepforge.org/T128
17th September 2020 Mark Whitehead
* Begin updates to use inclusive language. Simultaneous fits now handled by Coordinator and Tasks
- see https://phab.hepforge.org/T112
19th August 2020 Thomas Latham
* Remove explicit normalisation of numerator Blatt-Weisskopf factors
- See https://phab.hepforge.org/T93
22nd May 2020 Thomas Latham
* Fix uninitialised variable (related to rho-omega mixing) in LauIsobarDynamics
12th December 2019 Thomas Latham & Daniel Johnson
* Fix issue with generation of events for categories with small expected yield
- See https://phab.hepforge.org/T76
21st November 2019 Thomas Latham
* Add QuasiFlatSqDalitz example, which generates toy according to EvtGen's FLATSQDALITZ model
6th - 20th November 2019 Thomas Latham
* Adopt CMake as the build system
- See https://phab.hepforge.org/T33
===
## Laura++ v3r5
6th August 2019 Thomas Latham
* Add some extra charmonium states to list of known resonances
* Minor modifications to code for importing parameter values from file
17th May 2019 Thomas Latham
* Fix licences and Doxygen in pole, nonresonant form factors, and rescattering line shapes
* Add journal reference for pole line shape
* Fix class names and add Doxygen to LauCalcChiSq, LauResultsExtractor, LauMergeDataFiles
* Update Doxyfile from more recent Doxygen version
* Make consistent the use of ClassDef and ClassImp everywhere
* Add functions to return the "sanitised" names of parent and daughters
8th January 2019 Thomas Latham
* Workaround for issue with splitting toy MC files when generating large number of experiments
5th December 2018 Thomas Latham
* Move sources and headers for the utilities library into the main library
- makes examples dir executables only (in preparation for CMake build)
22nd, 23rd July and 4th August 2018 Juan Otalora
* Add pole, nonresonant form factors, and rescattering line shapes
17th April 2018 Daniel O'Hanlon
* Fix bug in rho-omega mixing fit-fraction calculation: rho fit-fraction was not normalised to the total DP rate
23rd March 2018 Thomas Latham
* Some fixes in LauRhoOmegaMix that propagate the following settings to the subcomponents:
- spinType_
- flipHelicity_
- ignoreMomenta_
- ignoreSpin_
- ignoreBarrierScaling_
23rd February 2018 Thomas Latham
* Add section on structure of package to README file (requested by CPC technial editor)
* Add copyright notice to files in test directory
21st February 2018 Thomas Latham
* Improve comments in functions calculating helicity angles in LauKinematics
19th February 2018 Daniel O'Hanlon
* Fix bug in LauCPFitModel introduced in code for importing parameters (25/01/18)
- When parameters are asked to be randomised via useRandomInitFitPars, those
parameters that were already fixed in the model, in addition to those that
are fixed on import, were being freed.
19th February 2018 Daniel O'Hanlon
* Bug fixes in rho/omega fit fractions calculation
25th January 2018 Daniel O'Hanlon
* Add feature for importing parameters into LauCPFitModels from previous fit output files.
23rd January 2018 Daniel O'Hanlon
* Calculate separate rho and omega fit-fractions for LauRhoOmegaMix, when turned on with calculateRhoOmegaFitFractions in LauIsobarDynamics.
===
## Laura++ v3r4
16th January 2018 Thomas Latham
* Update licence for all files to the Apache Software License Version 2.0
14th December 2017 Thomas Latham
* Correct LauFlatteRes to use the exact formulae from the papers that report the default parameter values for each supported resonance
- Deals correctly now with the cases where the m0 is absorbed into the couplings
- Now uses the correct value of g1 for the a_0(980) (needed to be squared)
- Also sets the mass values to those reported in those papers
- Added printout to specify what is being done in each case
* Improve the consistency between the weightEvents functions in LauSimpleFitModel and LauCPFitModel
- Also remove the unecessary division by ASqMax in LauIsobarDynamics::getEventWeight
4th December 2017 Thomas Latham
* Allow background yields to be specified as any LauAbsRValue (i.e. LauParameter or now also LauFormulaPar)
30th November 2017 Thomas Latham
* In LauFitDataTree::readExperimentData add a check that the tree contains the branch "iExpt" and if not:
- If the requested experiment is 0 then read all data in the tree (and print a warning)
- Otherwise print an error message and return
29th November 2017 Thomas Latham
* Improve error messages in LauCPFitModel::weightEvents
===
## Laura++ v3r3
23rd November 2017 Thomas Latham
* Add an example written as a python script: GenFit3pi.py
* Various improvements to the other example code
23rd November 2017 Thomas Latham
* Fix bug in the LauAbsResonance constructor used by the K-matrix
- "resonance" charge is now set to the sum of the daughter charges
1st November 2017 Thomas Latham
* Fix bug in LauFlatteRes
- m_0 factor multiplying the width was, if useAdlerTerm_ is true, replaced by
f_Adler rather than being multiplied by it
- only affected case where using LauFlatteRes to describe K_0*(1430)
===
## Laura++ v3r2
18th October 2017 Thomas Latham
* Modify LauDaughters::testDPSymmetry to:
- produce an ERROR message and exit if the symmetric DP does not have its daughters arranged correctly
- detect also flavour-conjugate DPs and set a corresponding flag that can be retrieved via LauDaughters::gotFlavourConjugateDP
- in this case if the daughters are sub-optimally arranged print a WARNING
* Modify LauIsobarDynamics::calcDPNormalisationScheme so that any narrow resonance regions are symmetrised appropriately if the DP is fully-symmetric, symmetric or is flavour-conjugate (and in this last case, symmetrisation of the integration has been forced via a new boolean function)
11th October 2017 Thomas Latham
* Allow the user to specify the randomiser to be used to randomise the initial values of the isobar parameters
- simply use the new static function LauAbsCoeffSet::setRandomiser
- if not specified it defaults to the current use of LauRandom::zeroSeedRandom
10th October 2017 Thomas Latham
* Make symmetrisation of vetoes automatic in LauVetoes for symmetric DPs
- but add new allowed indices (4 and 5) to allow vetoes to be applied to mMin or mMax if desired
* Also apply to fully symmetric DPs
* In addition implement the more efficient calculation of the amplitude in the fully symmetric case
23rd September 2017 Thomas Latham
* Fix expressions for Covariant option for Blatt-Weisskopf momentum for spin > 1
* Make use of setSpinFormalism to set the formalism to Legendre for NR types (instead of kludging with ignoreMomentum)
15th September 2017 Thomas Latham
* Various improvements to the examples
6th September 2017 Thomas Latham
* Improve doxygen comments for event-embedding functions in fit models
5th September 2017 Thomas Latham
* Improve efficiency of Covariant spin factor calculations
31st August 2017 Thomas Latham
* Add further option for parent Blatt-Weisskopf momentum - Covariant (corresponding to Covariant spin factor)
8th August 2017 Thomas Latham
* Implement expressions for the spin factor based on covariant tensor formalism
* Make it much simpler to switch between formalism options via new functions in LauResonanceMaker:
- setSpinFormalism, setBWType, setBWBachelorRestFrame
- default settings are unchanged (and are equivalent to setting LauAbsResonance::Zemach_P, LauBlattWeisskopfFactor::BWPrimeBarrier, LauBlattWeisskopfFactor::ResonanceFrame, respectively)
21st July 2017 Thomas Latham
* Add note to README file about compilation issue on Ubuntu 16.04 LTS
21st July 2017 Thomas Latham
* Create public functions to update the kinematics based on one invariant mass and the corresponding helicity angle
20th June 2017 Daniel O'Hanlon
* Terminate when asked to read a non-existent K-matrix parameter file
8th June 2017 Thomas Latham
* Fix compilation error on gcc 4.9
30th May 2017 Thomas Latham
* Permit different efficiency histograms to be defined in classic/square DP and force enable calculation of square DP coords (here and for background PDFs) if required
29th May 2017 Thomas Latham
* Propagate information on EDM from the minimiser to the fit models and into the fit results ntuple
29th May 2017 Thomas Latham
* Ensure that the kinematics will calculate the square DP co-ordinates if the integration requires them
29th May 2017 Thomas Latham
* Reintegrate the RooFit-slave branch into the trunk (and delete the branch)
28th March 2017 Thomas Latham
(in branch for developing RooFit-based slave)
* Rename cacheFitData to verifyFitData in all fit models and RF-slave
28th March 2017 Daniel O'Hanlon
* Fix bug in LauCPFitModel::weightEvents
24th March 2017 Thomas Latham
(in branch for developing RooFit-based slave)
* Refactor code between fit models, master, slave and fit-object classes
22nd March 2017 Thomas Latham
(in branch for developing RooFit-based slave)
* Make the compilation of the RF-based slave class, and its associated example binary, optional
22nd March 2017 Thomas Latham
(in branch for developing RooFit-based slave)
* Complete working example of RooFit-based slave
- Have identified some scope for refactoring of code
- Also want to make the compilation of this class, and its associated example binary, optional
15th March 2017 Mark Whitehead
(in branch for developing time-dependent model)
* Handle event-by-event mistag probabilities
7th March 2017 Thomas Latham
* Rename the command for weighting events from "reweight" to "weight"
3rd March 2017 Daniel O'Hanlon
* Implement LauCPFitModel::weightEvents based on the same function in LauSimpleFitModel
1st March 2017 Thomas Latham
(in branch for developing RooFit-based slave)
* Fix root-cling related errors
28th February 2017 Thomas Latham
(in branch for developing RooFit-based slave)
* Start work on creation of RooFit-based slave class
- Will allow RooFit-based fitters to plug-in straightforwardly to the simultaneous fitting (JFit) framework
20th February 2017 Thomas Latham
* Add warning messages to LauBkgndDPModel::setBkgndHisto when supplied backgroud histogram pointers are null
31st January 2017 Thomas Latham
* Audit of the code to automate the creation of the integration binning scheme.
- Fix one bug, some tidy-ups, and reintroduce a couple of lost features:
- the use of a single square-DP grid if a narrow resonance is found in m12
- extension of region down to threshold if the narrow resonance is close to threshold
22nd January 2017 Daniel O'Hanlon
* Fix bug in automated integration scheme where resonances were assumed to have been added in order of ascending mass
14th December 2016 Daniel O'Hanlon
* Add several light resonances to the list in LauResonanceMaker
13th December 2016 Daniel O'Hanlon
* Automate the determination of the integration scheme for an arbitrary number of narrow resonances in m13 and m23
12th December 2016 Daniel O'Hanlon
* Efficiency saving from modifying the behaviour of LauIsobarDynamics::calculateAmplitudes, LauIsobarDynamics::resAmp and LauIsobarDynamics::incohResAmp in the case of symmetric DPs
- Previously, there were 2N calls to LauKinematics::flipAndUpdateKinematics for N resonances, now reduced to 2
21st November 2016 John Back
* Added two K-matrix examples for creating pedagogical plots (with associated data files):
- B3piKMatrixPlots for K-matrix elements, propagator, and pole and SVP production terms
- B3piKMatrixMassProj for pole and SVP mass projections generated over the DP
17th November 2016 John Back
* Modifications of the K matrix implementation:
- Changed the format of the parameter file to use keywords, with updated examples
- The scattering coefficients are now symmetrised, unless "ScattSymmetry 0" is used
- Allow the option to use the Adler zero suppression term for the production poles and SVPs (default = off).
These are specified with the useProdAdler boolean in the LauKMatrixProdPole/SVP constructors
- Added a few helper functions for obtaining coefficients and (internal) matrices
- Added a method to return the Lorentz-invariant transition amplitude for plots/tests
1st November 2016 Wenbin Qian
* Add calculation of so-called covariant factors for spin amplitude
===
## Laura++ v3r1
9th September 2016 Thomas Latham
* Modification of LauFitNtuple to check the size of the covariance matrix wrt known number of parameters and act accordingly:
- If it is empty, just fill a diagonal correlation matrix and issue a warning.
- If it results from a failed first stage of a two-stage fit then the correlation matrix is padded with 1s and 0s for the parameters that were fixed in the first stage.
* Remove the feature that allows parameters to float in first stage of a two-stage fit but to be fixed in second.
* Minor fix to LauAbsCoeffSet: the names of parameters would be mangled if they were the same as the basename, e.g. A1_A would become A1_ while A1_B would be correct.
8th September 2016 Thomas Latham
* Modifications to LauResonanceInfo to allow customisation of which extra parameters are shared between charge conjugate or shared-parameter records.
- Where the parameters are not shared they are independently created instead of being cloned.
* Modification of LauRhoOmegaMix to take advantage of the above to have the magB and phiB parameters independent.
* Addition to LauResonanceMaker of rho(770)_COPY record that is a shared record with rho(770) - this allows the above new feature to be used.
* Minor unrelated improvement to information messages in LauIsobarDynamics.
25th August 2016 John Back
* Modified LauRhoOmegaMix to allow either a RelBW or GS lineshape for the rho, as well as
allowing the option to set the second-order denominator term to be equal to unity.
Also fixed the bug where the spinTerm was not included in the rho-omega amplitude.
Changed the LauAbsResonance enum from RhoOmegaMix to RhoOmegaMix_GS, RhoOmegaMix_RBW,
RhoOmegaMix_GS_1 and RhoOmegaMix_RBW_1, where _1 sets the denominator term to unity and
_GS or _RBW sets the appropriate rho lineshape. The omega is always a RelBW.
* Added to LauAbsResonance: ignoreSpin and ignoreBarrierScaling boolean flags, which ignore
either the spin terms or the barrier scaling factors for the amplitude. The latter does not
turn off the resonance barrier factor for mass-dependent widths
* Added to LauResonanceMaker: getResInfo(resonanceName), which retrieves the resonance information.
This is used to obtain the PDG omega values for initialising LauRhoOmegaMix
* Made LauRelBreitWignerRes ignore momentum-dependent terms for the resonance width if ignoreMomenta is set.
This is used in the LauRhoOmegaMix for the omega lineshape where its width does not depend on momentum
23rd May 2016 John Back
* Added new lineshape model for rho-omega mass mixing, LauRhoOmegaMix.
12th April 2016 Thomas Latham
* Switch to integrating in square DP when narrow resonances are found in m12.
- The integration grid size can be specified by the user
19th January 2016 John Back
* Correct the f(m^2) factor in the denominator of the LauGounarisSakuraiRes
lineshape to use Gamma_0 instead of Gamma(m)
14th January 2016 Thomas Latham
* Documentation improvements
7th December 2015 Thomas Latham
* Resolve bug that meant the order of resonances in LauIsobarDynamics was assumed to match with the order in which the complex coefficients are supplied to the fit model
- The ordering of resonances is defined by LauIsobarDynamics:
- Firstly all coherent resonances in order of addition
- Followed by all incoherent resonances in order of addition
- The complex coefficients are now rearranged to match that order
- Printout of the model summary at the end of initialisation has been enhanced to indicate the ordering
- Doxygen updated to reflect these changes
12th November 2015 Daniel Craik
* Added support for Akima splines and linear interpolation to Lau1DCubicSpline
* LauAbsModIndPartWave, LauModIndPartWaveRealImag and LauModIndPartWaveMagPhase updated to allow choice of spline interpolation method
* LauEFKLLMRes updated to use Akima splines
10th November 2015 Thomas Latham & Daniel Craik
* Add the EFKLLM form-factor model for the Kpi S-wave and an example using this lineshape
* Modify LauResonanceMaker::getResonance to use a switch for greater clarity and easier checking on missing cases
4th November 2015 Daniel Craik
* Add checks to LauIsobarDynamics::addResonance and LauIsobarDynamics::addIncohResonance to stop the wrong type of LauResonanceModel being used
- LauAbsResonance::isIncoherentModel method added to identify incoherent models
8th September 2015 Mark Whitehead
* Add the ability to modify the error of parameters via the CoeffSet
- setParameterError added to LauAbsCoeffSet
* Tweak the handling of initial error values passed to MINUIT (to determine initial step size) in LauMinuit
7th September 2015 Mark Whitehead
* Add the ability to Gaussian constrain parameters via the CoeffSet
- addGaussianConstraint added to LauAbsCoeffSet
12th June 2015 Thomas Latham
* Modifications to Belle-style nonresonant models
- LauBelleNR modified to use pure Legendre polynomials of cos(theta) in the spin term (i.e. to remove the q*p factors)
- New form added to LauBelleSymNR (LauAbsResonance::BelleSymNRNoInter) that removes the interference term between the two DP halves
- The new form also works with non-zero spin (warning added if non-zero spin specified for BelleSymNR and TaylorNR)
8th June 2015 Thomas Latham
* Further work on the blinding mechanism:
- New method added LauParameter::blindParameter that activates the blinding.
- The rest of the framework updated to use another new method LauParameter::unblindedValue in all likelihood calculations etc.
- Example GenFitNoDP updated to include lines to optionally blind the yield parameters.
29th May 2015 Daniel Craik
* Added LauBlind class for blinding and unblinding a value with an offset based on a blinding string
26th May 2015 Daniel Craik
* Stopped LauCPFitModel passing fixed signal/background yields or
asymmetries to Minuit to avoid hitting limit of 101 fixed parameters
22nd April 2015 Daniel Craik
* Updated MIPW classes to use Lau1DCubicSpline
19th April 2015 Daniel Craik
* Added Lau1DCubicSpline class for 1D spline interpolation
26th March 2015 Thomas Latham
* Reworked MIPW code into abstract base class and derived classes
to allow different representations of the amplitude at each knot
31st December 2015 Daniel Craik
* Added unbinned goodness of fit tests to examples
12th January 2015 Daniel Craik
* Calculate effective masses for virtual resonances above the upper kinematic limit
10th December 2014 Daniel Craik
* Added coefficient sets to extract gamma from a simultaneous fit to CP and nonCP final states,
such as the B0->D_CP K pi and B0->D0bar K pi Dalitz plots, as proposed in Phys. Rev. D79, 051301 (2009)
- LauPolarGammaCPCoeffSet uses the CP parameters r, delta and gamma directly
- LauRealImagGammaCPCoeffSet parameterises CPV as X_CP+/- and Y_CP+/-
- LauCartesianGammaCPCoeffSet parameterises CPV as X_CP, Y_CP DeltaX_CP DeltaY_CP
- Fixed CP parameters are not passed to the fitter so the same coefficient sets can be used for both the
CP and nonCP Dalitz plots
- LauPolarGammaCPCoeffSet allows for a single gamma parameter to be shared between multiple resonances
- LauAbsCoeffSet::adjustName made virtual to allow global variables such as gamma to not receive a prefix
===
## Laura++ v3r0p1
19th June 2015 Thomas Latham
* Factor out the JFit slave code from LauAbsFitModel into a new base class LauSimFitSlave
19th June 2015 Thomas Latham
* Fix check in LauIsobarDynamics::calcDPNormalisationScheme to avoid using hardcoded number
===
## Laura++ v3r0
24th October 2014 Thomas Latham
* Fixed bug in floating of Blatt-Weisskopf barrier radii
- The values at the pole mass were not being updated when the radii changed
21st October 2014 Daniel Craik
* Fixed bug in LauIsobarDynamics where multiple incoherent amplitudes led to nonsensical fit fractions
17th October 2014 John Back
* Added the ability to calculate the transition amplitude matrix T in LauKMatrixPropagator,
as well as a few other minor speed-up changes and code checks. Example/PlotKMatrixTAmp.cc
can be used to check the T amplitude variation, phase shift and inelasticity, for a given
K matrix channel, as a function of the invariant mass squared variable s
15th October 2014 Thomas Latham
* Add methods to LauIsobarDynamics to make the integration binning more tunable by the user:
- setNarrowResonanceThreshold - modify the value below which a resonance is considered to be narrow (defaults to 0.02 GeV/c2)
- setIntegralBinningFactor - modify the factor by which the narrow resonance width is divided to obtain the bin size (defaults to 100)
* Print warning messages if the memory usage is likely to be very large
13th October 2014 Thomas Latham
* Modify Makefile to allow compilation with ROOT 6 (in addition to maintaining support for ROOT 5)
* Fix a few compilation errors on MacOSX 10.9
13th October 2014 Daniel Craik
* Update LauModIndPartWave to allow knots at kinematic limits to be modified
- Add new method setKnotAmp to modify existing knots (and the knot at the upper kinematic limit which is automatically added at initialisation)
* Update doxygen for LauIsobarDynamics::addIncoherentResonance to mention that incoherent resonances must be added last
10th October 2014 Thomas Latham
* Add new method to LauResonanceMaker to set whether the radius of a given Blatt-Weisskopf category should be fixed of floated
* Modify the methods of LauResonanceMaker to set the radius value and whether it should be floated so that they work before and after the resonances have been created
9th October 2014 John Back
* Corrected the eta-eta' and 4pi phase space factors in LauKMatrixPropagator,
which is used for the K-matrix amplitude:
- calcEtaEtaPRho() does not include the mass difference term m_eta - m_eta'
following the recommendation in hep-ph/0204328 and from advice from M Pennington
- calcFourPiRho() incorporates a better parameterisation of the double integral of Eq 4 in
hep-ph/0204328 which avoids the exponential increase for small values of s (~< 0.1)
- More detailed comments are provided in the above two functions to explain what is
going on and the reason for the choices made
6th October 2014 Thomas Latham
* Implement the mechanism for floating Blatt-Weisskopf barrier factor radius parameters
30th September 2014 Thomas Latham
* Fix issue in the checks on toy MC generation validity
- in the case of exceeding max iterations it was possible to enter an infinite loop
- the checks now detect all three possible states:
- aSqMaxSet_ is too low (generation is biased) => increase aSqMaxSet_ value
- aSqMaxSet_ is too high => reduce aSqMaxSet_ value to improve efficiency
- aSqMaxSet_ is high (causing low efficiency) but cannot be lowered without biasing => increase iterationsMax_ limit
* Update resonance parameter in LauResonanceMaker to match PDG 2014
* Modify behaviour when TTree objects are saved into files to avoid having multiple cycle numbers present
29th September 2014 Daniel Craik
* Add support for incoherent resonances in the signal model
- LauIsobarDynamics updated to include incoherent terms
- ABC for incoherent resonances, LauAbsIncohRes, added deriving from LauAbsResonance
- LauGaussIncohRes added to implement a Gaussian incoherent resonance, deriving from LauAbsIncohRes
- Small changes to various other classes to enable incoherent terms
* Fixed small bug in LauMagPhaseCoeffSet which could hang if phase is exactly pi or -pi
* Added charged version of the BelleNR resonances to LauResonanceMaker
* Updated parameters in LauConstants to match PDG 2014
14th July 2014 Thomas Latham
* Add intial support for fully-symmetric final states such as B0 -> KS KS KS
- Performs the symmetrisation of the signal model
- Background (and efficiency) histogram classes need some work if the user wants to provide folded histograms
8th July 2014 Daniel Craik
* Add class for model-independent partial wave
- Uses splines to produce a smooth amplitude from a set of magnitude and phase values at given invariant masses
- The individual magnitudes and phases can be floated in the fit
16th June 2014 Thomas Latham
* Allow floating of resonance parameters in simultaneous fits
13th June 2014 Thomas Latham
* Fix bug in LauResonanceInfo cloning method, where the width parameter was given a clone of the mass
10th June 2014 Thomas Latham
* Add new function to allow sharing of resonance parameters between components that are not charged conjugates, e.g. LASS_BW and LASS_NR
9th June 2014 Thomas Latham and Daniel Craik
* Fix bug in the new integration scheme
- Was not accounting for cases where several resonances share a floating parameter
- Meant that the integrals and caches for that resonance were not being updated
* Introduce a change in the implementation of the helicity flip for neutral parent decays
- Prior to this change the helicity was flipped for any neutral resonance in the decay of a neutral particle.
- Now the flip no longer occurs in flavour-specific decays (such as Bs0 -> D0bar K- pi+ or B0 -> K+ pi- pi0) since it is only required in flavour-conjugate modes (such as B0 -> KS pi+ pi-).
- This does not affect any physical results but it does contribute a pi phase flip to some odd-spin resonances (for example K*(892)0 in Bs0->D0barKpi).
- Therefore results are not necessarily comparable between fits run before and after this changeset.
- This change will first be released in v3r0.
===
## Laura++ v2r2
5th June 2014 Thomas Latham
* Fix issue in asymmetric efficiency histogram errors
- Fluctuation of bins was incorrectly sampling - assumed area each side of peak was the same
5th June 2014 Thomas Latham
(in branch for release in v3r0)
* Introduce intelligent calculation of amplitudes during recalculation of integrals and recaching of data points
- Floating resonance parameters is now much more efficient
* Make resonance parameters second-stage, also improves fit timing when floating them
3rd June 2014 Rafael Coutinho
* Implement generation of toy MC from fit results in fitSlave
27th May 2014 Thomas Latham
(in branch for release in v3r0)
* Complete audit of special functions
* Remove unncessary LauAbsDPDynamics base class and move all functionality into LauIsobarDynamics
20th May 2014 Daniel Craik
(in branch for release in v3r0)
* Add support for K*_0(1430) and a_0(980) to LauFlatteRes
16th-19th May 2014 Thomas Latham and Daniel Craik
(in branch for release in v3r0)
* Update all other lineshapes so that their parameters can float
- The only resonance parameters that now cannot float are the Blatt-Weisskopf barrier factor radii
15th May 2014 Thomas Latham
(in branch for release in v3r0)
* Change the mechanism for getting floating resonance parameters into the fit
- Moved from LauResonanceMaker to the resonances themselves
- Lays some groundwork for improving the efficiency of recalculating the integrals
- LauBelleNR and LauBelleSymNR lineshape parameters can now be floated
13th May 2014 Daniel Craik
(in branch for release in v3r0)
* Fix bug where illegal characters were being propagated from resonance names into TBranch names
6th May 2014 Thomas Latham
(in branch for release in v3r0)
* Provide accessors for mass and width parameters
5th May 2014 Louis Henry
* Fix compilation problem by making LauDatabasePDG destructor virtual
4th May 2014 Thomas Latham
* Provide a new argument to LauSimpleFitModel::splitSignalComponent and
LauCPFitModel::splitSignalComponent to allow fluctuation of the bins on the
SCF fraction histogram
29th April 2014 Thomas Latham
* Fix bug in the determination of the integration scheme
- Nearby narrow resonances caused problems if their "zones" overlap
- These zones are now merged together
29th April 2014 Thomas Latham
(in branch for release in v3r0)
* Some improvments to integration scheme storage
26th April 2014 Juan Otalora
(in branch for release in v3r0)
* Make integation scheme fixed after first determination
- is stored in a new class LauDPPartialIntegralInfo
- used on subsequent re-evaluations of the integrals
23rd April 2014 Thomas Latham
* Attempt to improve clarity of LauIsobarDynamics::addResonance function
- the 3rd argument is now an enumeration of the various resonance models
- removed the optional arguments regarding the change of mass, width & spin
- the same functionality can be obtained by using the returned pointer and calling changeResonance
- the resonance name now only affects the lineshape in the LauPolNR case
- the BelleSymNR / TaylorNR choice is now made in the 3rd argument
- similarly for the BelleNR / (newly introduced) PowerLawNR choice
* Add new PowerLawNR nonresonant model (part of LauBelleNR)
* All examples updated to use new interface
23rd April 2014 Thomas Latham
* Address issue of setting values of resonance parameters for all models
- decided to do away with need to have LauIsobarDynamics know everything
- LauIsobarDynamics::addResonance now returns a pointer to LauAbsResonance
- parameters can be changed through LauAbsResonance::setResonanceParameter
- LauIsobarDynamics still knows about Blatt-Weisskopf factors - better to only need to set this once
- Update GenFit3pi example to demonstrate mechanism
22nd April 2014 Thomas Latham
* Allow Gaussian constraints to be added in simultaneous fitting
- constraints will be ignored by the slaves
- those added directly to fit parameters will be propogated to the master and handled there
- those on combinations of parameters should be added in the master process
22nd April 2014 Mark Whitehead
* Update Laura to cope with resonances of spin 4 and spin 5
- Zemach spin terms added to src/LauAbsResonance.cc
- BW barrier factors added to src/LauRelBreitWignerRes.cc
19th April 2014 Daniel Craik
* Add LauWeightedSumEffModel which gives an efficiency model from the weighted sum of several LauEffModel objects.
* Added pABC, LauAbsEffModel, for LauEffModel and LauWeightedSumEffModel.
* Various classes updated to use pointers to LauAbsEffModel instead of LauEffModel.
15th April 2014 Daniel Craik
* Enable LauEfficiencyModel to contain several Lau2DAbsDP objects with the total efficiency calculated as the product.
10th April 2014 Mark Whitehead
* Fix an issue with the likelihood penalty term for Gaussian constraints
- Factor two missing in the denominator
- New penalty term is: ( x-mean )^2 / 2*(width^2)
4th April 2014 Thomas Latham
* Add storage of fit fractions that have not been efficiency corrected
===
## Laura++ v2r1
1st April 2014 Thomas Latham
* Fix issue in LauFitter that prevents compilation with g++ 4.8
- Missing virtual destructor
- Take opportunity to audit other special functions
31st March 2014 Mark Whitehead
(in branch for release in v2r1)
* Added an efficiency branch to the ntuple produced for toy data samples
- Both LauSimpleFitModel and LauCPFitModel updated
28th March 2014 Daniel Craik
(in branch for release in v2r2)
* Added support for asymmetric errors to Lau2DHistDP, Lau2DSplineDP and LauEffModel.
27th March 2014 Daniel Craik
* Changed histogram classes to use seeded random number generator for
fluctuation and raising or lowering of bins and updated doxygen.
20th March 2014 Mark Whitehead
(in branch for release in v2r1)
* Added the ability to add Gaussian contraints to LauFormulaPars of fit parameters
- User supplies the information but the LauFormulaPar is constructed behind the scenes
18th March 2014 Thomas Latham
* Improve behaviour of toy generation from fit results
13th March 2014 Juan Otalora
(in branch for release in v3r0)
* Extended ability to float mass and width to other resonance lineshapes (Flatte, LASS and G-S)
11th March 2014 Mark Whitehead
(in branch for release in v2r1)
* Added the functionality to make LauFormulaPars usable in fits
- Added a new class LauAbsRValue which LauParameter and LauFormularPar inherit from
- Many files updated to accept LauAbsRValues instead of LauParameters
* Fairly major clean up of obsolete functions in LauAbsPdf
- Only LauLinearPdf used any of them, this has now been updated
10th March 2014 Thomas Latham
(in branch for release in v3r0)
* First attempt at floating resonance parameters (work mostly from Juan)
- Only works for RelBW lineshape
- Can only float mass and width
- Works nicely!
- Still needs much work to generalise and make more efficient
===
## Laura++ v2r0
8th March 2014 Thomas Latham
* Some additional functionality for the CoeffSet classes:
- allow the parameter values to be set (optionally setting the initial and generated values as well)
- allow the parameters to be set to float or to be fixed in the fit
These are needed when cloning but wanting some of the parameters to have different values and/or floating behaviour from the cloned set.
* Improve the printout of the setting of the coefficient values in the fit models and the creation of resonances
* Add LauFlatNR for the unform NR model - ends its rather strange special treatment
* Fix bug setting resAmpInt to 0 for LauPolNR
* Many other improvements to the info/warning/error printouts
* Modify GenFitBelleCPKpipi example to demonstrate cloning in action
* Add -Werror to compiler flags (treats warnings as errors)
5th March 2014 Thomas Latham
* Some improvements to LauPolNR to speed up amplitude calculation
2nd March 2014 Thomas Latham
* A number of updates to the CoeffSet classes:
- allow specification of the basename just after construction (before being given to the fit model)
- allow configuration of the parameter fit ranges (through static methods of base class)
- more adaptable cloning of the parameters (e.g. can only clone phase but allow magnitude to float independently)
- allow CP-violating parameters to be second-stage in Belle and CLEO formats
* Some improvements to the Doxygen and runtime information printouts
20th February 2014 Louis Henry
* Add LauPolNR - class for modelling the nonresonant contribution based on BaBar 3K model (arXiv:1201.5897)
6th February 2014 Thomas Latham
* Correct helicity convention information in Doxygen for LauKinematics
===
## Laura++ v1r2
5th February 2014 Thomas Latham
* Add rule to the Makefile that creates a rootmap file for the library
4th February 2014 Daniel Craik
* Fixed bug in Lau2DSplineDPPdf - normalisation was not being calculated
* Added out-of-range warning in LauBkgndDPModel and supressed excessive warnings
3rd February 2014 Mark Whitehead
(in branch for release in v2r0)
* Added a new class to allow parameters to be a function of other parameters
- inc/LauFormulaPar.hh
- src/LauFormulaPar.cc
28th January 2014 Daniel Craik
* Improved out-of-range efficiency warnings in LauEffModel and supressed excessive errors
* Modified LauIsobarDynamics to allow LASS parameters to be configured for LauLASSBWRes and
LauLASSNRRes
27th January 2014 Daniel Craik
* Added spline interpolation to DP backgrounds
- Added Lau2DSplineDPPdf which uses a spline to model a normalised PDF across a DP
- Added pABC, Lau2DAbsDPPdf, for Lau2DHistDPPdf and Lau2DSplineDPPdf and moved common
code in Lau2DHistDPPdf and Lau2DSplineDPPdf into ABC Lau2DAbsHistDPPdf
- LauBkgndDPModel, modified to use Lau2DAbsDPPdf instead of Lau2DHistDPPdf
- setBkgndSpline method added to LauBkgndDPModel to allow use of splines
22nd January 2014 Thomas Latham
* Improve some error checks and corresponding warning messages in
LauCPFitModel::setSignalDPParameters
16th January 2014 Thomas Latham
* Add LauRealImagCPCoeffSet, which provides an (x,y), (xbar,ybar) way of
parametrising the complex coefficients.
* Try to improve timing in the *CoeffSet classes by making the complex coeffs
into member variables.
20th December 2013 Daniel Craik
* Added Lau2DCubicSpline which provides cubic spline interpolation of a histogram
- Added Lau2DSplineDP which uses a spline to model variation across a DP (eg efficiency)
- Added pABC, Lau2DAbsDP, for Lau2DHistDP and Lau2DSplineDP and moved common code
in Lau2DHistDP and Lau2DSplineDP into ABC Lau2DAbsHistDP
- LauEffModel, LauDPDepSumPdf and LauDPDepMapPdf modified to use Lau2DAbsDP instead of
Lau2DHistDP
- setEffSpline method added to LauEffModel and useSpline flag added to constructor for
LauDPDepSumPdf to allow use of splines
18th December 2013 Mark Whitehead
(in branch for release in v2r0)
* Added functionality to include Gaussian constraints on floated
parameters in the fit.
The files updated are:
- inc/LauAbsFitModel.hh
- inc/LauParameter.hh
- src/LauAbsFitModel.cc
- src/LauParameter.cc
5th December 2013 Thomas Latham
* Fix small bug in GenFitKpipi example where background asymmetry parameter had
its limits the wrong way around
4th December 2013 Daniel Craik
* Updated 2D chi-squared code to use adaptive binning.
3rd December 2013 Thomas Latham
* Generalise the Makefile in the examples directory
- results in minor changes to the names of 3 of the binaries
3rd December 2013 Thomas Latham
(in branch for release in v2r0)
* Have the master save an ntuple with all fitter parameters and the full correlation matrix information.
29th November 2013 Thomas Latham
* Fixed bug in ResultsExtractor where the output file was not written
29th November 2013 Thomas Latham
(in branch for release in v2r0)
* Allow the slave ntuples to store the partial covariance matrices in the simultaneous fitting
26th November 2013 Thomas Latham
(in branch for release in v2r0)
* Added first version of the simultaneous fitting framework
===
## Laura++ v1r1p1
22nd November 2013 Thomas Latham
* Fixed bug in LauCPFitModel where values of q = -1 extra PDFs
were used regardless of the event charge.
===
## Laura++ v1r1
20th November 2013 Mark Whitehead
* Changed convention for the barrier factors, swapping from p* to p.
This seems to give more physically reasonable results.
The files updated are:
- src/LauGounarisSakuraiRes.cc
- src/LauRelBreitWignerRes.cc
18th October 2013 Thomas Latham
* Fix dependency problem in Makefile
8th October 2013 Thomas Latham
* Some fixes to yield implementation
* Minor bug fix in DP background histogram class
7th October 2013 Mark Whitehead
* Update to accept the yields and yield asymmetries as LauParameters.
All examples have been updated to reflect this change.
This updated the following files:
- inc/LauCPFitModel.hh
- inc/LauSimpleFitModel.hh
- inc/LauAbsFitModel.hh
- src/LauCPFitModel.cc
- src/LauSimpleFitModel.cc
* Addition of the following particles to src/LauResonanceMaker.cc
Ds*+-, Ds0*(2317)+-, Ds2*(2573)+-, Ds1*(2700)+- and Bs*0
===
## Laura++ v1r0
13th September 2013 Thomas Latham
* Initial import of the package into HEPforge
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 8cec73f..70c4d2a 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1,42 +1,43 @@
list(APPEND EXAMPLE_SOURCES
B3piKMatrixMassProj
B3piKMatrixPlots
CalcChiSq
GenFit3K
GenFit3KS
GenFit3pi
GenFitBelleCPKpipi
+ GenFitDpipi
GenFitDs2KKpi
GenFitEFKLLM
GenFitKpipi
GenFitNoDP
GenFitNoDPMultiDim
KMatrixDto3pi
KMatrixExample
MergeDataFiles
mixedSampleTest
PlotKMatrixTAmp
PlotResults
point2PointTestSample
QuasiFlatSqDalitz
ResultsExtractor
SimFitCoordinator
SimFitTask
SimFitTaskRooFit
)
if(NOT LAURA_BUILD_ROOFIT_TASK)
list(REMOVE_ITEM EXAMPLE_SOURCES SimFitTaskRooFit)
endif()
foreach( _example ${EXAMPLE_SOURCES})
add_executable(${_example} ${_example}.cc)
target_link_libraries(${_example} PRIVATE Laura++)
install(TARGETS ${_example} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
endforeach()
# Also install the python script version of GenFit3pi
configure_file(GenFit3pi.py.in GenFit3pi.py @ONLY)
install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/GenFit3pi.py DESTINATION ${CMAKE_INSTALL_BINDIR})
diff --git a/examples/GenFitDpipi.cc b/examples/GenFitDpipi.cc
new file mode 100644
index 0000000..eec4572
--- /dev/null
+++ b/examples/GenFitDpipi.cc
@@ -0,0 +1,224 @@
+
+#include <cstdlib>
+#include <iostream>
+#include <vector>
+
+#include "TFile.h"
+#include "TH2.h"
+#include "TString.h"
+#include "TTree.h"
+
+#include "LauSimpleFitModel.hh"
+#include "LauResonanceMaker.hh"
+#include "LauBkgndDPModel.hh"
+#include "LauDaughters.hh"
+#include "LauEffModel.hh"
+#include "LauIsobarDynamics.hh"
+#include "LauMagPhaseCoeffSet.hh"
+#include "LauRealImagCoeffSet.hh"
+#include "LauRandom.hh"
+#include "LauVetoes.hh"
+#include "LauAbsModIndPartWave.hh"
+#include "LauModIndPartWaveRealImag.hh"
+#include "LauModIndPartWaveMagPhase.hh"
+
+void usage( std::ostream& out, const TString& progName )
+{
+ out<<"Usage:\n";
+ out<<progName<<" gen [nExpt = 1] [firstExpt = 0]\n";
+ out<<"or\n";
+ out<<progName<<" fit <iFit> [nExpt = 1] [firstExpt = 0]"<<std::endl;
+ out<<"or\n";
+ out<<progName<<" plot"<<std::endl;
+}
+
+int main( int argc, char** argv )
+{
+ // Process command-line arguments
+ // Usage:
+ // ./GenFitDpipi gen [nExpt = 1] [firstExpt = 0]
+ // or
+ // ./GenFitDpipi fit <iFit> [nExpt = 1] [firstExpt = 0]
+ if ( argc < 2 ) {
+ usage( std::cerr, argv[0] );
+ return EXIT_FAILURE;
+ }
+
+ TString command = argv[1];
+ command.ToLower();
+ Int_t iFit(0);
+ Int_t nExpt(1);
+ Int_t firstExpt(0);
+ if ( command == "gen" ) {
+ if ( argc > 2 ) {
+ nExpt = atoi( argv[2] );
+ if ( argc > 3 ) {
+ firstExpt = atoi( argv[3] );
+ }
+ }
+ } else if ( command == "fit" ) {
+ if ( argc < 3 ) {
+ usage( std::cerr, argv[0] );
+ return EXIT_FAILURE;
+ }
+ iFit = atoi( argv[2] );
+ if ( argc > 3 ) {
+ nExpt = atoi( argv[3] );
+ if ( argc > 4 ) {
+ firstExpt = atoi( argv[4] );
+ }
+ }
+ } else {
+ usage( std::cerr, argv[0] );
+ return EXIT_FAILURE;
+ }
+
+ // If you want to use square DP histograms for efficiency,
+ // backgrounds or you just want the square DP co-ordinates
+ // stored in the toy MC ntuple then set this to kTRUE
+ Bool_t squareDP = kTRUE;
+
+ // This defines the DP => decay is B+ -> pi+ pi+ D-
+ // Particle 1 = pi+
+ // Particle 2 = pi+
+ // Particle 3 = D-
+ // The DP is defined in terms of m13Sq and m23Sq
+ LauDaughters* daughters = new LauDaughters("B+", "pi+", "pi+", "D-", squareDP);
+
+ // Optionally apply some vetoes to the DP
+ LauVetoes* vetoes = new LauVetoes();
+
+ LauEffModel* effModel = new LauEffModel(daughters, vetoes);
+
+ // Set the values of the Blatt-Weisskopf barrier radii and whether they are fixed or floating
+ LauResonanceMaker& resMaker = LauResonanceMaker::get();
+ resMaker.setDefaultBWRadius( LauBlattWeisskopfFactor::Parent, 4.0 );
+ resMaker.setDefaultBWRadius( LauBlattWeisskopfFactor::Charm, 4.0 );
+ resMaker.setDefaultBWRadius( LauBlattWeisskopfFactor::Light, 4.0 );
+ resMaker.setDefaultBWRadius( LauBlattWeisskopfFactor::Beauty, 4.0 );
+ resMaker.fixBWRadius( LauBlattWeisskopfFactor::Parent, kTRUE);
+ resMaker.fixBWRadius( LauBlattWeisskopfFactor::Charm, kTRUE);
+ resMaker.fixBWRadius( LauBlattWeisskopfFactor::Light, kTRUE);
+ resMaker.fixBWRadius( LauBlattWeisskopfFactor::Beauty, kTRUE);
+ // Create the isobar model
+
+ std::vector<LauAbsCoeffSet*> coeffset;
+ LauIsobarDynamics* sigModel = new LauIsobarDynamics(daughters, effModel);
+ LauAbsResonance* reson(0);
+
+ reson = sigModel->addResonance("D*0", 2, LauAbsResonance::RelBW);
+ reson = sigModel->addResonance("D*0_0", 2, LauAbsResonance::MIPW_MagPhase);
+ LauModIndPartWaveMagPhase* mipw = dynamic_cast<LauModIndPartWaveMagPhase*>(reson);
+ if (mipw==nullptr){
+ std::cout << "MIPW pointer is null" << std::endl;
+ return 0;
+ }
+
+ //vector of knot masses - ignore ends as they are dealt with internally
+ std::set<Double_t> knot_mass{
+ 2.10,
+ 2.20,
+ 2.30,
+ 2.40,
+ 2.50,
+ 2.60,
+ 2.70,
+ 2.80,
+ 2.90,
+ 3.10,
+ 4.10,
+ };
+
+ mipw->defineKnots(knot_mass);
+ mipw->floatKnotsSecondStage(kFALSE);
+
+ //Set magnitude and phase for the knots (including the end points here)
+ mipw->setKnotAmp(0, 0.12, -2.82,kFALSE,kFALSE);
+ mipw->setKnotAmp(1, 0.58, -1.56,kFALSE,kFALSE);
+ mipw->setKnotAmp(2, 0.73, -1.00,kFALSE,kFALSE);
+ mipw->setKnotAmp(3, 0.68, -0.42,kFALSE,kFALSE);
+ mipw->setKnotAmp(4, 0.5, 0.0,kTRUE,kTRUE);
+ mipw->setKnotAmp(5, 0.23, -0.00,kFALSE,kFALSE);
+ mipw->setKnotAmp(6, 0.23, -0.42,kFALSE,kFALSE);
+ mipw->setKnotAmp(7, 0.15, -0.31,kFALSE,kFALSE);
+ mipw->setKnotAmp(8, 0.17, -0.63,kFALSE,kFALSE);
+ mipw->setKnotAmp(9, 0.20, -0.87,kFALSE,kFALSE);
+ mipw->setKnotAmp(10, 0.14, -1.16,kFALSE,kFALSE);
+ mipw->setKnotAmp(11, 0.08, 1.02,kFALSE,kFALSE);
+ mipw->setKnotAmp(12, 0.0, 0.0,kTRUE, kTRUE);
+
+ reson = sigModel->addResonance("D*0_2", 2, LauAbsResonance::RelBW);
+ reson = sigModel->addResonance("D*0_1(2680)", 2, LauAbsResonance::RelBW);
+ reson = sigModel->addResonance("B*0", 2, LauAbsResonance::RelBW);
+ reson = sigModel->addResonance("D*0_3(2760)", 2, LauAbsResonance::RelBW);
+ reson = sigModel->addResonance("D0(3000)", 2, LauAbsResonance::RelBW);
+
+ sigModel->setASqMaxValue(1.0);
+
+ // Create the fit model
+ LauSimpleFitModel* fitModel = new LauSimpleFitModel(sigModel);
+
+ coeffset.push_back( new LauMagPhaseCoeffSet("D*0", 0.55, -0.38, kFALSE, kFALSE) );
+ coeffset.push_back( new LauMagPhaseCoeffSet("D*0_0", 1.26, -0.28, kFALSE, kFALSE) ); // Still need a total mag/phase for the MIPW shape
+ coeffset.push_back( new LauMagPhaseCoeffSet("D*0_2", 1.00, 0.00, kTRUE, kTRUE) );
+ coeffset.push_back( new LauMagPhaseCoeffSet("D*0_1(2680)", 0.48, 2.47, kFALSE, kFALSE) );
+ coeffset.push_back( new LauMagPhaseCoeffSet("B*0", 0.27, 0.14, kFALSE, kFALSE) );
+ coeffset.push_back( new LauMagPhaseCoeffSet("D*0_3(2760)", 0.17, 0.01, kFALSE, kFALSE) );
+ coeffset.push_back( new LauMagPhaseCoeffSet("D0(3000)", 0.08, -0.84, kFALSE, kFALSE) );
+
+ for (std::vector<LauAbsCoeffSet*>::iterator iter=coeffset.begin(); iter!=coeffset.end(); ++iter) {
+ fitModel->setAmpCoeffSet(*iter);
+ }
+
+ Double_t nSig(50000);
+
+ TString sigEventsName = "signalEvents";
+ LauParameter* nSigEvents = new LauParameter(sigEventsName,nSig,-2.0*nSig,2.0*nSig,kTRUE);
+ fitModel->setNSigEvents(nSigEvents);
+
+ // Set the number of experiments to generate or fit and which
+ // experiment to start with
+ fitModel->setNExpts( nExpt, firstExpt );
+
+ // Switch on/off calculation of asymmetric errors.
+ fitModel->useAsymmFitErrors(kFALSE);
+
+ // Randomise initial fit values for the signal mode
+ fitModel->useRandomInitFitPars(kTRUE);
+
+ // Switch on/off Poissonian smearing of total number of events
+ fitModel->doPoissonSmearing(kTRUE);
+
+ // Switch on/off Extended ML Fit option
+ fitModel->doEMLFit(kFALSE);
+
+ // Switch on the two-stage fit (for the resonance parameters)
+ fitModel->twoStageFit(kFALSE);
+
+ // Generate toy from the fitted parameters
+ //TString fitToyFileName("fitToyMC_Dpipi_");
+ //fitToyFileName += iFit;
+ //fitToyFileName += ".root";
+ //fitModel->compareFitData(100, fitToyFileName);
+
+ // Set the names of the files to read/write
+ TString dataFile("gen-Dpipi.root");
+ TString treeName("genResults");
+ TString rootFileName("");
+ TString tableFileName("");
+ if (command == "fit") {
+ rootFileName = "fitDpipi_"; rootFileName += iFit;
+ rootFileName += "_expt_"; rootFileName += firstExpt;
+ rootFileName += "-"; rootFileName += (firstExpt+nExpt-1);
+ rootFileName += ".root";
+ tableFileName = "fitDpipiResults_"; tableFileName += iFit;
+ } else {
+ rootFileName = "dummy.root";
+ tableFileName = "genDpipiResults";
+ }
+
+ // Execute the generation/fit
+ fitModel->run( command, dataFile, treeName, rootFileName, tableFileName );
+
+ return EXIT_SUCCESS;
+}
diff --git a/examples/SimFitTask.cc b/examples/SimFitTask.cc
index 6974754..0c7af6d 100644
--- a/examples/SimFitTask.cc
+++ b/examples/SimFitTask.cc
@@ -1,254 +1,252 @@
/*
Copyright 2013 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
*/
#include <cstdlib>
#include <iostream>
#include <vector>
#include "TFile.h"
#include "TH2.h"
#include "TString.h"
#include "TTree.h"
#include "LauSimpleFitModel.hh"
#include "LauBkgndDPModel.hh"
#include "LauDaughters.hh"
#include "LauEffModel.hh"
#include "LauIsobarDynamics.hh"
#include "LauMagPhaseCoeffSet.hh"
#include "LauRandom.hh"
#include "LauVetoes.hh"
void usage( std::ostream& out, const TString& progName )
{
out<<"Usage:\n";
out<<progName<<" gen <category = DD or LL> [nExpt = 1] [firstExpt = 0]\n";
out<<"or\n";
out<<progName<<" fit <category = DD or LL> <iFit> <port> [hostname] [nExpt = 1] [firstExpt = 0]"<<std::endl;
}
int main( int argc, char** argv )
{
// Process command-line arguments
// Usage:
// ./SimFitTask gen <category = DD or LL> [nExpt = 1] [firstExpt = 0]
// or
// ./SimFitTask fit <category = DD or LL> <iFit> <port> [nExpt = 1] [firstExpt = 0]
if ( argc < 3 ) {
usage( std::cerr, argv[0] );
return EXIT_FAILURE;
}
TString command = argv[1];
command.ToLower();
TString category = argv[2];
if ( category != "DD" && category != "LL" ) {
usage( std::cerr, argv[0] );
return EXIT_FAILURE;
}
Int_t iFit(0);
UInt_t port(5000);
TString hostname("localhost");
Int_t nExpt(1);
Int_t firstExpt(0);
if ( command == "gen" ) {
if ( argc > 3 ) {
nExpt = atoi( argv[3] );
if ( argc > 4 ) {
firstExpt = atoi( argv[4] );
}
}
} else if ( command == "fit" ) {
if ( argc < 5 ) {
usage( std::cerr, argv[0] );
return EXIT_FAILURE;
}
iFit = atoi( argv[3] );
port = atoi( argv[4] );
if ( argc > 5 ) {
hostname = argv[5];
if ( argc > 6 ) {
nExpt = atoi( argv[6] );
if ( argc > 7 ) {
firstExpt = atoi( argv[7] );
}
}
}
} else {
usage( std::cerr, argv[0] );
return EXIT_FAILURE;
}
- LauRandom::setSeed(0);
-
// If you want to use square DP histograms for efficiency,
// backgrounds or you just want the square DP co-ordinates
// stored in the toy MC ntuple then set this to kTRUE
Bool_t squareDP = kFALSE;
// This defines the DP => decay is B0 -> pi0 pi0 K_S0
// Particle 1 = pi0
// Particle 2 = pi0
// Particle 3 = KS_0
// The DP is defined in terms of m13Sq and m23Sq
LauDaughters* daughters = new LauDaughters("B0", "pi0", "pi0", "K_S0", squareDP);
// Optionally apply some vetoes to the DP
LauVetoes* vetoes = new LauVetoes();
// Define the efficiency model (defaults to unity everywhere)
// Can optionally provide a histogram to model variation over DP
// (example syntax given in commented-out section)
LauEffModel* effModel = new LauEffModel(daughters, vetoes);
//TFile *effHistFile = TFile::Open("histoFiles/efficiency.root", "read");
//TH2* effHist = dynamic_cast<TH2*>(effHistFile->Get("effHist"));
//Bool_t useInterpolation = kTRUE;
//Bool_t fluctuateBins = kFALSE;
//Bool_t useUpperHalf = kTRUE;
//effModel->setEffHisto(effHist, useInterpolation, fluctuateBins, 0.0, 0.0, useUpperHalf, squareDP);
// Create the isobar model
LauIsobarDynamics* sigModel = new LauIsobarDynamics(daughters, effModel);
LauAbsResonance* res(0);
res = sigModel->addResonance("f_0(980)", 3, LauAbsResonance::Flatte); // resPairAmpInt = 3 => resonance mass is m12.
res = sigModel->addResonance("f_2(1270)", 3, LauAbsResonance::RelBW);
res = sigModel->addResonance("K*0(892)", 1, LauAbsResonance::RelBW);
res->fixMass(kFALSE);
res = sigModel->addResonance("K*0_0(1430)", 1, LauAbsResonance::LASS);
// Reset the maximum signal DP ASq value
// This will be automatically adjusted to avoid bias or extreme
// inefficiency if you get the value wrong but best to set this by
// hand once you've found the right value through some trial and
// error.
sigModel->setASqMaxValue(1.25);
TString integralsFileName("integ-");
integralsFileName += category;
integralsFileName += ".dat";
sigModel->setIntFileName( integralsFileName );
// Create the fit model
LauSimpleFitModel* fitModel = new LauSimpleFitModel(sigModel);
// Create the complex coefficients for the isobar model
// Here we're using the magnitude and phase form:
// c_j = a_j exp(i*delta_j)
std::vector<LauAbsCoeffSet*> coeffset;
coeffset.push_back( new LauMagPhaseCoeffSet("f_0(980)", 1.00, 0.00, kTRUE, kTRUE) );
coeffset.push_back( new LauMagPhaseCoeffSet("f_2(1270)", 0.53, 1.39, kFALSE, kFALSE) );
coeffset.push_back( new LauMagPhaseCoeffSet("K*0(892)", 0.87, 1.99, kFALSE, kFALSE) );
coeffset.push_back( new LauMagPhaseCoeffSet("K*0_0(1430)", 1.17, -1.59, kFALSE, kFALSE) );
for (std::vector<LauAbsCoeffSet*>::iterator iter=coeffset.begin(); iter!=coeffset.end(); ++iter) {
fitModel->setAmpCoeffSet(*iter);
}
// Set the signal yield and define whether it is fixed or floated
TString sigEventsName = "signalEvents" + category;
Double_t nSig(500.0);
if ( category == "DD" ) {
nSig = 750.0;
}
LauParameter * nSigEvents = new LauParameter(sigEventsName,nSig,-2.0*nSig,2.0*nSig,kFALSE);
fitModel->setNSigEvents(nSigEvents);
// Set the number of experiments to generate or fit and which
// experiment to start with
fitModel->setNExpts( nExpt, firstExpt );
// Optionally load in continuum background DP model histogram
// (example syntax given in commented-out section)
std::vector<TString> bkgndNames(1);
bkgndNames[0] = "comb" + category;
fitModel->setBkgndClassNames( bkgndNames );
Double_t nBkgnd = 1200.0;
if ( category == "DD" ) {
nBkgnd = 2500.0;
}
LauParameter* nBkgndEvents = new LauParameter(bkgndNames[0],nBkgnd,-2.0*nBkgnd,2.0*nBkgnd,kFALSE);
fitModel->setNBkgndEvents( nBkgndEvents );
//TString bkgndFileName("histoFiles/bkgndDPs.root");
//TFile* bkgndFile = TFile::Open(bkgndFileName.Data(), "read");
//TH2* bkgndDP = dynamic_cast<TH2*>(bkgndFile->Get("AllmTheta")); // m', theta'
LauBkgndDPModel* bkgndModel = new LauBkgndDPModel(daughters, vetoes);
//bkgndModel->setBkgndHisto(bkgndDP, useInterpolation, fluctuateBins, useUpperHalf, squareDP);
fitModel->setBkgndDPModel( bkgndNames[0], bkgndModel );
// Randomise initial fit values for the signal mode
fitModel->useRandomInitFitPars(kTRUE);
const Bool_t haveBkgnds = ( fitModel->nBkgndClasses() > 0 );
// Switch on/off Poissonian smearing of total number of events
fitModel->doPoissonSmearing(haveBkgnds);
// Switch on/off Extended ML Fit option
fitModel->doEMLFit(haveBkgnds);
// Activate two-stage fit
fitModel->twoStageFit(kTRUE);
// Generate toy from the fitted parameters
//TString fitToyFileName("fitToyMC_");
//fitToyFileName += category;
//fitToyFileName += "-Task_";
//fitToyFileName += iFit;
//fitToyFileName += ".root";
//fitModel->compareFitData(100, fitToyFileName);
// Write out per-event likelihoods and sWeights
//TString splotFileName("splot_");
//splotFileName += category;
//splotFileName += "-Task_";
//splotFileName += iFit;
//splotFileName += ".root";
//fitModel->writeSPlotData(splotFileName, "splot", kFALSE);
// Set the names of the files to read/write
TString dataFile("gen-"); dataFile += category; dataFile += "-Task.root";
TString treeName("genResults");
TString rootFileName("");
TString tableFileName("");
if (command == "fit") {
rootFileName = "fit"; rootFileName += category; rootFileName += "-Task_"; rootFileName += iFit;
rootFileName += "_expt_"; rootFileName += firstExpt;
rootFileName += "-"; rootFileName += (firstExpt+nExpt-1);
rootFileName += ".root";
tableFileName = "fit"; tableFileName += category; tableFileName += "TaskResults_"; tableFileName += iFit;
} else {
rootFileName = "dummy.root";
tableFileName = "gen"; tableFileName += category; tableFileName += "TaskResults_";
}
// Execute the generation/fit
if ( command == "fit" ) {
fitModel->runTask( dataFile, treeName, rootFileName, tableFileName, hostname, port );
} else {
fitModel->run( command, dataFile, treeName, rootFileName, tableFileName );
}
return EXIT_SUCCESS;
}
diff --git a/src/LauResonanceMaker.cc b/src/LauResonanceMaker.cc
index f6beed3..31065e6 100644
--- a/src/LauResonanceMaker.cc
+++ b/src/LauResonanceMaker.cc
@@ -1,1038 +1,1043 @@
/*
Copyright 2004 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 LauResonanceMaker.cc
\brief File containing implementation of LauResonanceMaker class.
*/
#include <iostream>
#include "LauAbsResonance.hh"
#include "LauBelleNR.hh"
#include "LauBelleSymNR.hh"
#include "LauBreitWignerRes.hh"
#include "LauDabbaRes.hh"
#include "LauDaughters.hh"
#include "LauEFKLLMRes.hh"
#include "LauFlatteRes.hh"
#include "LauFlatNR.hh"
#include "LauGaussIncohRes.hh"
#include "LauGounarisSakuraiRes.hh"
#include "LauKappaRes.hh"
#include "LauLASSRes.hh"
#include "LauLASSBWRes.hh"
#include "LauLASSNRRes.hh"
#include "LauModIndPartWaveMagPhase.hh"
#include "LauModIndPartWaveRealImag.hh"
#include "LauNRAmplitude.hh"
#include "LauRescatteringRes.hh"
#include "LauRescattering2Res.hh"
#include "LauPolNR.hh"
#include "LauPoleRes.hh"
#include "LauPolarFormFactorNR.hh"
#include "LauPolarFormFactorSymNR.hh"
#include "LauRelBreitWignerRes.hh"
#include "LauResonanceInfo.hh"
#include "LauResonanceMaker.hh"
#include "LauRhoOmegaMix.hh"
#include "LauSigmaRes.hh"
ClassImp(LauResonanceMaker);
LauResonanceMaker* LauResonanceMaker::resonanceMaker_ = 0;
LauResonanceMaker::LauResonanceMaker() :
nResDefMax_(0),
bwBarrierType_(LauBlattWeisskopfFactor::BWPrimeBarrier),
bwRestFrame_(LauBlattWeisskopfFactor::ResonanceFrame),
spinFormalism_(LauAbsResonance::Zemach_P),
summaryPrinted_(kFALSE)
{
this->createResonanceVector();
this->setDefaultBWRadius( LauBlattWeisskopfFactor::Parent, 4.0 );
}
LauResonanceMaker::~LauResonanceMaker()
{
for ( std::vector<LauBlattWeisskopfFactor*>::iterator iter = bwIndepFactors_.begin(); iter != bwIndepFactors_.end(); ++iter ) {
delete *iter;
}
bwIndepFactors_.clear();
for ( BWFactorCategoryMap::iterator iter = bwFactors_.begin(); iter != bwFactors_.end(); ++iter ) {
delete iter->second.bwFactor_;
}
bwFactors_.clear();
}
LauResonanceMaker& LauResonanceMaker::get()
{
if ( resonanceMaker_ == 0 ) {
resonanceMaker_ = new LauResonanceMaker();
}
return *resonanceMaker_;
}
void LauResonanceMaker::createResonanceVector()
{
// Function to create all possible resonances that this class supports.
// Also add in the sigma and kappa - but a special paramterisation is used
// instead of the PDG "pole mass and width" values.
std::cout << "INFO in LauResonanceMaker::createResonanceVector : Setting up possible resonance states..." << std::endl;
LauResonanceInfo* neutral(0);
LauResonanceInfo* positve(0);
LauResonanceInfo* negatve(0);
// Define the resonance names and store them in the array
resInfo_.clear();
resInfo_.reserve(100);
// rho resonances name, mass, width, spin, charge, default BW category, BW radius parameter (defaults to 4.0)
// rho(770)
neutral = new LauResonanceInfo("rho0(770)", 0.77526, 0.1478, 1, 0, LauBlattWeisskopfFactor::Light, 5.3);
positve = new LauResonanceInfo("rho+(770)", 0.77511, 0.1491, 1, 1, LauBlattWeisskopfFactor::Light, 5.3);
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// The following two lines of code are placed here in order to allow the following, rather niche, scenario:
// The LauRhoOmegaMix code permits (through the use of the optional independentPar argument of LauResonanceInfo::addExtraParameter) the magnitude and phase of the rho/omega mixing to potentially differ between the decay of the parent particle to rho0 X and the parent antiparticle to rho0 Xbar.
// This can be acheived by using the rho0(770) record in one case and the rho0(770)_COPY record in the other.
neutral = neutral->createSharedParameterRecord("rho0(770)_COPY");
resInfo_.push_back( neutral );
// rho(1450)
neutral = new LauResonanceInfo("rho0(1450)", 1.465, 0.400, 1, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("rho+(1450)", 1.465, 0.400, 1, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// rho_3(1690)
neutral = new LauResonanceInfo("rho0_3(1690)", 1.686, 0.186, 3, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("rho+_3(1690)", 1.686, 0.186, 3, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// rho(1700)
neutral = new LauResonanceInfo("rho0(1700)", 1.720, 0.250, 1, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("rho+(1700)", 1.720, 0.250, 1, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// rho(1900)
neutral = new LauResonanceInfo("rho0(1900)", 1.909, 0.130, 1, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("rho+(1900)", 1.909, 0.130, 1, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// rho_3(1990)
neutral = new LauResonanceInfo("rho0_3(1990)", 1.982, 0.188, 3, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("rho+_3(1990)", 1.982, 0.188, 3, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// K* resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// K*(892)
neutral = new LauResonanceInfo("K*0(892)", 0.89555, 0.0473, 1, 0, LauBlattWeisskopfFactor::Kstar, 3.0);
positve = new LauResonanceInfo("K*+(892)", 0.89166, 0.0508, 1, 1, LauBlattWeisskopfFactor::Kstar, 3.0);
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// K*(1410)
neutral = new LauResonanceInfo("K*0(1410)", 1.414, 0.232, 1, 0, LauBlattWeisskopfFactor::Kstar );
positve = new LauResonanceInfo("K*+(1410)", 1.414, 0.232, 1, 1, LauBlattWeisskopfFactor::Kstar );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// K*_0(1430)
neutral = new LauResonanceInfo("K*0_0(1430)", 1.425, 0.270, 0, 0, LauBlattWeisskopfFactor::Kstar );
positve = new LauResonanceInfo("K*+_0(1430)", 1.425, 0.270, 0, 1, LauBlattWeisskopfFactor::Kstar );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// LASS nonresonant model
neutral = neutral->createSharedParameterRecord("LASSNR0");
positve = positve->createSharedParameterRecord("LASSNR+");
negatve = negatve->createSharedParameterRecord("LASSNR-");
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// K*_2(1430)
neutral = new LauResonanceInfo("K*0_2(1430)", 1.4324, 0.109, 2, 0, LauBlattWeisskopfFactor::Kstar );
positve = new LauResonanceInfo("K*+_2(1430)", 1.4273, 0.100, 2, 1, LauBlattWeisskopfFactor::Kstar );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// K*(1680)
neutral = new LauResonanceInfo("K*0(1680)", 1.718, 0.322, 1, 0, LauBlattWeisskopfFactor::Kstar );
positve = new LauResonanceInfo("K*+(1680)", 1.718, 0.322, 1, 1, LauBlattWeisskopfFactor::Kstar );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// K*(1950)
neutral = new LauResonanceInfo("K*0_0(1950)", 1.945, 0.201, 0, 0, LauBlattWeisskopfFactor::Kstar );
positve = new LauResonanceInfo("K*+_0(1950)", 1.945, 0.201, 0, 1, LauBlattWeisskopfFactor::Kstar );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// phi resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// phi(1020)
neutral = new LauResonanceInfo("phi(1020)", 1.019461, 0.004249, 1, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// phi(1680)
neutral = new LauResonanceInfo("phi(1680)", 1.680, 0.150, 1, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// f_0(980)
neutral = new LauResonanceInfo("f_0(980)", 0.990, 0.070, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(1270)
neutral = new LauResonanceInfo("f_2(1270)", 1.2755, 0.1867, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_0(1370)
neutral = new LauResonanceInfo("f_0(1370)", 1.370, 0.350, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f'_0(1300), from Belle's Kspipi paper
neutral = new LauResonanceInfo("f'_0(1300)", 1.449, 0.126, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(1430)
neutral = new LauResonanceInfo("f_2(1430)", 1.430, 0.150, 2, 0, LauBlattWeisskopfFactor::Light ); // PDG width in the range 13 - 150
resInfo_.push_back( neutral );
// f_0(1500)
neutral = new LauResonanceInfo("f_0(1500)", 1.506, 0.112, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f'_2(1525)
neutral = new LauResonanceInfo("f'_2(1525)", 1.5174, 0.086, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(1565)
neutral = new LauResonanceInfo("f_2(1565)", 1.542, 0.122, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(1640)
neutral = new LauResonanceInfo("f_2(1640)", 1.639, 0.099, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_0(1710)
neutral = new LauResonanceInfo("f_0(1710)", 1.704, 0.123, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(1810)
neutral = new LauResonanceInfo("f_2(1810)", 1.815, 0.197, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(1910)
neutral = new LauResonanceInfo("f_2(1910)", 1.900, 0.167, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(1950)
neutral = new LauResonanceInfo("f_2(1950)", 1.936, 0.464, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_2(2010)
neutral = new LauResonanceInfo("f_2(2010)", 2.011, 0.202, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_0(2020)
neutral = new LauResonanceInfo("f_0(2020)", 1.992, 0.442, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_4(2050)
neutral = new LauResonanceInfo("f_4(2050)", 2.018, 0.237, 4, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// f_0(2100)
neutral = new LauResonanceInfo("f_0(2100)", 2.086, 0.284, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// omega resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// omega(782)
neutral = new LauResonanceInfo("omega(782)", 0.78265, 0.00849, 1, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// a resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// a_0(980)
neutral = new LauResonanceInfo("a0_0(980)", 0.980, 0.092, 0, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("a+_0(980)", 0.980, 0.092, 0, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// a_0(1450)
neutral = new LauResonanceInfo("a0_0(1450)", 1.474, 0.265, 0, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("a+_0(1450)", 1.474, 0.265, 0, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// a_2(1320)
neutral = new LauResonanceInfo("a0_2(1320)", 1.3169, 0.1050, 2, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("a+_2(1320)", 1.3169, 0.1050, 2, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// charmonium resonances name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// chi_c0
neutral = new LauResonanceInfo("chi_c0", 3.41471, 0.0108, 0, 0, LauBlattWeisskopfFactor::Charmonium );
resInfo_.push_back( neutral );
// chi_c1
neutral = new LauResonanceInfo("chi_c1", 3.51067, 0.00084, 0, 0, LauBlattWeisskopfFactor::Charmonium );
resInfo_.push_back( neutral );
// chi_c2
neutral = new LauResonanceInfo("chi_c2", 3.55617, 0.00197, 2, 0, LauBlattWeisskopfFactor::Charmonium );
resInfo_.push_back( neutral );
// psi(3770)
neutral = new LauResonanceInfo("psi(3770)", 3.7737, 0.0272, 1, 0, LauBlattWeisskopfFactor::Charmonium );
resInfo_.push_back( neutral );
// X(3872)
neutral = new LauResonanceInfo("X(3872)", 3.87169, 0.0012, 1, 0, LauBlattWeisskopfFactor::Charmonium );
resInfo_.push_back( neutral );
// chi_c2(2P)
neutral = new LauResonanceInfo("chi_c2(2P)", 3.9222, 0.0353, 2, 0, LauBlattWeisskopfFactor::Charmonium );
resInfo_.push_back( neutral );
// unknown scalars name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// sigma
neutral = new LauResonanceInfo("sigma0", 0.475, 0.550, 0, 0, LauBlattWeisskopfFactor::Light );
positve = new LauResonanceInfo("sigma+", 0.475, 0.550, 0, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// kappa
neutral = new LauResonanceInfo("kappa0", 0.824, 0.478, 0, 0, LauBlattWeisskopfFactor::Kstar );
positve = new LauResonanceInfo("kappa+", 0.824, 0.478, 0, 1, LauBlattWeisskopfFactor::Kstar );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// dabba
neutral = new LauResonanceInfo("dabba0", 2.098, 0.520, 0, 0, LauBlattWeisskopfFactor::Charm );
positve = new LauResonanceInfo("dabba+", 2.098, 0.520, 0, 1, LauBlattWeisskopfFactor::Charm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// excited charm states name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// D*
neutral = new LauResonanceInfo("D*0", 2.00685, 0.0021, 1, 0, LauBlattWeisskopfFactor::Charm );
positve = new LauResonanceInfo("D*+", 2.01026, 83.4e-6, 1, 1, LauBlattWeisskopfFactor::Charm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// D*_0
neutral = new LauResonanceInfo("D*0_0", 2.300, 0.274, 0, 0, LauBlattWeisskopfFactor::Charm );
positve = new LauResonanceInfo("D*+_0", 2.349, 0.221, 0, 1, LauBlattWeisskopfFactor::Charm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// D*_2
//AVERAGE--neutral = new LauResonanceInfo("D*0_2", 2.4618, 0.049, 2, 0 );
neutral = new LauResonanceInfo("D*0_2", 2.4607, 0.0475, 2, 0, LauBlattWeisskopfFactor::Charm );
positve = new LauResonanceInfo("D*+_2", 2.4654, 0.0467, 2, 1, LauBlattWeisskopfFactor::Charm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// D1(2420)
neutral = new LauResonanceInfo("D0_1(2420)", 2.4208, 0.0317, 1, 0, LauBlattWeisskopfFactor::Charm );
positve = new LauResonanceInfo("D+_1(2420)", 2.4232, 0.025, 1, 1, LauBlattWeisskopfFactor::Charm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// D(2600)
//OLD--neutral = new LauResonanceInfo("D0(2600)", 2.6087, 0.093, 0, 0 );
//OLD--positve = new LauResonanceInfo("D+(2600)", 2.6213, 0.093, 0, 1 );
neutral = new LauResonanceInfo("D0(2600)", 2.623, 0.139, 0, 0, LauBlattWeisskopfFactor::Charm );
positve = new LauResonanceInfo("D+(2600)", 2.623, 0.139, 0, 1, LauBlattWeisskopfFactor::Charm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
+ // D(2680)
+ neutral = new LauResonanceInfo("D*0_1(2680)", 2.6811, 0.1867, 1, 0, LauBlattWeisskopfFactor::Charm );
+ resInfo_.push_back( neutral );
// D(2760)
//OLD-- neutral = new LauResonanceInfo("D0(2760)", 2.7633, 0.061, 1, 0 );
//OLD-- positve = new LauResonanceInfo("D+(2760)", 2.7697, 0.061, 1, 1 );
neutral = new LauResonanceInfo("D0(2760)", 2.761, 0.063, 1, 0, LauBlattWeisskopfFactor::Charm );
positve = new LauResonanceInfo("D+(2760)", 2.761, 0.063, 1, 1, LauBlattWeisskopfFactor::Charm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
+ neutral = new LauResonanceInfo("D*0_3(2760)", 2.7755, 0.0953, 3, 0, LauBlattWeisskopfFactor::Charm );
+ resInfo_.push_back( neutral );
// D(2900)
- neutral = new LauResonanceInfo("D0(3000)", 3.214, 0.186, 0, 0, LauBlattWeisskopfFactor::Charm );
+ neutral = new LauResonanceInfo("D0(3000)", 3.214, 0.186, 0, 0, LauBlattWeisskopfFactor::Charm );
resInfo_.push_back( neutral );
// D(3400)
neutral = new LauResonanceInfo("D0(3400)", 3.4, 0.15, 0, 0, LauBlattWeisskopfFactor::Charm );
resInfo_.push_back( neutral );
// excited strange charm name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// Ds*
positve = new LauResonanceInfo("Ds*+", 2.1121, 0.0019, 1, 1, LauBlattWeisskopfFactor::StrangeCharm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// Ds0*(2317)
positve = new LauResonanceInfo("Ds*+_0(2317)", 2.3178, 0.0038, 0, 1, LauBlattWeisskopfFactor::StrangeCharm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// Ds2*(2573)
positve = new LauResonanceInfo("Ds*+_2(2573)", 2.5691, 0.0169, 2, 1, LauBlattWeisskopfFactor::StrangeCharm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// Ds1*(2700)
positve = new LauResonanceInfo("Ds*+_1(2700)", 2.7083, 0.120, 1, 1, LauBlattWeisskopfFactor::StrangeCharm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// Ds1*(2860)
positve = new LauResonanceInfo("Ds*+_1(2860)", 2.859, 0.159, 1, 1, LauBlattWeisskopfFactor::StrangeCharm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// Ds3*(2860)
positve = new LauResonanceInfo("Ds*+_3(2860)", 2.860, 0.053, 3, 1, LauBlattWeisskopfFactor::StrangeCharm );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// excited bottom states name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// B*
neutral = new LauResonanceInfo("B*0", 5.3247, 0.00, 1, 0, LauBlattWeisskopfFactor::Beauty, 6.0);
positve = new LauResonanceInfo("B*+", 5.3247, 0.00, 1, 1, LauBlattWeisskopfFactor::Beauty, 6.0);
negatve = positve->createChargeConjugate();
resInfo_.push_back( neutral );
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// excited strange bottom name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// Bs*
neutral = new LauResonanceInfo("Bs*0", 5.4154, 0.00, 1, 0, LauBlattWeisskopfFactor::StrangeBeauty, 6.0);
resInfo_.push_back( neutral );
// nonresonant models name, mass, width, spin, charge, BW category, BW radius parameter (defaults to 4.0)
// Phase-space nonresonant model
neutral = new LauResonanceInfo("NonReson", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// Theory-based nonresonant model
neutral = new LauResonanceInfo("NRModel", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// Belle nonresonant models
neutral = new LauResonanceInfo("BelleSymNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("BelleNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
positve = new LauResonanceInfo("BelleNR+", 0.0, 0.0, 0, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
neutral = new LauResonanceInfo("BelleNR_Swave", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
positve = new LauResonanceInfo("BelleNR_Swave+",0.0, 0.0, 0, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
neutral = new LauResonanceInfo("BelleNR_Pwave", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
positve = new LauResonanceInfo("BelleNR_Pwave+",0.0, 0.0, 1, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
neutral = new LauResonanceInfo("BelleNR_Dwave", 0.0, 0.0, 2, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
positve = new LauResonanceInfo("BelleNR_Dwave+",0.0, 0.0, 2, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
neutral = new LauResonanceInfo("BelleNR_Fwave", 0.0, 0.0, 3, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
positve = new LauResonanceInfo("BelleNR_Fwave+",0.0, 0.0, 3, 1, LauBlattWeisskopfFactor::Light );
negatve = positve->createChargeConjugate();
resInfo_.push_back( positve );
resInfo_.push_back( negatve );
// Taylor expansion nonresonant model
neutral = new LauResonanceInfo("NRTaylor", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// Polynomial nonresonant models
neutral = new LauResonanceInfo("PolNR_S0", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("PolNR_S1", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("PolNR_S2", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("PolNR_P0", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("PolNR_P1", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("PolNR_P2", 0.0, 0.0, 1, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// Fake resonances for S-Wave splines
neutral = new LauResonanceInfo("Spline_S0", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("Spline_S0_Bar", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// Polar Form Factor nonresonant model
neutral = new LauResonanceInfo("PolarFFSymNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
neutral = new LauResonanceInfo("PolarFFNR", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
// PiPi-KK Inelastic Scattering
neutral = new LauResonanceInfo("Rescattering", 0.0, 0.0, 0, 0, LauBlattWeisskopfFactor::Light );
resInfo_.push_back( neutral );
nResDefMax_ = resInfo_.size();
}
void LauResonanceMaker::setBWType(const LauBlattWeisskopfFactor::BarrierType bwType)
{
// Check whether any BW factors have been created and bail out if so
if ( ! bwIndepFactors_.empty() ) {
std::cerr << "ERROR in LauResonanceMaker::setBWType : some barrier factors have already been created - cannot change the barrier type now!" << std::endl;
return;
}
for ( BWFactorCategoryMap::const_iterator iter = bwFactors_.begin(); iter != bwFactors_.end(); ++iter ) {
if ( iter->second.bwFactor_ != 0 ) {
std::cerr << "ERROR in LauResonanceMaker::setBWType : some barrier factors have already been created - cannot change the barrier type now!" << std::endl;
return;
}
}
bwBarrierType_ = bwType;
}
void LauResonanceMaker::setBWBachelorRestFrame(const LauBlattWeisskopfFactor::RestFrame restFrame)
{
// Check whether any BW factors have been created and bail out if so
if ( ! bwIndepFactors_.empty() ) {
std::cerr << "ERROR in LauResonanceMaker::setBWBachelorRestFrame : some barrier factors have already been created - cannot change the rest frame now!" << std::endl;
return;
}
for ( BWFactorCategoryMap::const_iterator iter = bwFactors_.begin(); iter != bwFactors_.end(); ++iter ) {
if ( iter->second.bwFactor_ != 0 ) {
std::cerr << "ERROR in LauResonanceMaker::setBWBachelorRestFrame : some barrier factors have already been created - cannot change the rest frame now!" << std::endl;
return;
}
}
bwRestFrame_ = restFrame;
}
void LauResonanceMaker::setSpinFormalism(const LauAbsResonance::LauSpinType spinType)
{
if ( summaryPrinted_ ) {
std::cerr << "ERROR in LauResonanceMaker::setSpinFormalism : cannot redefine the spin formalism after creating one or more resonances" << std::endl;
return;
}
spinFormalism_ = spinType;
}
void LauResonanceMaker::setDefaultBWRadius(const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory, const Double_t bwRadius)
{
if ( bwCategory == LauBlattWeisskopfFactor::Default || bwCategory == LauBlattWeisskopfFactor::Indep ) {
std::cerr << "WARNING in LauResonanceMaker::setDefaultBWRadius : cannot set radius values for Default or Indep categories" << std::endl;
return;
}
// Check if we have an information object for this category
BWFactorCategoryMap::iterator factor_iter = bwFactors_.find( bwCategory );
if ( factor_iter != bwFactors_.end() ) {
// If so, we can set the value in the information object
BlattWeisskopfCategoryInfo& categoryInfo = factor_iter->second;
categoryInfo.defaultRadius_ = bwRadius;
// Then we can check if a LauBlattWeisskopfFactor object has been created for this category
LauBlattWeisskopfFactor* bwFactor = categoryInfo.bwFactor_;
if ( bwFactor != 0 ) {
// If it has then we can also set its radius value directly
LauParameter* radius = bwFactor->getRadiusParameter();
radius->value(bwRadius);
radius->initValue(bwRadius);
radius->genValue(bwRadius);
}
} else {
// If not then we just store the value to be used later
BlattWeisskopfCategoryInfo& categoryInfo = bwFactors_[bwCategory];
categoryInfo.bwFactor_ = 0;
categoryInfo.defaultRadius_ = bwRadius;
categoryInfo.radiusFixed_ = kTRUE;
}
}
void LauResonanceMaker::fixBWRadius(const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory, const Bool_t fixRadius)
{
if ( bwCategory == LauBlattWeisskopfFactor::Default || bwCategory == LauBlattWeisskopfFactor::Indep ) {
std::cerr << "WARNING in LauResonanceMaker::fixBWRadius : cannot fix/float radius values for Default or Indep categories" << std::endl;
return;
}
// Check if we have an information object for this category
BWFactorCategoryMap::iterator factor_iter = bwFactors_.find( bwCategory );
if ( factor_iter != bwFactors_.end() ) {
// If so, we can set the value in the information object
BlattWeisskopfCategoryInfo& categoryInfo = factor_iter->second;
categoryInfo.radiusFixed_ = fixRadius;
// Then we can check if a LauBlattWeisskopfFactor object has been created for this category
LauBlattWeisskopfFactor* bwFactor = categoryInfo.bwFactor_;
if ( bwFactor != 0 ) {
// If it has then we can also fix/float its radius value directly
LauParameter* radius = bwFactor->getRadiusParameter();
radius->fixed(fixRadius);
}
} else {
// If not then we just store the value to be used later
BlattWeisskopfCategoryInfo& categoryInfo = bwFactors_[bwCategory];
categoryInfo.bwFactor_ = 0;
categoryInfo.defaultRadius_ = -1.0;
categoryInfo.radiusFixed_ = fixRadius;
}
}
LauBlattWeisskopfFactor* LauResonanceMaker::getParentBWFactor(Int_t resSpin, LauBlattWeisskopfFactor::BarrierType barrierType)
{
LauBlattWeisskopfFactor* bwFactor(0);
// Look up the category in the category information map
BWFactorCategoryMap::iterator factor_iter = bwFactors_.find( LauBlattWeisskopfFactor::Parent );
if ( factor_iter == bwFactors_.end() ) {
// If the category is currently undefined we need to create it
bwFactor = new LauBlattWeisskopfFactor( resSpin, 4.0, bwBarrierType_, bwRestFrame_, LauBlattWeisskopfFactor::Parent );
std::cerr<<"WARNING in LauResonanceMaker::getParentBWFactor : Default radius 4.0 set for Blatt-Weisskopf factor category: Parent"<<std::endl;
BlattWeisskopfCategoryInfo& categoryInfo = bwFactors_[LauBlattWeisskopfFactor::Parent];
categoryInfo.bwFactor_ = bwFactor;
categoryInfo.defaultRadius_ = bwFactor->getRadiusParameter()->value();
categoryInfo.radiusFixed_ = kTRUE;
} else {
// If it exists, we can check if the factor object has been created
BlattWeisskopfCategoryInfo& categoryInfo = factor_iter->second;
if ( categoryInfo.bwFactor_ != 0 ) {
// If so, simply clone it
bwFactor = categoryInfo.bwFactor_->createClone( resSpin, barrierType );
} else {
// Otherwise we need to create it, using the default value if it has been set
if ( categoryInfo.defaultRadius_ >= 0.0 ) {
bwFactor = new LauBlattWeisskopfFactor( resSpin, categoryInfo.defaultRadius_, bwBarrierType_, bwRestFrame_, LauBlattWeisskopfFactor::Parent );
} else {
bwFactor = new LauBlattWeisskopfFactor( resSpin, 4.0, bwBarrierType_, bwRestFrame_, LauBlattWeisskopfFactor::Parent );
std::cerr<<"WARNING in LauResonanceMaker::getParentBWFactor : Default radius 4.0 set for Blatt-Weisskopf factor category: Parent"<<std::endl;
}
categoryInfo.bwFactor_ = bwFactor;
// Set whether the radius should be fixed/floated
LauParameter* radius = bwFactor->getRadiusParameter();
radius->fixed( categoryInfo.radiusFixed_ );
}
}
return bwFactor;
}
LauBlattWeisskopfFactor* LauResonanceMaker::getBWFactor( const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory, const LauResonanceInfo* resInfo )
{
LauBlattWeisskopfFactor* bwFactor(0);
// If this is an independent factor, create it and add it to the list of independent factors, then return it
if ( bwCategory == LauBlattWeisskopfFactor::Indep ) {
bwFactor = new LauBlattWeisskopfFactor( *resInfo, bwBarrierType_, bwRestFrame_, bwCategory );
bwIndepFactors_.push_back(bwFactor);
return bwFactor;
}
// Otherwise, look up the category in the category information map
BWFactorCategoryMap::iterator factor_iter = bwFactors_.find( bwCategory );
if ( factor_iter == bwFactors_.end() ) {
// If the category is currently undefined we need to create it
bwFactor = new LauBlattWeisskopfFactor( *resInfo, bwBarrierType_, bwRestFrame_, bwCategory );
BlattWeisskopfCategoryInfo& categoryInfo = bwFactors_[bwCategory];
categoryInfo.bwFactor_ = bwFactor;
categoryInfo.defaultRadius_ = bwFactor->getRadiusParameter()->value();
categoryInfo.radiusFixed_ = kTRUE;
} else {
// If it exists, we can check if the factor object has been created
BlattWeisskopfCategoryInfo& categoryInfo = factor_iter->second;
if ( categoryInfo.bwFactor_ != 0 ) {
// If so, simply clone it
const UInt_t resSpin = resInfo->getSpin();
bwFactor = categoryInfo.bwFactor_->createClone( resSpin, categoryInfo.bwFactor_->getBarrierType() );
} else {
// Otherwise we need to create it, using the default value if it has been set
if ( categoryInfo.defaultRadius_ >= 0.0 ) {
bwFactor = new LauBlattWeisskopfFactor( *resInfo, categoryInfo.defaultRadius_, bwBarrierType_, bwRestFrame_, bwCategory );
} else {
bwFactor = new LauBlattWeisskopfFactor( *resInfo, bwBarrierType_, bwRestFrame_, bwCategory );
}
categoryInfo.bwFactor_ = bwFactor;
// Set whether the radius should be fixed/floated
LauParameter* radius = bwFactor->getRadiusParameter();
radius->fixed( categoryInfo.radiusFixed_ );
}
}
return bwFactor;
}
LauAbsResonance* LauResonanceMaker::getResonance(const LauDaughters* daughters, const TString& resName, const Int_t resPairAmpInt, const LauAbsResonance::LauResonanceModel resType, const LauBlattWeisskopfFactor::BlattWeisskopfCategory bwCategory)
{
// Routine to return the appropriate LauAbsResonance object given the resonance
// name (resName), which daughter is the bachelor track (resPairAmpInt = 1,2 or 3),
// and the resonance type ("BW" = Breit-Wigner, "Flatte" = Flatte distribution).
// If this is the first resonance we are making, first print a summary of the formalism
if ( ! summaryPrinted_ ) {
std::cout << "INFO in LauResonanceMaker::getResonance : Freezing amplitude formalism:" << std::endl;
switch ( spinFormalism_ ) {
case LauAbsResonance::Zemach_P :
std::cout << " : Spin factors use Zemach spin tensors, with bachelor momentum in resonance rest frame" << std::endl;
break;
case LauAbsResonance::Zemach_Pstar :
std::cout << " : Spin factors use Zemach spin tensors, with bachelor momentum in parent rest frame" << std::endl;
break;
case LauAbsResonance::Covariant :
std::cout << " : Spin factors use Covariant spin tensors" << std::endl;
break;
case LauAbsResonance::Legendre :
std::cout << " : Spin factors are just Legendre polynomials" << std::endl;
break;
}
switch ( bwBarrierType_ ) {
case LauBlattWeisskopfFactor::BWBarrier :
std::cout << " : Blatt-Weisskopf barrier factors are the 'non-primed' form" << std::endl;
break;
case LauBlattWeisskopfFactor::BWPrimeBarrier :
std::cout << " : Blatt-Weisskopf barrier factors are the 'primed' form" << std::endl;
break;
case LauBlattWeisskopfFactor::ExpBarrier :
std::cout << " : Blatt-Weisskopf barrier factors are the exponential form" << std::endl;
break;
}
switch ( bwRestFrame_ ) {
case LauBlattWeisskopfFactor::ParentFrame :
std::cout << " : Blatt-Weisskopf barrier factors use bachelor momentum in parent rest frame" << std::endl;
break;
case LauBlattWeisskopfFactor::ResonanceFrame :
std::cout << " : Blatt-Weisskopf barrier factors use bachelor momentum in resonance rest frame" << std::endl;
break;
case LauBlattWeisskopfFactor::Covariant :
std::cout << " : Blatt-Weisskopf barrier factors use covariant expression" << std::endl;
break;
}
summaryPrinted_ = kTRUE;
}
// Loop over all possible resonance states we have defined in
// createResonanceVector() until we get a match with the name of the resonance
LauResonanceInfo* resInfo(0);
for (std::vector<LauResonanceInfo*>::const_iterator iter=resInfo_.begin(); iter!=resInfo_.end(); ++iter) {
if (resName == (*iter)->getName()) {
// We have recognised the resonance name.
std::cout<<"INFO in LauResonanceMaker::getResonance : Creating resonance: "<<resName<<std::endl;
resInfo = (*iter);
// stop looping
break;
}
}
// if we couldn't find the right resonance then we should return a null pointer
if ( resInfo == 0 ) {
std::cout<<"ERROR in LauResonanceMaker::getResonance : Unable to locate resonance info for: "<<resName<<std::endl;
return 0;
}
// Now construct the resonance using the specified type
LauAbsResonance* theResonance(0);
switch ( resType ) {
case LauAbsResonance::BW :
// Simple non-relativistic Breit-Wigner
std::cout<<" : Using simple Breit-Wigner lineshape. "<<std::endl;
theResonance = new LauBreitWignerRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::RelBW :
{
// Relativistic Breit-Wigner with Blatt-Weisskopf factors.
std::cout<<" : Using relativistic Breit-Wigner lineshape. "<<std::endl;
theResonance = new LauRelBreitWignerRes(resInfo, resPairAmpInt, daughters);
LauBlattWeisskopfFactor::BlattWeisskopfCategory parCategory = LauBlattWeisskopfFactor::Parent;
LauBlattWeisskopfFactor::BlattWeisskopfCategory resCategory = bwCategory;
if ( bwCategory == LauBlattWeisskopfFactor::Default ) {
resCategory = resInfo->getBWCategory();
}
LauBlattWeisskopfFactor* resBWFactor = this->getBWFactor( resCategory, resInfo );
LauBlattWeisskopfFactor* parBWFactor = this->getBWFactor( parCategory, resInfo );
theResonance->setBarrierRadii( resBWFactor, parBWFactor );
break;
}
case LauAbsResonance::GS :
{
// Gounaris-Sakurai function to try and model the rho(770) better
std::cout<<" : Using Gounaris-Sakurai lineshape. "<<std::endl;
theResonance = new LauGounarisSakuraiRes(resInfo, resPairAmpInt, daughters);
LauBlattWeisskopfFactor::BlattWeisskopfCategory parCategory = LauBlattWeisskopfFactor::Parent;
LauBlattWeisskopfFactor::BlattWeisskopfCategory resCategory = bwCategory;
if ( bwCategory == LauBlattWeisskopfFactor::Default ) {
resCategory = resInfo->getBWCategory();
}
LauBlattWeisskopfFactor* resBWFactor = this->getBWFactor( resCategory, resInfo );
LauBlattWeisskopfFactor* parBWFactor = this->getBWFactor( parCategory, resInfo );
theResonance->setBarrierRadii( resBWFactor, parBWFactor );
break;
}
case LauAbsResonance::Flatte :
// Flatte distribution - coupled channel Breit-Wigner
std::cout<<" : Using Flatte lineshape. "<<std::endl;
theResonance = new LauFlatteRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::Sigma :
// Sigma model - should only be used for the pi-pi system
std::cout<<" : Using Sigma lineshape. "<<std::endl;
theResonance = new LauSigmaRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::Kappa :
// Kappa model - should only be used for the K-pi system
std::cout<<" : Using Kappa lineshape. "<<std::endl;
theResonance = new LauKappaRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::Dabba :
// Dabba model - should only be used for the D-pi system
std::cout<<" : Using Dabba lineshape. "<<std::endl;
theResonance = new LauDabbaRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::LASS :
// LASS function to try and model the K-pi S-wave better
std::cout<<" : Using LASS lineshape. "<<std::endl;
theResonance = new LauLASSRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::LASS_BW :
// LASS function to try and model the K-pi S-wave better
std::cout<<" : Using LASS lineshape (resonant part only). "<<std::endl;
theResonance = new LauLASSBWRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::LASS_NR :
// LASS function to try and model the K-pi S-wave better
std::cout<<" : Using LASS lineshape (nonresonant part only). "<<std::endl;
theResonance = new LauLASSNRRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::EFKLLM :
// EFKLLM form-factor description of the K-pi S-wave
std::cout<<" : Using EFKLLM lineshape. "<<std::endl;
theResonance = new LauEFKLLMRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::KMatrix :
// K-matrix description
std::cerr<<"ERROR in LauResonanceMaker::getResonance : K-matrix type specified, which should be separately handled."<<std::endl;
break;
case LauAbsResonance::FlatNR :
// uniform NR amplitude - arguments are there to preserve the interface
std::cout<<" : Using uniform NR lineshape. "<<std::endl;
// we override resPairAmpInt here
theResonance = new LauFlatNR(resInfo, 0, daughters);
break;
case LauAbsResonance::NRModel :
// NR amplitude model - arguments are there to preserve the interface
std::cout<<" : Using NR-model lineshape. "<<std::endl;
// we override resPairAmpInt here
theResonance = new LauNRAmplitude(resInfo, 0, daughters);
break;
case LauAbsResonance::BelleNR :
case LauAbsResonance::PowerLawNR :
// Belle NR amplitude model - arguments are there to preserve the interface
std::cout<<" : Using Belle NR lineshape. "<<std::endl;
theResonance = new LauBelleNR(resInfo, resType, resPairAmpInt, daughters);
break;
case LauAbsResonance::BelleSymNR :
case LauAbsResonance::BelleSymNRNoInter :
case LauAbsResonance::TaylorNR :
// Belle NR amplitude model - arguments are there to preserve the interface
std::cout<<" : Using Belle symmetric NR lineshape. "<<std::endl;
theResonance = new LauBelleSymNR(resInfo, resType, resPairAmpInt, daughters);
break;
case LauAbsResonance::PolNR :
// Polynomial NR amplitude model - arguments are there to preserve the interface
std::cout<<" : Using polynomial NR lineshape. "<<std::endl;
theResonance = new LauPolNR(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::Pole :
// Scalar pole model
std::cout<<" : Using the scalar Pole lineshape.. "<<std::endl;
theResonance = new LauPoleRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::PolarFFNR :
// Polar Form Factor NR amplitude model - arguments are there to preserve the interface
std::cout<<" : Using Polar FormFactor NR lineshape.. "<<std::endl;
theResonance = new LauPolarFormFactorNR(resInfo, resType, resPairAmpInt, daughters);
break;
case LauAbsResonance::PolarFFSymNR :
case LauAbsResonance::PolarFFSymNRNoInter :
// Polar Form Factor NR amplitude model - arguments are there to preserve the interface
std::cout<<" : Using Polar FormFactor Symetric NR lineshape. "<<std::endl;
theResonance = new LauPolarFormFactorSymNR(resInfo, resType, resPairAmpInt, daughters);
break;
case LauAbsResonance::Rescattering:
case LauAbsResonance::RescatteringNoInter:
// KKPiPi Inelastic Scattering amplitude - arguments are there to preserve the interface
std::cout<<" : KKPiPi Inelastic Scattering amplitude lineshape. "<<std::endl;
theResonance = new LauRescatteringRes(resInfo, resType, resPairAmpInt, daughters);
break;
case LauAbsResonance::Rescattering2:
// KKPiPi Inelastic Scattering amplitude - arguments are there to preserve the interface
std::cout<<" : KKPiPi Inelastic Scattering amplitude lineshape. "<<std::endl;
theResonance = new LauRescattering2Res(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::MIPW_MagPhase :
// Model independent partial wave
std::cout<<" : Using model independent partial wave lineshape (magnitude and phase). "<<std::endl;
theResonance = new LauModIndPartWaveMagPhase(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::MIPW_RealImag :
// Model independent partial wave
std::cout<<" : Using model independent partial wave lineshape (real and imaginary part). "<<std::endl;
theResonance = new LauModIndPartWaveRealImag(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::GaussIncoh :
// Incoherent Gaussian
std::cout<<" : Using incoherent Gaussian lineshape. "<<std::endl;
theResonance = new LauGaussIncohRes(resInfo, resPairAmpInt, daughters);
break;
case LauAbsResonance::RhoOmegaMix_GS :
case LauAbsResonance::RhoOmegaMix_RBW :
case LauAbsResonance::RhoOmegaMix_GS_1 :
case LauAbsResonance::RhoOmegaMix_RBW_1 :
// Rho-omega mass mixing model
std::cout<<" : Using rho-omega mass mixing lineshape. "<<std::endl;
theResonance = new LauRhoOmegaMix(resInfo, resType, resPairAmpInt, daughters);
LauBlattWeisskopfFactor::BlattWeisskopfCategory parCategory = LauBlattWeisskopfFactor::Parent;
LauBlattWeisskopfFactor::BlattWeisskopfCategory resCategory = bwCategory;
if ( bwCategory == LauBlattWeisskopfFactor::Default ) {
resCategory = resInfo->getBWCategory();
}
LauBlattWeisskopfFactor* resBWFactor = this->getBWFactor( resCategory, resInfo );
LauBlattWeisskopfFactor* parBWFactor = this->getBWFactor( parCategory, resInfo );
theResonance->setBarrierRadii( resBWFactor, parBWFactor );
break;
}
// Set the spin formalism choice
theResonance->setSpinType( spinFormalism_ );
return theResonance;
}
Int_t LauResonanceMaker::resTypeInt(const TString& name) const
{
// Internal function that returns the resonance integer, specified by the
// order of the resonance vector defined in createResonanceVector(),
// for a given resonance name.
Int_t resTypInt(-99);
Int_t i(0);
for (std::vector<LauResonanceInfo*>::const_iterator iter=resInfo_.begin(); iter!=resInfo_.end(); ++iter) {
if (name.BeginsWith((*iter)->getName(), TString::kExact) == kTRUE) {
// We have recognised the resonance from those that are available
resTypInt = i;
return resTypInt;
}
++i;
}
return resTypInt;
}
void LauResonanceMaker::printAll( std::ostream& stream ) const
{
for ( std::vector<LauResonanceInfo*>::const_iterator iter = resInfo_.begin(); iter != resInfo_.end(); ++iter ) {
stream << (**iter) << std::endl;
}
}
LauResonanceInfo* LauResonanceMaker::getResInfo(const TString& resName) const
{
LauResonanceInfo* resInfo(0);
for (std::vector<LauResonanceInfo*>::const_iterator iter=resInfo_.begin(); iter!=resInfo_.end(); ++iter) {
if (resName == (*iter)->getName()) {
// We have recognised the resonance name.
resInfo = (*iter);
// stop looping
break;
}
}
return resInfo;
}

File Metadata

Mime Type
text/x-diff
Expires
Tue, Sep 30, 6:01 AM (1 d, 19 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
6566413
Default Alt Text
(108 KB)

Event Timeline