diff --git a/.clang-format b/.clang-format
index ebeccb7..223ea1f 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,121 +1,168 @@
Language: Cpp
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
+AlignArrayOfStructures: Right
+AlignConsecutiveAssignments: None
+AlignConsecutiveBitFields: Consecutive
+AlignConsecutiveDeclarations: None
AlignEscapedNewlines: Left
-AlignOperands: true
-AlignTrailingComments: true
+AlignOperands: AlignAfterOperator
+AlignTrailingComments:
+ Kind: Always
+ OverEmptyLines: 0
+AllowAllArgumentsOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: false
+AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: InlineOnly
-AllowShortIfStatementsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
-BraceWrapping:
+BitFieldColonSpacing: Both
+BraceWrapping:
+ AfterCaseLabel: false
AfterClass: false
- AfterControlStatement: false
+ AfterControlStatement: Never
AfterEnum: true
AfterFunction: true
AfterNamespace: false
- AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
+ BeforeLambdaBody: true
+ BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
+BreakAfterAttributes: Leave
+BreakArrays: false
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
+BreakBeforeConceptDeclarations: Always
BreakBeforeTernaryOperators: true
-BreakInheritanceList: AfterColon
BreakConstructorInitializers: AfterColon
+BreakInheritanceList: AfterColon
BreakStringLiterals: false
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: Always
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
-ForEachMacros:
+ForEachMacros:
- foreach
- BOOST_FOREACH
IncludeBlocks: Regroup
-IncludeCategories:
+IncludeCategories:
- Regex: '^"EvtGen/'
Priority: 1
- Regex: '^"EvtGenBase/'
Priority: 2
- Regex: '^"EvtGenModels/'
Priority: 3
- Regex: '^"EvtGenExternal/'
Priority: 4
- Regex: '^"(HepMC|HepMC3)/'
Priority: 5
- Regex: '^"(Pythia8|Photos|Tauola|SHERPA|ATOOLS)/'
Priority: 6
- Regex: '^"T[[:alnum:]]+\.h"'
Priority: 7
- Regex: '^<[[:alnum:]._]+>'
Priority: 9
- Regex: '.*'
Priority: 8
IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: '(Impl\.hh)$'
+IndentAccessModifiers: false
+IndentCaseBlocks: false
IndentCaseLabels: true
+IndentExternBlock: Indent
+IndentGotoLabels: true
IndentPPDirectives: None
+IndentRequiresClause: false
IndentWidth: 4
IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
+InsertBraces: false
+InsertNewlineAtEOF: true
+IntegerLiteralSeparator:
+ Binary: 0
+ Decimal: 0
+ Hex: 0
KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: Signature
+LineEnding: LF
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
+PPIndentWidth: 0
+PackConstructorInitializers: NextLine
PenaltyBreakAssignment: 50
PenaltyBreakBeforeFirstCallParameter: 50
PenaltyBreakComment: 250
PenaltyBreakFirstLessLess: 100
+PenaltyBreakOpenParenthesis: 0
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 1
PenaltyExcessCharacter: 10
+PenaltyIndentedWhitespace: 0
PenaltyReturnTypeOnItsOwnLine: 250
PointerAlignment: Left
+QualifierAlignment: Left
+ReferenceAlignment: Pointer
ReflowComments: false
-SortIncludes: true
-SortUsingDeclarations: true
+RemoveBracesLLVM: false
+RemoveSemicolon: false
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 0
+SortIncludes: CaseSensitive
+SortUsingDeclarations: Lexicographic
SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 4
-SpacesInAngles: false
-SpacesInContainerLiterals: true
+SpacesInAngles: Never
SpacesInCStyleCastParentheses: false
+SpacesInConditionalStatement: true
+SpacesInContainerLiterals: true
+SpacesInLineCommentPrefix:
+ Minimum: 1
+ Maximum: 1
SpacesInParentheses: true
SpacesInSquareBrackets: false
-Standard: Cpp11
-StatementMacros:
+Standard: Latest
+StatementMacros:
- ClassDef
- ClassImp
-TabWidth: 8
+TabWidth: 4
UseTab: Never
diff --git a/EvtGenBase/EvtHepMCEvent.hh b/EvtGenBase/EvtHepMCEvent.hh
index e118109..9dfaee9 100644
--- a/EvtGenBase/EvtHepMCEvent.hh
+++ b/EvtGenBase/EvtHepMCEvent.hh
@@ -1,124 +1,123 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifndef EVTHEPMCEVENT_HH
#define EVTHEPMCEVENT_HH
#include "EvtGenBase/EvtVector4R.hh"
#ifdef EVTGEN_HEPMC3
#include "HepMC3/GenEvent.h"
#include "HepMC3/GenParticle.h"
#include "HepMC3/GenVertex.h"
#include "HepMC3/Print.h"
#include "HepMC3/Units.h"
typedef HepMC3::GenParticlePtr GenParticlePtr;
typedef HepMC3::GenVertexPtr GenVertexPtr;
typedef HepMC3::GenEvent GenEvent;
typedef HepMC3::FourVector FourVector;
typedef HepMC3::Units Units;
inline GenParticlePtr newGenParticlePtr(
const FourVector& mom = FourVector::ZERO_VECTOR(), int pid = 0,
int status = 0 )
{
return std::make_shared<HepMC3::GenParticle>( mom, pid, status );
}
inline GenVertexPtr newGenVertexPtr(
const FourVector& pos = FourVector::ZERO_VECTOR() )
{
return std::make_shared<HepMC3::GenVertex>( pos );
}
#else
#include "HepMC/GenEvent.h"
#include "HepMC/GenParticle.h"
#include "HepMC/GenVertex.h"
#include "HepMC/SimpleVector.h"
#include "HepMC/Units.h"
typedef HepMC::GenParticle* GenParticlePtr;
typedef HepMC::GenVertex* GenVertexPtr;
typedef HepMC::GenEvent GenEvent;
typedef HepMC::FourVector FourVector;
#define Units HepMC::Units
inline GenParticlePtr newGenParticlePtr(
const FourVector& mom = FourVector( 0.0, 0.0, 0.0, 0.0 ), int pid = 0,
int status = 0 )
{
return new HepMC::GenParticle( mom, pid, status );
}
inline GenVertexPtr newGenVertexPtr(
const FourVector& pos = FourVector( 0.0, 0.0, 0.0, 0.0 ) )
{
return new HepMC::GenVertex( pos );
}
#endif
class EvtParticle;
class EvtHepMCEvent {
public:
EvtHepMCEvent();
virtual ~EvtHepMCEvent();
// Select what frame a given GenParticle is in:
// its own restframe, the lab frame (first mother), or its mother's frame
enum HepMCFrame
{
RESTFRAME = 1,
LAB = 2,
MOTHER = 3
};
// Select the GenParticle status
enum HepMCStatus
{
STABLE = 1,
DECAYED = 2,
HISTORY = 3
};
void constructEvent( EvtParticle* baseParticle );
void constructEvent( EvtParticle* baseParticle, EvtVector4R& translation );
GenEvent* getEvent() { return m_theEvent; }
// Methods used to create GenParticles and FourVectors of vertices.
// Make these public so that other classes may call them if they use EvtHepMCEvent.
// Create a GenParticle using info from the EvtParticle, specifying what frame
// the 4-momentum is from.
GenParticlePtr createGenParticle( EvtParticle* theParticle, int frameType );
// Find out the decay vertex position for the given EvtParticle.
FourVector getVertexCoord( EvtParticle* theParticle );
- protected:
private:
// Delete the event structure (called by destructor)
void deleteEvent();
// Add a vertex to the event. This is called by the constructEvent function
// and is recursive, i.e. it loops through all possible daughter particles and
// their descendents.
void addVertex( EvtParticle* inEvtParticle, GenParticlePtr inGenParticle );
GenEvent* m_theEvent;
EvtVector4R m_translation;
};
#endif
diff --git a/EvtGenBase/EvtIncoherentMixing.hh b/EvtGenBase/EvtIncoherentMixing.hh
index e9329fd..415e743 100644
--- a/EvtGenBase/EvtIncoherentMixing.hh
+++ b/EvtGenBase/EvtIncoherentMixing.hh
@@ -1,94 +1,93 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifndef EVTINCOHERENTMIXING_HH
#define EVTINCOHERENTMIXING_HH 1
// Include files
#include "EvtGenBase/EvtParticle.hh"
/** @class EvtIncoherentMixing EvtIncoherentMixing.hh EvtGenBase/EvtIncoherentMixing.hh
* Class to contain the parameters of the incoherent B0 and B0S mixing
*
* @author Patrick Robbe
* @date 2003-10-09
*/
class EvtIncoherentMixing {
public:
/// Standard constructor
EvtIncoherentMixing();
~EvtIncoherentMixing(); ///< Destructor
// activate or desactivate the Bs mixing
static void setB0Mixing();
static void unsetB0Mixing();
// activate or desactivate the B0 mixing
static void setBsMixing();
static void unsetBsMixing();
// is mixing activated ?
static bool doB0Mixing();
static bool doBsMixing();
// set values for the mixing
static void setdGammad( double value );
static void setdeltamd( double value );
static void setdGammas( double value );
static void setdeltams( double value );
// get parameters for mixing
static double getdGammad();
static double getdeltamd();
static double getdGammas();
static double getdeltams();
// Functions to obtain time and type of the mixing ( 1 mix, 0 unmix )
static void incoherentB0Mix( const EvtId id, double& t, int& mix );
static void incoherentBsMix( const EvtId id, double& t, int& mix );
// Functions to check if a B has mixed (comes from a B)
static bool isB0Mixed( EvtParticle* );
static bool isBsMixed( EvtParticle* );
// Functions for CP models
// returns for particle p the decay time t , the flavour of the tag
// side (B0, anti-B0, B_s0, anti-B_s0). The flavour of p can flip
// with probability probB
static void OtherB( EvtParticle* p, double& t, EvtId& otherb, double probB );
static void OtherB( EvtParticle* p, double& t, EvtId& otherb );
static bool flipIsEnabled();
static void enableFlip();
static void disableFlip();
- protected:
private:
static bool m_doB0Mixing;
static bool m_doBsMixing;
static double m_dGammad;
static double m_deltamd;
static double m_dGammas;
static double m_deltams;
static bool m_enableFlip;
};
#endif // EVTGENBASE_EVTINCOHERENTMIXING_HH
diff --git a/EvtGenExternal/EvtExternalGenList.hh b/EvtGenExternal/EvtExternalGenList.hh
index b85182b..92466c7 100644
--- a/EvtGenExternal/EvtExternalGenList.hh
+++ b/EvtGenExternal/EvtExternalGenList.hh
@@ -1,58 +1,57 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifndef EVTEXTERNALGENLIST_HH
#define EVTEXTERNALGENLIST_HH
#include "EvtGenBase/EvtAbsRadCorr.hh"
#include "EvtGenBase/EvtDecayBase.hh"
#include <list>
// Description: A factory type method to create engines for external physics
// generators like Pythia.
class EvtExternalGenList {
public:
EvtExternalGenList( bool convertPythiaCodes = false,
std::string pythiaXmlDir = "",
std::string photonType = "gamma",
bool useEvtGenRandom = true,
bool seedTauolaFortran = true );
virtual ~EvtExternalGenList();
std::list<EvtDecayBase*> getListOfModels();
EvtAbsRadCorr* getPhotosModel( const double infraredCutOff = 1.0e-7,
const double maxWtInterference = 64.0 );
EvtAbsRadCorr* getSherpaPhotonsModel( const double infraredCutOff = 1.0e-7,
const int mode = 2,
const int useME = 0 );
- protected:
private:
std::string m_photonType;
bool m_useEvtGenRandom;
};
#endif
diff --git a/EvtGenExternal/EvtPythiaEngine.hh b/EvtGenExternal/EvtPythiaEngine.hh
index bc04bb6..e8a828f 100644
--- a/EvtGenExternal/EvtPythiaEngine.hh
+++ b/EvtGenExternal/EvtPythiaEngine.hh
@@ -1,94 +1,93 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifdef EVTGEN_PYTHIA
#ifndef EVTPYTHIAENGINE_HH
#define EVTPYTHIAENGINE_HH
#include "EvtGenBase/EvtDecayBase.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtVector4R.hh"
#include "EvtGenModels/EvtAbsExternalGen.hh"
#include "EvtGenExternal/EvtPythiaRandom.hh"
#include "Pythia8/ParticleData.h"
#include "Pythia8/Pythia.h"
#include <map>
#include <memory>
#include <string>
#include <vector>
// Description: Interface to the Pytha 8 external generator
class EvtPythiaEngine : public EvtAbsExternalGen {
public:
EvtPythiaEngine( std::string xmlDir = "./xmldoc",
bool convertPhysCodes = false, bool useEvtGenRandom = true );
bool doDecay( EvtParticle* theMother ) override;
void initialise() override;
- protected:
private:
void updateParticleLists();
void updatePhysicsParameters();
bool validPDGCode( int PDGCode );
void createPythiaParticle( Pythia8::Pythia& thePythiaGenerator,
EvtId& particleId, int PDGCode );
void updatePythiaDecayTable( Pythia8::Pythia& thePythiaGenerator,
EvtId& particleId, int aliasInt, int PDGCode );
void storeDaughterInfo( Pythia8::Event& theEvent, EvtParticle* theParticle,
int startInt );
void clearDaughterVectors();
void clearPythiaModeMap();
void createDaughterEvtParticles( EvtParticle* theParent );
int getModeInt( EvtDecayBase* decayModel );
bool m_convertPhysCodes;
// Specify if we are going to use the random number generator (engine) from EvtGen for Pythia 8.
bool m_useEvtGenRandom;
bool m_initialised{ false };
std::unique_ptr<Pythia8::Pythia> m_genericPythiaGen;
std::unique_ptr<Pythia8::Pythia> m_aliasPythiaGen;
std::shared_ptr<EvtPythiaRandom> m_evtgenRandom;
std::vector<int> m_daugPDGVector;
std::vector<EvtVector4R> m_daugP4Vector;
std::map<int, std::vector<int>> m_pythiaModeMap;
std::map<int, int> m_addedPDGCodes;
};
#endif
#endif
diff --git a/EvtGenExternal/EvtTauolaEngine.hh b/EvtGenExternal/EvtTauolaEngine.hh
index 8eedbdc..6fada5d 100644
--- a/EvtGenExternal/EvtTauolaEngine.hh
+++ b/EvtGenExternal/EvtTauolaEngine.hh
@@ -1,87 +1,86 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifdef EVTGEN_TAUOLA
#ifndef EVTTAUOLAENGINE_HH
#define EVTTAUOLAENGINE_HH
#include "EvtGenBase/EvtDecayBase.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtVector4R.hh"
#include "EvtGenModels/EvtAbsExternalGen.hh"
#ifdef EVTGEN_HEPMC3
#include "HepMC3/Relatives.h"
#include "HepMC3/Units.h"
#include "Tauola/TauolaHepMC3Event.h"
#include "Tauola/TauolaHepMC3Particle.h"
#else
#include "Tauola/TauolaHepMCEvent.h"
#include "Tauola/TauolaHepMCParticle.h"
#include "Tauola/TauolaParticle.h"
#endif
#include "EvtGenBase/EvtHepMCEvent.hh"
#include <mutex>
// Description: Interface to the TAUOLA external generator
class EvtTauolaEngine : public EvtAbsExternalGen {
public:
EvtTauolaEngine( bool useEvtGenRandom = true, bool seedTauolaFortran = true );
bool doDecay( EvtParticle* theMother ) override;
void initialise() override;
- protected:
private:
GenParticlePtr createGenParticle( const EvtParticle* theParticle ) const;
void setUpPossibleTauModes();
void setOtherParameters();
int getModeInt( EvtDecayBase* decayModel ) const;
void decayTauEvent( EvtParticle* tauParticle );
bool m_useEvtGenRandom{ true };
bool m_seedTauolaFortran{ true };
// PDG standard code integer ID for tau particle
static constexpr int m_tauPDG{ 15 };
// Number of possible decay modes in Tauola
static constexpr int m_nTauolaModes{ 22 };
// Neutral and charged spin propagator choices
static int m_neutPropType;
static int m_posPropType;
static int m_negPropType;
static bool m_initialised;
static std::mutex m_tauola_mutex;
};
#endif
#endif
diff --git a/EvtGenModels/EvtBcVHad.hh b/EvtGenModels/EvtBcVHad.hh
index 15b1626..e846234 100644
--- a/EvtGenModels/EvtBcVHad.hh
+++ b/EvtGenModels/EvtBcVHad.hh
@@ -1,84 +1,94 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifndef EvtBcVHad_HH
#define EvtBcVHad_HH
#include "EvtGenBase/EvtDecayAmp.hh"
#include "EvtGenBase/EvtVector4C.hh"
#include "EvtGenModels/EvtBCVFF2.hh"
#include "EvtGenModels/EvtWHad.hh"
#include <array>
#include <memory>
#include <string>
class EvtParticle;
// Description: Module to implement Bc -> psi + (n pi) + (m K) decays
class EvtBcVHad : public EvtDecayAmp {
public:
std::string getName() const override;
EvtDecayBase* clone() const override;
void initProbMax() override;
void init() override;
void decay( EvtParticle* parent ) override;
protected:
// Hadronic current function
EvtVector4C hardCurr( EvtParticle* parent ) const;
void parseDecay();
private:
// Code of the Bc -> VW formfactor set:
// 1 - SR
// 2 - PM
int m_whichFit;
// Final vector particle code
int m_idVector;
// Code of the hadronic final state
// 1: B_c+ -> V pi+
// 2: B_c+ -> V pi+ pi0
// 3: B_c+ -> V 2pi+ pi-
// 4: B_c+ -> V 2pi+ pi- pi0 (not implemented)
// 5: B_c+ -> V 3pi+ 2pi-
// 6: B_c+ -> V K+ K- pi+
// 7: B_c+ -> V K+ pi+ pi-
// 8: B_c+ -> V K_S0 K+
// 9: B_c+ -> V K+ K- 2pi+ pi-
// 10: B_c+ -> V 4pi+ 3pi-
// 11: B_c+ -> V K+ 2pi+ 2pi-
int m_outCode;
std::unique_ptr<EvtBCVFF2> m_FFModel;
std::unique_ptr<EvtWHad> m_WCurr;
- std::array<int, 4> m_iPiPlus = { { -1, -1, -1, -1 } };
- std::array<int, 4> m_iPiMinus = { { -1, -1, -1, -1 } };
- std::array<int, 4> m_iPiZero = { { -1, -1, -1, -1 } };
- std::array<int, 4> m_iKPlus = { { -1, -1, -1, -1 } };
- std::array<int, 4> m_iKMinus = { { -1, -1, -1, -1 } };
+ std::array<int, 4> m_iPiPlus = {
+ {-1, -1, -1, -1}
+ };
+ std::array<int, 4> m_iPiMinus = {
+ {-1, -1, -1, -1}
+ };
+ std::array<int, 4> m_iPiZero = {
+ {-1, -1, -1, -1}
+ };
+ std::array<int, 4> m_iKPlus = {
+ {-1, -1, -1, -1}
+ };
+ std::array<int, 4> m_iKMinus = {
+ {-1, -1, -1, -1}
+ };
};
#endif
diff --git a/EvtGenModels/EvtBtoXsgammaFermiUtil.hh b/EvtGenModels/EvtBtoXsgammaFermiUtil.hh
index ea017e0..d8d164a 100644
--- a/EvtGenModels/EvtBtoXsgammaFermiUtil.hh
+++ b/EvtGenModels/EvtBtoXsgammaFermiUtil.hh
@@ -1,57 +1,57 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifndef EVTBTOXSGAMMAFERMIUTIL_HH
#define EVTBTOXSGAMMAFERMIUTIL_HH
#include <vector>
// Description:
// Class to hold various fermi functions and their helper functions. The
// fermi functions are used in EvtBtoXsgammaKagan.
class EvtBtoXsgammaFermiUtil final {
//--------------------
// Instance Members --
//--------------------
public:
//Exponential function
static double FermiExpFunc( double var, const std::vector<double>& coeffs );
//Gaussian function and its helper functions
- static double FermiGaussFunc( double, std::vector<double> const& coeffs );
+ static double FermiGaussFunc( double, const std::vector<double>& coeffs );
static double FermiGaussFuncRoot( double, double, double,
std::vector<double>& coeffs );
static double FermiGaussRootFcnA( double, const std::vector<double>& coeffs1,
const std::vector<double>& coeffs2 );
static double FermiGaussRootFcnB( double, const std::vector<double>& coeffs1,
const std::vector<double>& coeffs2 );
static double Gamma( double, const std::vector<double>& coeffs );
//Roman function and its helper functions
static double BesselI1( double );
static double BesselK1( double );
static double FermiRomanFuncRoot( double, double );
static double FermiRomanRootFcnA( double );
- static double FermiRomanFunc( double, std::vector<double> const& coeffs );
+ static double FermiRomanFunc( double, const std::vector<double>& coeffs );
};
#endif
diff --git a/History.md b/History.md
index 4e7d617..f380c10 100644
--- a/History.md
+++ b/History.md
@@ -1,999 +1,1004 @@
# History file for EvtGen
From version 2.0.0,
Tabc labels refer to [Maniphest tasks](https://phab.hepforge.org/maniphest/query/nkBRd9OhPCBN/), while
Dxyz labels refer to [Differential code reviews](https://phab.hepforge.org/differential/query/YDY8EgjNGd.e/) on HepForge:
https://phab.hepforge.org/Tabc
https://phab.hepforge.org/Dxyz
===
## R03-00-00-betaX
+18 Nov 2024 Thomas Latham
+* Update CI to use LCG\_105 on el9 with gcc13/clang16 by default
+ - Also update CI to avoid spurious failure of test stage
+ - Update clang-format config to clang16 and apply resulting changes
+
25 Oct 2024 Thomas Latham
* Fixes, updates and improvements to setupEvtGen script
7 Oct 2024 Thomas Latham
* D133: Fix bug in rotation to helicity basis for tensor particles
4 Oct 2024 Heather Ratcliffe, Thomas Latham, Fernando Abudinen
* D132: Introduce thread safety
- Protect statics: make them const or thread\_local
- Improve const-correctness of many functions
- Make thread\_local the RNG, particle property table, external factory, decay tables, and sym tables
- Add explicit mutexing to non-thread-safe externals (Sherpa, Tauola, Photos)
- Propagate the EvtGen seed to the Fortran RNG in Tauola
- Some fixes to EvtBtoXsEtap and EvtBtoXsgamma
- Reorganise test code for multi-threading
1 Oct 2024 Fernando Abudinen
* D131: Tauola tests
- Translated TAUOLA tests in validation to new json format
- Covered all 22 supported TAUOLA models
18 Sep 2024 Thomas Latham
* D130: Fix recently introduced bug in EvtDalitzReso for parent with significant natural width
- Add a test for eta\_c -> K+ K- pi0 under GENERIC\_DALITZ model
- Modify code to restore correct behaviour
- Make other general improvements to EvtDalitzReso class
14 Aug 2024 Fernando Abudinen
* D128: Improvements in EvtId and EvtPDL.
- Modernisation of EvtId class improving Boolean functions.
- Conversion of EvtPDL into thread-local singleton.
- Propagation of changes in EvtPDL to EvtGen initialisation.
9 Aug 2024 Fernando Abudinen
* D129: Added tests for PYTHIA interface
- Introduced new tests for decays with PYTHIA.
- Converted preexisting tests to json format based on new testing framework.
1 Aug 2024 Fernando Abudinen
* D127: Improve FSR mutexing by using `std::lock_guard`.
3 July 2024 Fernando Abudinen
* D126: Fix FSR initialisation for thread safety.
- Modified PHOTOS and Sherpa instances to become global static members
and made sure that they are initialised only once.
- Made sure that calls to these instances are mutexed.
- Made sure that all interface class members are initialised for each thread.
1 July 2024 Fernando Abudinen
* D125: Removed `EventHandler` in `EvtSherpaPhotons` interface to reduce initialisation overhead.
24 June 2024 John Back
* D124: Add EvtD0ToKspipi DP model, courtesy of Camille Normand (LHCb).
21 June 2024 Thomas Latham
* D123: Removed `EvtPatches.hh`. Removed unused `clock_t` typedef and redundant `UNUSED` macro.
20 June 2024 Thomas Latham
* D122: Fix compilation warnings under gcc13 and clang16
20 June 2024 Fernando Abudinen
* D121: Introduced function `setSeed` to set seed for random number engines.
19 June 2024 Thomas Latham
* D120: Remove "reference" field from JSON test files.
Instead simply prepend "Ref/" to output ROOT file name.
22 May 2024 Fernando Abudinen
* D118: Removed obsolete `ISR` attribute for photons. It was redundant as it was supposed to be
the contrary of the `FSR` attribute. It was never used and could lead to confusion.
- The `FSR` attribute is now set to 0 by default at initialisation for `EvtPhotonParticle`.
21 May 2024 Fernando Abudinen
* D115: Introduced Sherpa's PHOTONS++ generator
as alternative for final-state radiation simulation.
- Added Sherpa dependencies and linking in compilation files
- Introduced new `EvtSherpaPhotons` interface
- Introduced new `EvtSherpaRandom` interface to propagate EvtGen's random number into Sherpa
- Implemented `fsrGenerator` as input argument in `testDecayModel` module
8 May 2024 Michal Kreps, Thomas Latham, Andrii Verbytskyi
* D58: Rename member variables to follow convention of `m_` prefix
- In addition:
* Introduce pre-build check in the CI that convention is being followed in all classes
* Fix shadowing of variables in some classes
* Fixes to Doxygen configuration
* Enable shadowing and overloaded-virtual compiler warnings
23 Apr 2024 Thomas Latham
* D117: Drop redundant EVTGEN\_CPP11 preprocessor switch
22 Apr 2024 Fernando Abudinen
* D116: Replaced PHOTOS with FSR flags in examples and tests.
17 Apr 2024 Fernando Abudinen
* D114: Simplified pre-processor behaviour for PHOTOS.
12 Apr 2024 Fernando Abudinen
* D113: Introduced new FSR flag and deprecated PHOTOS flag.
Implemented proper use of neverRadCorr.
12 Apr 2024 Fernando Abudinen
* D112: Removed EvtPhotosEngine and moved its functionality EvtPHOTOS class.
Moved initialisation of fsrEngine to setRadCorrEngine.
11 Apr 2024 Thomas Latham
* D109: Remove broken or obsolete models
- Models removed:
* BHADRONIC
* BQTOLLLLHYPERCP
* BQTOLLLL
* D\_MULTIBODY
* KSTARSTARGAMMA
* LAMBDAB2LAMBDAV and subsidiary models LAMBDA2PPIFORLAMBDAB2LAMBDAV and V2VPVMFORLAMBDAB2LAMBDAV
* Lb2Lhh
* PROPSLPOLE
* VPHOTOV
* VPHOTOVISR
* VUB\_AC
- Classes in EvtGenBase already unused or used only by the above models also removed
* Evt3Rank3C
* EvtAbsBinning
* EvtAmpAmpPdf
* EvtAmpIndex
* EvtAmpSubIndex
* EvtBreitWignerPdf
* EvtDecayParm
* EvtIntegPdf1D
* EvtMBreitWigner
* EvtMHelAmp
* EvtMNode
* EvtMParticle
* EvtMLineShape
* EvtMRes
* EvtMTree
* EvtMTrivialLS
* EvtPointPred
* EvtPto3PAmpSmpResolution
* EvtSpinAmp
9 Apr 2024 Fernando Abudinen
* D111: Added tests for decays with FSR and implemented const correctness for getP4LabBeforeFSR() function.
19 Feb 2024 Fernando Abudinen
* D108: Bugfix protect polarisation vector for vector and tensor particles against wrong indices
19 Feb 2024 Fernando Abudinen
* D107: Implement const correctness for epsPhoton and epsParentPhoton
3 Feb 2024 John Back
* T230: Add EvtBcVPPHad model for Bc to Jpsi p pbar pi decays and generalised particle ordering
for EvtBcVHad decay files, courtesy of Aleksei Luchinsky, Dmitrii Pereima & Vanya Belyaev (LHCb).
Updated EvtPhiDalitz model to use helicity amplitudes and fixed the indices used in
EvtVector3R::dot(), courtesy of Arnau Brossa Gonzalo & Antonio Romero Vidal (LHCb).
31 Oct 2023 Fernando Abudinen
* D102: Bugfix probmax issue for X38722-+\_PSI\_GAMMA model
- Calculation of amplitude moved to dedicated calcAmp function and fixed initialisation.
- Introduced weighting to compensate for phase-space changes due to resonance width.
- Fixed bugs in rho couplings and loops over photon and vector states.
16 Oct 2023 Fernando Abudinen
* D99: Add tests for PHOTOS
- EvtParticle::getAttribute function made const
- Added variables for testing of FSR to testing framework
- Added dedicated tests for FSR with Photos
- Turned off Photos for all other tests
16 Oct 2023 Thomas Latham
* D98: Modernise EvtIdSet and other improvements
- Modernise and greatly simplify EvtIdSet implementation
- Fixes in EvtPropSLPole to avoid unnecessary dynamic allocations
- Other minor fixes and tidy-ups
* Credit to Heather Ratcliffe and Chris Brady for providing
and/or inspiring several of these improvements
22 Aug 2023 Fernando Abudinen
* D97: Bugfix probmax issue and introduced pole compensation for VTOSLL model
- Calculation of amplitude moved to dedicated calcAmp function and fixed initialisation.
22 Aug 2023 Tom Latham
* CMake updates
- Update default C++ standard to 17
- Suppress 'up-to-date' messages during install
- Add 'EvtGen' prefix to file names of custom CMake modules
- Remove unused CMake module
* Update CI config
- Update default LCG version to 103
- Add builds for el9 OS using LCG 104
- Allow switching on/off building against each external
- Test stage: attempt to improve selection of commits to diff in different cases
- Update CVMFS tags as per https://cern.service-now.com/service-portal?id=outage&n=OTG0079356
* Fix script for generating src dependencies
- Adapted to behaviour of newer CMake version in LCG 103
* Apply clang-format
- Few small changes after update of CI clang version to 12
- Document version of clang-format to be used
* Updates to install script
- Update to latest Pythia8 and HepMC3 versions
- Fix to ensure dependencies are picked up from the local install
22 Aug 2023 Andrii Verbytskyi
* Patch for finding Pythia8 xmldoc path
21 Aug 2023 Tom Latham
* D96: Work around change of interface for setRndmEnginePtr in Pythia8 310
22 Jun 2023 Ludovico Massaccesi
* T219: Fixed amplitudes for D_DALITZ model of D0 -> pi+ pi- pi0.
1 March 2023 Fernando Abudinen
* D92: Bugfix probmax issue for TENSOR daughter in EvtSSD_DirectCP model.
Calculation of amplitude in EvtSSD_DirectCP model moved to dedicated calcAmp function.
Got rid of a few static variables along the way.
8 Feb 2023 Alexei Sibidanov and Tom Latham
* D90: Apply clang format and enable checking of formatting in gitlab CI
3 Feb 2023 John Back
* D91: Check for non-zero momentum for EvtSLBaryonAmp parent spin density matrix.
Print out integrals of JSON test histograms.
16 Dec 2022 John Back
* D89: Added probabilities for B_c -> V pi+ and V pi+ pi0 EvtBcVHad modes.
16 Dec 2022 Alexei Sibidanov
* D88: Applied clang-tidy modernize-use-nullptr
13 Dec 2022 Fernando Abudinen and Tom Latham
* Various improvements to testing framework
16 Nov 2022 Tom Latham
* T123: Provide documention of how to contribute bug reports, feature requests, new/modified code
8 Sep 2022 Fernando Abudinen, John Back, Michal Kreps, Tom Latham, Alex Ward
* T108: Implement JSON test framework for all decay models
9 June 2022 Michal Kreps
* D84: Improve efficiency of RareLbToLll decay model for final states with e+e- pair.
===
## R02-02-00
12 May 2022 Michal Kreps
* D83: Fix double counting of charmonia with K0 decays for B0.
11 May 2022 Tom Latham
* D80: Add CMake options for enabling clang-tidy static analysis checks during build
14 Apr 2022 John Back
* D82: EvtDecayProb: initialise data members and remove empty destructor
14 Apr 2022 Michal Kreps
* D81: Derive EvtFlatSqDalitz from EvtDecayIncoherent since we directly provide
final kinematics
2nd Mar 2022 John Back
* D78: Add Bc -> J/psi K+ pi- pi+ pi- pi+, Bc -> J/psi K+ K- pi+ pi- pi+ &
Bc -> J/psi 4pi+ 3pi- decay modes to the BC_VHAD model, courtesy of
Aleksei Luchinsky, Anna Danilina, Dmitrii Pereima & Vanya Belyaev (LHCb)
===
## R02-01-01
8th Sep 2021 Michal Kreps
* Update location of web page for Pythia8 download in setup script.
8th Sep 2021 Markus Prim, Lu Cao, Chaoyi Lyu and Michel De Cian (Michal Kreps)
* D73: Add new model for semileptonic B decays with BCL and BGL form-factors
8th June 2021 Michal Kreps
* T110, D71: Fix B+ --> eta' l nu BF which was order of magnitude too high.
Balance the decrease by increasing B+ --> D0 l nu, which is after change
still bit smaller than PDG 2021.
8th Jun 2021 Michal Kreps
* D71: Fix B+ --> eta' l nu BF.
20th Apr 2021 Tom Lathem
* D68: Fix compilation with Pythia 8.304
17th Mar 2021 Michal Kreps
* D62: Improve PI0DALITZ model to dynamically work out maximum probability to
make it usuable also for eta --> llgamma decays.
Remove ETA2MUMUGAMMA since it is a pure one-to-one copy of PI0DALITZ.
15th Jan 2021 Michal Kreps
* D47: Model to generate 4-body phase-space decays in restricted part of the m12-m34 space
12th Jan 2021 Michal Kreps
* D48: Fix bug in calculation of the daughter momentum in decay model EvtBsMuMuKK
7th Jan 2021 Michal Kreps
* D43: Allow to pass particle properties table in form of stringstream to constructor
of EvtGen for use case where these are created on fly.
10th Dec 2020 Michal Kreps
* D36: EvtFlatSqDalitz model to be more efficient and to avoid cut-off around the edges
21st Aug 2020 John Back
* T109: Add EvtEtaLLPiPi model for eta' -> l l pi pi decays (l = e or mu),
- courtesy of Aleksei Luchinsky (LHCb).
29th Jun 2020 Michal Kreps
* T103: Add missing include in EvtGenBase/EvtMatrix.hh.
15th May 2020 Michal Kreps
* D28: Add EvtThreeBodyPhsp (rectangular Dalitz plot selection) and
EvtPhspDecaytimeCut (minimum decay time requirement) models.
* D27: Fix initialisation of constants in EvtBTo3hCP model.
===
## R02-00-00
24th Apr 2020 Michal Kreps
* Update particle properties file evt.pdl to 2019 version of RPP by PDG.
23rd Apr 2020 Tom Latham
* Apply copyright and licence notices to all relevant files.
17th Apr 2020 Tom Latham
* Add text of GNU GPLv3 in COPYING, add (preliminary) list of authors in
AUTHORS, and clean-up all source files, prior to applying copyright and
licence notices.
9th Apr 2020 Tom Latham
* Improve, and document use of, standalone installation script.
* Apply clang-format formatting to all C++ source files.
8th Apr 2020 Tom Latham
* One small modernisation change to EvtPhotosEngine to match that already
applied in EvtTauolaEngine.
8th Apr 2020 John Back
* Fixed NonReson amplitude and the 4-momentum boosts used for angles in
EvtLambdacPHH,
- courtesy of Elisabeth Niel (LHCb).
7th Apr 2020 Gerhard Raven, Tom Latham, Michal Kreps and John Back
* Incorporate C++ modernization changes from Gerhard Raven (LHCb).
- Merged modernize branch into master.
9th Mar 2020 John Back
* Add EvtAbsExternalGen::getDecayProb() to allow external generators to
return a probability that can be used in EvtDecayProb (default = 1).
6th Mar 2020 Andrii Verbytskyi and Tom Latham
* Implement HepMC3 support: EvtHepMCEvent, external engines & cmake files.
15th Nov 2019 John Back
* Added EvtPsi2JpsiPiPi model for psi2S -> J/psi pi+ pi- decays based on hep-ph/1507.07985,
- courtesy of Aleksei Luchinsky (LHCb).
21st August 2019 Michal Kreps
* Added the EvtDToKpienu decay model for D -> K pi e nu decays from BESIII,
- courtesy of Liaoyuan Dong.
16th July 2019 John Back
* Correct imaginary sign for EvtComplex /= (EvtComplex c) operator.
3rd July 2019 John Back
* Added the EvtLambdacPHH decay model for Lc -> p K pi decays with K*(890),
Delta++(1232) and Lambda(1520) resonances, based on the Fermilab E791
analysis hep-ex/9912003v1,
- courtesy of Elisabeth Niel and Patrick Robbe (LHCb).
* Modified EvtResonance2 to accept other barrier factor radii.
3rd July 2019 Michal Kreps
* Make sure minimum mass for resonances with non-zero widths is larger than
1e-4 GeV in EvtRelBreitWignerBarrierFact.
3rd May 2019 John Back
* Corrected EvtSLDiBaryonAmp bugs/issues in the BToDiBaryonlnupQCD model:
- parity, amplitude terms and B momentum reference frame variables.
* Corrected treament of spinor indices in EvtRareLb2Lll,
- courtesy of Tom Blake and Michal Kreps (LHCb).
* Updated the EvtBcVHad model to also handle Bc -> psi Ks K decays,
- courtesy of Aleksei Luchinsky (LHCb).
* Add new decay model EvtBsMuMuKK (BS_MUMUKK) for Bs to J/psi (mu+mu-) K+K-,
- courtesy of Veronika Chobanova, Jeremy Dalseno, Diego Martinez Santos and
Marcos Romero Lamas (LHCb).
* Fix infinite loop during initialisation of the EvtBTo3hCP model via
EvtCBTo3piP00 and EvtCBTo3piMPP,
- courtesy of Peter Richardson (Durham).
15th March 2019 Tom Latham
* Implement cmake build system, replacing the old config method.
30th Jan 2019 John Back
* Fix modernization compiler errors and warnings.
29th Jan 2019 Michal Kreps
* Allow reading decay files which are missing end-of-line before end-of-file.
21st December 2018 John Back
* Imported C++ modernization changes from Gerhard Raven (LHCb).
7th December 2018 John Back
* Added the EvtBLLNuL (BLLNUL) model that generates rare B -> ell ell nu ell
decays, where ell = e or mu,
- courtesy of Anna Danilina and Nikolai Nikitin (LHCb).
* Removed the EvtB2MuMuMuNu (BUTOMMMN) model, since its now replaced
by the more general BLLNuL one.
5th November 2018 John Back
* Added the BToDiBaryonlnupQCD model for generating B to p N* l nu decays,
where N can be any (exited) charged baryon (spin 1/2 or 3/2),
- courtesy of Mark Smith and Ryan Newcombe (LHCb), with added code optimisations.
17th October 2018 John Back
* Added various decay models from LHCb EvtGenExtras package:
- EvtBcVHad ("BC_VHAD"),
- Evtbs2llGammaMNT ("BSTOGLLMNT"),
- Evtbs2llGammaISRFSR ("BSTOGLLISRFSR"),
- EvtbTosllMS ("BTOSLLMS"),
- EvtbTosllMSExt ("BTOSLLMSEXT"),
- EvtLb2Baryonlnu ("Lb2Baryonlnu"),
- EvtLb2plnuLCSR ("Lb2plnuLCSR"),
- EvtLb2plnuLQCD ("Lb2plnuLQCD"),
- EvtFlatSqDalitz ("FLATSQDALITZ"),
- EvtPhspFlatLifetime ("PHSPFLATLIFETIME").
5th October 2018 John Back
* Updated setupEvtGen.sh to work with the new HepForge Phabricator site.
13th March 2018 John Back
* Updated EvtPythiaEngine to correctly handle updates of various particle
properties so that Pythia uses the same information as EvtGen (evt.pdl)
for the generic and alias PYTHIA decay model.
12th March 2018 John Back
* Updated EvtBcXMuNu models (X = Scalar, Vector, Tensor) to generate
Bc to D0(star) mu nu decays, with associated form factors in EvtBCXFF,
- courtesy of Aleksei Luchinsky (LHCb).
* Also generalised the calculation
of their maximum probabilities by reusing the CalcMaxProb method in
EvtSemiLeptonicAmp, which now allows for different Q^2 binning
(default remains at 25 bins).
===
## R01-07-00
13th December 2017 John Back
* New tag incorporating all changes below.
* Recommended external packages are
(as used in the setupEvtGen.sh script):
- HepMC 2.06.09,
- pythia 8.230,
- Photos++ 3.61
- Tauola++ 1.1.6c.
12th December 2017 John Back
* Changed Pythia validation example decay files to use Pythia8 codes.
6th December 2017 John Back
* Modified the examples to use DECAY.DEC (see 25th April 2016) instead of
DECAY_2010.DEC. Changed EvtExternalGenList to assume Pythia8 codes are
used in decay files by default, which is the case for DECAY.DEC. Also
updated the setupEvtGen.sh script to work with Pythia 8.2x versions.
29th November 2017 John Back
* Modified EvtSVP, EvtVVP and EvtTVP models to handle both radiative and
two-lepton decays,
- courtesy of Aleksei Luchinsky (LHCb).
14th July 2017 John Back
* Only create external generator objects if they don't already exist in
EvtExternalGenFactory.
* Modified configure script to work with Pythia 8.2x
5th July 2017 Michal Kreps
* Register the VTOSLL model.
14th June 2017 John Back
* Add isNeutralKaon() boolean function and corrected comments in EvtDDalitz.
8th May 2017 Michal Kreps
* Fix bug in EvtbTosllVectorAmp to recognise Bs --> K*bar mu mu decay as
b --> d ll transition.
8th May 2017 Michal Kreps
* Significantly simplify way how we decide on decay mode and daughters
ordering in DDalitz model.
- With new code by definition all orderings of
daughters in the decay file will yield same output.
4th May 2017 John Back
* Further fixes to DDalitz particle ordering (including charge-conjugates):
- Mode 5: D0 -> K- K0bar K+ and K+ K- K0bar
- Mode 12: D0 -> pi0 pi- pi+ and pi+ pi0 pi-
- Removed unneeded index ordering checks for mode 10 (D+ -> pi- pi+ pi+)
and mode 11 (Ds+ -> pi- pi+ pi+)
27th April 2017 John Back
* Fixed DDalitz particle ordering for mode 7: D+ -> pi+ K- K+ and K+ pi+ K-
and their charge-conjugates
7th April 2017 John Back
* Modified EvtGenExternal/EvtPythiaEngine to ensure that the EvtGen-based
instances of Pythia8 (for generic and alias decays) use the same
particle properties as defined by EvtGen,
- courtesy Patrick Robbe (LHCb).
5th April 2017 Michal Kreps
* Fixed indexing in copy constructor of Evt3Rank3C, which would otherwise
produce an infinite loop;
- bug report from David Grellscheid.
3rd November 2016 John Back
* Modified EvtFlatQ2 model to work for all B -> X lepton lepton modes, as
well as adding an extra phase space factor to correct for the dip at low
q^2, which is enabled by using "FLATQ2 1" instead of just "FLATQ2" in the decay file,
- courtesy of Marcin Chrzaszcz & Thomas Blake (LHCb).
13th October 2016 John Back
* Added the TauolaCurrentOption decfile keyword to select the hadronic
current in Tauola; default is the BaBar-tuned current option (int = 1).
* EvtParticles can store double attributes using the functions
setAttributeDouble(name, double) and getAttributeDouble(name), which can
be useful for storing and retrieving amplitude weights, for example.
- The analogous EvtParticle integer attribute interface remains unchanged:
setAttribute(name, int) and getAttribute(name).
13th September 2016 John Back
* Modified EvtTauolaEngine to use internal Tauola spin matrices for
tau pair events by temporarily setting the PDG id of the mother as a
boson, keeping the same 4-momentum.
* The BaBar hadronic currents are now used by default.
* Also added the ability to change some Tauola parameters
using the "Define" keyword in decay files.
* Added an example decay file
illustrating the new features: validation/TauolaFiles/Btautau.dec
9th September 2016 Michal Kreps
* Reimplement code in EvtBTo3pi.F, EvtBTo3piMPP.F, EvtBTo3piP00.F and
EvtBToKpipi.F in C++ in order to remove dependence on Fortran compiler.
- With this, there is no internal Fortran code in EvtGen.
===
## R01-06-00
1st June 2016 John Back
* New tag incorporating all changes below.
* Recommended external packages are
- HepMC 2.06.09
- pythia 8.186
- Photos++ 3.61
- Tauola++ 1.1.5
28th April 2016 Michal Kreps
* For Ds+ --> 2pi+ pi- there was double counting of branching fraction
resulting in total branching fraction being 1.5 times larger than measured
one.
- Fix by revisiting submodes, which now fill total Ds --> 3pi.
25th April 2016 Michal Kreps
* Added DECAY.DEC/XML, which contain updated semileptonic charm and beauty
branching fractions using the 2014 PDG, tuned to minimize disagreements
between measurements and EvtGen for both inclusive and exclusive decays.
* Updated the evt.pdl particle properties file to the PDG 2014 edition.
* Implemented new LQCD form factors for Lb --> L mu mu from arXiv paper
1602.01399 (EvtRareLbToLllFFlQCD); old LQCD form factors are removed.
18th March 2016 John Back
* Fixed incorrect spinor algebra used in S1 -> 1/2 S2, 1/2 -> S3 S4 decays
in EvtDiracParticle::rotateToHelicityBasis() functions,
- courtesy of Luis Miguel Garcia Martin and the IFIC Valencia LHCb group.
19th Feburary 2016 John Back
* Fixed bug in the definition of the initial spinor term Sinit in
EvtRareLbToLll::HadronicAmpRS(),
- from Tom Blake (LHCb).
12th February 2016 John Back
* From LHCb, added extensions to the EvtHQET2(FF) model for semitauonic
decays from Brian Hamilton, which needs a patch to EvtSemiLeptonicAmp
from Jack Wimberley to ensure that the q^2 range is physical when
finding the maximum amplitude probability.
2nd December 2015 John Back
* From LHCb, added EvtKStopizmumu model for KS -> pi0 mu mu decays based on
JHEP08(1998)004,
- courtesy of Veronika Chobanova, Diego Martinez Santos and Jeremy Dalseno.
* Added EvtConst::Fermi for Fermi coupling constant.
===
## R01-05-00
21st October 2015 John Back
* New tag incorporating all changes below.
* Recommended external packages are
- HepMC 2.06.09
- pythia 8.186
- Photos++ 3.61
- Tauola++ 1.1.5
* Added the EvtB2MuMuMuNu model for simulating the very rare four-leptonic
decays B- -> mu+ mu- anti-nu_mu mu-,
- courtesy Nikolai Nikitin.
16th October 2015 John Back
* Updated the configure script to automatically select the library names
for PHOTOS++; version 3.56 and below uses Fortran, version 3.61 and above
uses C++ only (default). Avoid using v3.60, since it does not work.
This needs the PHOTOS libraries built before EvtGen is configured.
Modified setupEvtGen.sh to use Photos++ v3.61.
7th October 2015 John Back
* Updated EvtGenExternal/EvtPhotosEngine to check that additional particles
from the outgoing vertex are indeed (FSR) photons, since later versions of
PHOTOS introduce pair emission, where particles may not always be photons.
* Added the genRootDecayChain.cc validation program to create ROOT files
containing information about the complete decay tree. Two example test
decay files BKstarGamma.dec and BuDst0rhop.dec can be used with this; the
first tests PHOTOS, the second looks at sequential decay chain storage.
The plotBKstarGamma.C ROOT macro can be used for B -> K* gamma plots.
2nd October 2015 John Back
* Modified EvtSVPHelAmp and added a new EvtSVPHelCPMix model, implementing
the complete mixing phenomenology of Bs to vector gamma decays,
- courtesy of Clara Remon (LHCb).
* EvtD0mixDalitz code: cleanup, inverted q/p for decays of D0bar (simplifies
user decay files) and fixed y parameter bug,
- courtesy of Jordi Tico (LHCb).
* Changed the initialisation order of the infrared cut-off in EvtPhotosEngine.
This actually has no effect, since the exponentiation function sets it to the
same 1e-7 value, but it is now in the correct order if we need to update it.
* Removed all remaining obsolete pragma (Win32) warnings from some classes.
23rd September 2015 Michal Kreps
* Reimplement the real Spence function in C++ and removed its fortran
implementation.
15th September 2015 Michal Kreps
* Fixed accessed uninitialised memory in EvtPDL.cpp, line 213.
* Modified the configure and setupEvtGen.sh scripts to work on Mac; needed
Mac compilation patch files added to the new "platform" subdirectory.
10th September 2015 John Back
* Updated setupEvtGen.sh to use the recommended external packages:
- HepMC 2.06.09, pythia 8.186, Photos++ 3.56 and Tauola++ 1.1.5.
* Fixed form-factor calculations for the BTOSLLBALL model 6 used to generate
b -> sll decays,
- courtesy of Christoph Langenbruch and David Loh (LHCb).
- Affects B->K*ll, B->rholl and B->omegall, particularly the electron modes.
* In the validation directory, added runPhotosTest.sh for testing FSR in
Upsilon(4S) -> e+ e- decays, and changed the plot comparison scripts to
use the 2nd directory "oldRootFiles" (which could be a soft-link) for
including ROOT histograms made from a previous version of EvtGen.
27th August 2015 John Back
* Added Mersenne-Twister random number generator (RNG) EvtMTRandomEngine.
- It requires c++11 compiler features (>= gcc 4.7), which should
automatically be enabled by the configure script.
- Introduced the preprocessor environment variable EVTGEN_CPP11 for c++11
features.
- EvtMTRandomEngine is the default RNG for the validation and test examples
if c++11 features are enabled.
* Added a phase-space test validation/genPHSP.sh and PhaseSpacePlots.C to
visually check the flatness of Dalitz plots in order to ensure that the
RNG is not producing biased results that depend on particle ordering.
* Added the models EvtbsToLLLLAmp and EvtbsToLLLLHyperCP for
B0_q -> l+ l- l+ l- decays (SM and one supersymmetric scenario),
- courtesy of Nikolai Nikitin and Konstantin Toms.
- Documentation provided in doc/evt_BQTOLLLL_model.pdf and
doc/evt_BQTOLLLLHYPERCP_model.pdf.
* Changed the installation and set-up script name to be just setupEvtGen.sh;
it uses the VERSION variable to specify the required tag. List of tags
are available using either "svn ls -v http://svn.cern.ch/guest/evtgen/tags"
or by going to http://svn.cern.ch/guest/evtgen/tags in a web browser.
12th June 2015 John Back
* Changed the width of chi_b1 in evt.pdl from 9.8928 GeV (!) to zero.
1st May 2015 John Back
* Added Bc -> scalar ell nu (EvtBcSMuNu) and Bc -> tensor ell nu
(EvtBcTMuNu) decays,
- courtesy of Jack Wimberley, LHCb.
- Also included the chi_c1 mode for EvtBcVMuNu.
===
## R01-04-00
2nd April 2015 John Back
* Removed the EvtStdlibRandomEngine class since this can produce biases
to kinematic distributions when one or more of the daughters is a
resonance, such as B0 -> K pi psi
- (thanks to Antonio Augusto Alves Jr who discovered this issue).
- EvtSimpleRandomEngine is now the default random number generator in the
validation and test examples.
* Incorporated several additions and modifications from LHCb:
a) From Michal Kreps, Tom Blake & Christoph Langenbruch,
added rare Lb --> Lambda^(*) ell ell models described in
arXiv:1108.6129, with various form factors from Gutsche et al.
(arXiv:1301.3737) and lattice QCD (arXiv:1212.4827)
b) From Andrew Crocombe, implemented Bs --> K* form factors
from Ball-Zwicky and z-parametrization form factors from
arXiv:1006.4945 for EvtbTosllBallFF
c) Christoph Langenbruch fixed the Bs -> phi ll form factors in
EvtbTosllBallFF; T3 showed a non-physical pole at very low
q2 which significantly affected the electron mode
d) From Michal Kreps, removed semicolons from wrong places to
clear warnings when compiled with the "-pedantic" option.
9th October 2014 John Back
* Change svnweb.cern.ch to svn.cern.ch in the setup script.
1st April 2014 John Back
* In EvtReport, modified the logging output severity status flags
to have the "EVTGEN_" prefix, e.g. INFO becomes EVTGEN_INFO.
* The global report() function has been renamed to EvtGenReport().
31st March 2014 John Back
* Added the ability to store named attributes for EvtParticles in the
form of a map<string, int>. The setAttribute(name, value) stores the
required value, while getAttribute(name) retrieves the integer value.
This is used in EvtPhotosEngine to specify the final-state radiation
"FSR" attribute to 1 for any additional photons (EvtPhotonParticles)
created by Photos++. It also stores the "ISR" attribute, but this
is always set to zero, since only FSR photons are created.
If the named attribute does not exist, then getAttribute() returns zero.
29th January 2014 Daniel Craik
* Removed mass assertion on GS shape in EvtDalitzReso to allow it to also
be used for charged rho resonances.
27th January 2014 John Back
* Minor corrections to Vub models to remove further gcc 4.8 warnings.
* Updated configure script to work for MacOS clang (from Genser team).
===
## R01-03-00
9th January 2014 John Back
* New tag version "1.3.0", incorporating all changes below.
* Replaced auto-install script to work with this version as well as
the latest versions of all external generator packages.
* Updated README to mention the new CERN-based web pages for Photos++
and Tauola++.
8th January 2014 John Back
* Fix gcc 4.6 and 4.8 compilation warnings,
- courtesy of Patrick Robbe (LHCb);
- main changes are removal of unused variables.
* Changed the EvtPythiaEngine class and configure script to use new
Pythia 8 header locations; Pythia 8.180 or above is now required.
7th January 2014 John Back
* Modified EvtBCVFF to correct the Kiselev form factors
- from Jack Wimberley (LHCb).
9th October 2013 Daniel Craik
* Added Gounaris-Sakurai and Gaussian shapes to EvtGenericDalitz
and set sensible defaults for LASS parameters.
19th September 2013 John Back
* Modified EvtGenExternal/EvtPythiaEngine to keep track of any new
particles that are added to the default Pythia database to avoid
duplicating particle/anti-particle entries that could override
previously defined Pythia decay chains.
18th September 2013 John Back
* Added Mac OS flags for the configure script and src/Makefile.
15th July 2013 Daniel Craik
* Added flag to turn on scaling of LASS amplitude by M/q in EvtDalitzReso
15th July 2013 Daniel Craik
* EvtParserXML now accepts file names containing environment variables,
exponential non-resonant shape in EvtDalitzReso now defined as exp(-alpha*m^2),
LASS shape in EvtDalitzReso now takes a cutoff parameter
4th July 2013 Daniel Craik
* Added LASS, exponential non-resonant and linear non-resonant shapes to EvtGenericDalitz.
3rd July 2013 Daniel Craik
* Fixed auto-install script for R01-02-00.
1st July 2013 Daniel Craik
* Added auto-install script for R01-02-00.
===
## R01-02-00
15th May 2013 John Back
* New tag, version "1.2.0", incorporating all changes below.
14th May 2013 Michal Kreps
* Added Blatt-Weisskopf barrier factors up to L=5 in
EvtGenBase/EvtBlattWeisskopf::compute().
14th May 2013 John Back
* Added additional entries (appended at the end) to the evt.pdl particle
data file
- courtesy of Romulus Godang and Belle II colleagues.
14th March 2013 John Back
* Added the method EvtParticle::getPDGId() to get the PDG integer for a
particle directly (which just calls EvtPDL::getStdHep()).
* Added a check in EvtPhotosEngine::doDecay to skip Photos if a given
particle has too many daughters (>= 10) to avoid a problem with a
hard coded upper limit in the Photos PHOENE subroutine.
2nd February 2013 Daniel Craik
* Updated EvtDalitzTable to estimate probMax when it is missing from a
Dalitz model.
1st February 2013 John Back
* Added the ability to read in Pythia 6 commands in ascii decay files in
EvtDecayTable::readDecayFile (this was already possible in xml files).
* Modified the Photos++ engine default settings to be more suited to B
decays (from LHCb defaults).
31st January 2013 John Back
* Added the ability to read in Pythia 8 commands in ascii decay files
in EvtDecayTable::readDecayFile. They can be set using the syntax:
"PythiaTypeParam module:variable=value", where Type = Generic, Alias or
Both for specifying whether the parameter is for the generic or alias
Pythia decay engines (or both). The 2nd argument must not contain any
spaces. Fixed the list of commands strings being used in the
EvtPythiaEngine class (i.e. Pythia parameters that can be set via decay
files).
31st January 2013 Daniel Craik
* Added named parameters to various decay models.
30th January 2013 John Back
* Fixed some of the parameter arguments used in the EvtSVSCPiso model.
24th January 2013 John Back
* Set the Photos++ and Tauola++ models to use the EvtGen random number
engine when useEvtGenRandom is set to true in the EvtExternalGenList
constructor.
23rd January 2013 John Back
* Added EvtGenExternal/EvtPythiaRandom to allow the use of the EvtGen
random number engine to also be used for the random engine for Pythia 8.
* Added a boolean (useEvtGenRandom, default = true) within the
EvtExternalGenList constructor to use this feature.
18th December 2012 John Back
* Corrected some wrong daughter ordering assignments for decay modes 5 and
12 in EvtDDalitz. Updated validation/DalitzDecays.xml to also contain
D decay mode 12, as well as various modes that may use K_S0 and K_L0.
* Added validation/genDDalitzModes.sh and updated validation/compareDalitz.C to
do a complete comparison of the D Dalitz modes with the xml versions.
11th December 2012 Daniel Craik
* Updated the Xml parser to support named model parameters.
* Updated the generic Dalitz model to use named model parameters as an example.
15th October 2012 John Back
* Make EvtSimpleRandomEngine inherit from EvtRandomEngine to avoid
crash in EvtGen.cpp when no random engine is defined
- (from Bjoern Spruck).
===
## R01-01-00
4th October 2012 John Back
* New tag, version "1.1.0", incorporating all changes below.
* Provide proper default constructors for EvtVector4R and
EvtPhotonParticle. Modified the validation and test code to also
compile/link in the case of no external generators being included.
3rd October 2012 John Back
* Corrected the t3 vector form factor values for the Ball-Zwicky 2005
model (modelId = 6) in EvtbTosllBallFF::getVectorFF(), which
were set to t3tilde instead.
18th September 2012 John Back
* Moved the external generator engines to a new sub-directory
EvtGenExternal. Building the code now creates 2 libraries:
libEvtGen.so (Base+Models) and libEvtGenExternal.so.
- This allows anyone to ignore using the new external generators
if required (by not creating/loading the 2nd library).
* Added prefix option to the configure script/Makefile to allow the user
to specify an installation directory for the include files, libraries,
DECAY.DEC and evt.pdl files (for Genser).
14th September 2012 Michal Kreps
* Fixed the calculation of the angle between decay planes in the function
EvtKine::EvtDecayAngleChi. Fixed typo in EvtLb2Lll decay model. Only
some NP scenarious could be affected, SM one is definitely unaffected.
13th September 2012 John Back
* Added the use of the environment variables EVTGEN_PHOTOS, EVTGEN_PYTHIA
and EVTGEN_TAUOLA to specify if the Photos, Pythia and/or Tauola engine
classes are used or not. These variables are set by the configure script,
depending if the library paths are specified for these generators.
===
## R01-00-01
12th September 2012 John Back
* New tag incorporating all changes below, since R01-00-00.
11th September 2012 John Back
* Modified the Photos and Tauola engine classes to use the new
Photospp and Tauolapp namespaces that are present in the latest
versions of Photos++(3.5) and Tauola++(1.0.7).
* Updated the configure file to get the correct location of the Tauola++
include files.
* Added the D0->pi+pi-pi0 decay mode in EvtDDalitz
- from Marco Gersabeck and Frederic Dreyer (LHCb).
* Added new decay models/classes from Alexey Luchinsky (LHCb):
EvtBcVMuNu, EvtTVP, EvtWnPi, EvtSVP, EvtXPsiGamma, EvtBcVNpi
29th June 2012 John Back
* Corrected mass(squared) variables filled in the Dalitz TTree in
validation/genExampleRootFiles.
15th May 2012 Daniel Craik
* Updated EvtD0gammaDalitz to deal with D mesons from neutral B->DK
* Added save function to validation/compareDalitz.C.
11th May 2012 Daniel Craik
* Replaced BaBar specific configuration for BlattWeisskopf birth factors.
* Updated XML conversion script to handle new configuration.
* Fixed some bugs in the XML conversion script related to particle
modifications.
9th May 2012 Daniel Craik
* Added latex documentation for xml decay files.
2nd May 2012 Daniel Craik
* Added resDaughters attribute to the Dalitz resonance xml tag to
simplify defining symmetric resonances. Updated validation xml files to
use the new functionality.
27th April 2012 Daniel Craik
* Upgraded EvtGenericDalitz to use EvtDalitzReso for resonances.
* Added validation to compare EvtGenericDalitz to all 11 EvtDDalitz modes.
* Added a root macro to quickly compare two Dalitz decays for validation.
24th April 2012 John Back
* Solved two bugs in the EvtD0gammaDalitz model (from Jordi Tico, LHCb):
configuration of the conjugated model, and using only the B charge
to determine the model used, not the D flavour.
17th April 2012 Daniel Craik
* Updated the GenericDalitz validation code to use the same probMax
values as DDalitz.
* Added XML decay file parsing to EvtGen::readUDecay.
- Dec files are still the default.
30th March 2012 John Back
* Update maximum probability values in EvtDDalitz::initProbMax()
for all DDalitz modes.
23rd March 2012 John Back
* Added the EvtEta2MuMuGamma decay model from LHCb.
21st March 2012 John Back
* Added EvtD0gammaDalitz decay model from LHCb.
20th March 2012 Daniel Craik
* Added backwards compatibility for Pythia 6 commands in the XML configuration.
* Updated decay file conversion tool to convert JetSetPar lines to pythia6Param
tags.
19th March 2012 Daniel Craik
* Added infrastructure to pass commands to external generators.
* XML config now takes Pythia8 configuration commands.
16th March 2012 Daniel Craik
* Added the ability to define particles from the PDL for Dalitz decay
resonances instead of defining mass, width and spin seperately.
* Renamed the lifetime attribute of Dalitz decay resonaces to width to avoid
confusion.
* Added further validation code for the generic Dalitz model.
15th March 2012 Daniel Craik
* Added validation code for xml decay files and the generic Dalitz model.
===
## R01-00-00
6th March 2012 John Back
* First official version for Genser (evtgen 1.0.0) that includes
support for external generators: Pythia8, Photos++ and Tauola++.
* This also includes a preliminary version of creating Dalitz plot
decay models using EvtGenericDalitz.
diff --git a/src/EvtGenBase/EvtDalitzReso.cpp b/src/EvtGenBase/EvtDalitzReso.cpp
index 074a600..cab04f1 100644
--- a/src/EvtGenBase/EvtDalitzReso.cpp
+++ b/src/EvtGenBase/EvtDalitzReso.cpp
@@ -1,1072 +1,1072 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenBase/EvtDalitzReso.hh"
#include "EvtGenBase/EvtCyclic3.hh"
#include "EvtGenBase/EvtGenKine.hh"
#include "EvtGenBase/EvtMatrix.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtReport.hh"
#include "EvtGenBase/EvtdFunction.hh"
#include <assert.h>
#include <cmath>
#include <iostream>
#include <stdlib.h>
#define PRECISION ( 1.e-3 )
using EvtCyclic3::Index;
using EvtCyclic3::Pair;
// single Breit-Wigner
EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, Pair pairAng, Pair pairRes,
EvtSpinType::spintype spin, double m0, double g0,
NumType typeN, double f_b, double f_d ) :
m_dp( dp ),
m_pairAng( pairAng ),
m_pairRes( pairRes ),
m_spin( spin ),
m_typeN( typeN ),
m_m0( m0 ),
m_g0( g0 ),
m_massFirst( dp.m( first( pairRes ) ) ),
m_massSecond( dp.m( second( pairRes ) ) ),
m_m0_mix( -1. ),
m_g0_mix( 0. ),
m_delta_mix( 0. ),
m_amp_mix( 0., 0. ),
m_g1( -1. ),
m_g2( -1. ),
m_coupling2( Undefined ),
m_f_b( f_b ),
m_f_d( f_d ),
m_kmatrix_index( -1 ),
m_fr12prod( 0., 0. ),
m_fr13prod( 0., 0. ),
m_fr14prod( 0., 0. ),
m_fr15prod( 0., 0. ),
m_s0prod( 0. ),
m_a( 0. ),
m_r( 0. ),
m_Blass( 0. ),
m_phiB( 0. ),
m_R( 0. ),
m_phiR( 0. ),
m_cutoff( -1. ),
m_scaleByMOverQ( false ),
m_alpha( 0. )
{
assert( m_typeN != K_MATRIX && m_typeN != K_MATRIX_I &&
m_typeN != K_MATRIX_II ); // single BW cannot be K-matrix
}
// Breit-Wigner with electromagnetic mass mixing
EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, Pair pairAng, Pair pairRes,
EvtSpinType::spintype spin, double m0, double g0,
NumType typeN, double m0_mix, double g0_mix,
double delta_mix, EvtComplex amp_mix ) :
m_dp( dp ),
m_pairAng( pairAng ),
m_pairRes( pairRes ),
m_spin( spin ),
m_typeN( typeN ),
m_m0( m0 ),
m_g0( g0 ),
m_massFirst( dp.m( first( pairRes ) ) ),
m_massSecond( dp.m( second( pairRes ) ) ),
m_m0_mix( m0_mix ),
m_g0_mix( g0_mix ),
m_delta_mix( delta_mix ),
m_amp_mix( amp_mix ),
m_g1( -1. ),
m_g2( -1. ),
m_coupling2( Undefined ),
m_f_b( 0.0 ),
m_f_d( 1.5 ),
m_kmatrix_index( -1 ),
m_fr12prod( 0., 0. ),
m_fr13prod( 0., 0. ),
m_fr14prod( 0., 0. ),
m_fr15prod( 0., 0. ),
m_s0prod( 0. ),
m_a( 0. ),
m_r( 0. ),
m_Blass( 0. ),
m_phiB( 0. ),
m_R( 0. ),
m_phiR( 0. ),
m_cutoff( -1. ),
m_scaleByMOverQ( false ),
m_alpha( 0. )
{
// single BW (with electromagnetic mixing) cannot be K-matrix
assert( m_typeN != K_MATRIX && m_typeN != K_MATRIX_I &&
m_typeN != K_MATRIX_II );
}
// coupled Breit-Wigner
EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, Pair pairAng,
Pair pairRes, EvtSpinType::spintype spin,
double m0, NumType typeN, double g1, double g2,
CouplingType coupling2 ) :
m_dp( dp ),
m_pairAng( pairAng ),
m_pairRes( pairRes ),
m_spin( spin ),
m_typeN( typeN ),
m_m0( m0 ),
m_g0( -1. ),
m_massFirst( dp.m( first( pairRes ) ) ),
m_massSecond( dp.m( second( pairRes ) ) ),
m_m0_mix( -1. ),
m_g0_mix( 0. ),
m_delta_mix( 0. ),
m_amp_mix( 0., 0. ),
m_g1( g1 ),
m_g2( g2 ),
m_coupling2( coupling2 ),
m_f_b( 0.0 ),
m_f_d( 1.5 ),
m_kmatrix_index( -1 ),
m_fr12prod( 0., 0. ),
m_fr13prod( 0., 0. ),
m_fr14prod( 0., 0. ),
m_fr15prod( 0., 0. ),
m_s0prod( 0. ),
m_a( 0. ),
m_r( 0. ),
m_Blass( 0. ),
m_phiB( 0. ),
m_R( 0. ),
m_phiR( 0. ),
m_cutoff( -1. ),
m_scaleByMOverQ( false ),
m_alpha( 0. )
{
assert( m_coupling2 != Undefined );
assert( m_typeN != K_MATRIX && m_typeN != K_MATRIX_I &&
m_typeN != K_MATRIX_II ); // coupled BW cannot be K-matrix
assert( m_typeN != LASS ); // coupled BW cannot be LASS
assert( m_typeN != NBW ); // for coupled BW, only relativistic BW
}
// K-Matrix (A&S)
EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, Pair pairRes,
std::string nameIndex, NumType typeN,
EvtComplex fr12prod, EvtComplex fr13prod,
EvtComplex fr14prod, EvtComplex fr15prod,
double s0prod ) :
m_dp( dp ),
m_pairRes( pairRes ),
m_typeN( typeN ),
m_m0( 0. ),
m_g0( 0. ),
m_massFirst( dp.m( first( pairRes ) ) ),
m_massSecond( dp.m( second( pairRes ) ) ),
m_m0_mix( -1. ),
m_g0_mix( 0. ),
m_delta_mix( 0. ),
m_amp_mix( 0., 0. ),
m_g1( -1. ),
m_g2( -1. ),
m_coupling2( Undefined ),
m_f_b( 0. ),
m_f_d( 0. ),
m_kmatrix_index( -1 ),
m_fr12prod( fr12prod ),
m_fr13prod( fr13prod ),
m_fr14prod( fr14prod ),
m_fr15prod( fr15prod ),
m_s0prod( s0prod ),
m_a( 0. ),
m_r( 0. ),
m_Blass( 0. ),
m_phiB( 0. ),
m_R( 0. ),
m_phiR( 0. ),
m_cutoff( -1. ),
m_scaleByMOverQ( false ),
m_alpha( 0. )
{
assert( m_typeN == K_MATRIX || m_typeN == K_MATRIX_I ||
m_typeN == K_MATRIX_II );
m_spin = EvtSpinType::SCALAR;
if ( nameIndex == "Pole1" )
m_kmatrix_index = 1;
else if ( nameIndex == "Pole2" )
m_kmatrix_index = 2;
else if ( nameIndex == "Pole3" )
m_kmatrix_index = 3;
else if ( nameIndex == "Pole4" )
m_kmatrix_index = 4;
else if ( nameIndex == "Pole5" )
m_kmatrix_index = 5;
else if ( nameIndex == "f11prod" )
m_kmatrix_index = 6;
else
assert( 0 );
}
// LASS parameterization
EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, Pair pairRes, double m0,
double g0, double a, double r, double B,
double phiB, double R, double phiR, double cutoff,
bool scaleByMOverQ ) :
m_dp( dp ),
m_pairRes( pairRes ),
m_typeN( LASS ),
m_m0( m0 ),
m_g0( g0 ),
m_massFirst( dp.m( first( pairRes ) ) ),
m_massSecond( dp.m( second( pairRes ) ) ),
m_m0_mix( -1. ),
m_g0_mix( 0. ),
m_delta_mix( 0. ),
m_amp_mix( 0., 0. ),
m_g1( -1. ),
m_g2( -1. ),
m_coupling2( Undefined ),
m_f_b( 0.0 ),
m_f_d( 1.5 ),
m_kmatrix_index( -1 ),
m_fr12prod( 0., 0. ),
m_fr13prod( 0., 0. ),
m_fr14prod( 0., 0. ),
m_fr15prod( 0., 0. ),
m_s0prod( 0. ),
m_a( a ),
m_r( r ),
m_Blass( B ),
m_phiB( phiB ),
m_R( R ),
m_phiR( phiR ),
m_cutoff( cutoff ),
m_scaleByMOverQ( scaleByMOverQ ),
m_alpha( 0. )
{
m_spin = EvtSpinType::SCALAR;
}
//Flatte
EvtDalitzReso::EvtDalitzReso( const EvtDalitzPlot& dp, EvtCyclic3::Pair pairRes,
double m0 ) :
m_dp( dp ),
m_pairRes( pairRes ),
m_typeN( FLATTE ),
m_m0( m0 ),
m_g0( 0. ),
m_massFirst( dp.m( first( pairRes ) ) ),
m_massSecond( dp.m( second( pairRes ) ) ),
m_m0_mix( -1. ),
m_g0_mix( 0. ),
m_delta_mix( 0. ),
m_amp_mix( 0., 0. ),
m_g1( -1. ),
m_g2( -1. ),
m_coupling2( Undefined ),
m_f_b( 0. ),
m_f_d( 0. ),
m_kmatrix_index( -1 ),
m_fr12prod( 0., 0. ),
m_fr13prod( 0., 0. ),
m_fr14prod( 0., 0. ),
m_fr15prod( 0., 0. ),
m_s0prod( 0. ),
m_a( 0. ),
m_r( 0. ),
m_Blass( 0. ),
m_phiB( 0. ),
m_R( 0. ),
m_phiR( 0. ),
m_cutoff( -1. ),
m_scaleByMOverQ( false ),
m_alpha( 0. )
{
m_spin = EvtSpinType::SCALAR;
}
EvtComplex EvtDalitzReso::evaluate( const EvtDalitzPoint& x ) const
{
if ( m_typeN == NON_RES )
return EvtComplex( 1.0, 0.0 );
const double s = x.q( m_pairRes );
const double m = sqrt( s );
if ( m_typeN == NON_RES_LIN )
return s;
if ( m_typeN == NON_RES_EXP )
return exp( -m_alpha * s );
// do use always hash table (speed up fitting)
if ( m_typeN == K_MATRIX || m_typeN == K_MATRIX_I || m_typeN == K_MATRIX_II )
return Fvector( s, m_kmatrix_index );
if ( m_typeN == FLATTE )
return flatte( s );
EvtTwoBodyVertex vd( m_massFirst, m_massSecond, m_m0, m_spin );
vd.set_f( m_f_d );
const EvtTwoBodyKine kd( m_massFirst, m_massSecond, m );
if ( m_typeN == LASS )
return lass( kd, vd );
EvtComplex amp( 1.0, 0.0 );
EvtTwoBodyVertex vb( m_m0, m_dp.m( EvtCyclic3::other( m_pairRes ) ),
x.bigM(), m_spin );
vb.set_f( m_f_b );
const EvtTwoBodyKine kb( m, x.m( EvtCyclic3::other( m_pairRes ) ), x.bigM() );
EvtComplex prop( 0, 0 );
if ( m_typeN == NBW ) {
prop = propBreitWigner( m_m0, m_g0, m );
} else if ( m_typeN == GAUSS_CLEO || m_typeN == GAUSS_CLEO_ZEMACH ) {
prop = propGauss( m_m0, m_g0, m );
} else {
if ( m_coupling2 == Undefined ) {
// single BW
const double g = ( m_g0 <= 0. || vd.pD() <= 0. )
- ? -m_g0
- : m_g0 * vd.widthFactor( kd ); // running width
+ ? -m_g0
+ : m_g0 * vd.widthFactor( kd ); // running width
if ( m_typeN == GS_CLEO || m_typeN == GS_CLEO_ZEMACH ) {
// Gounaris-Sakurai (GS)
prop = propGounarisSakurai( m_m0, fabs( m_g0 ), vd.pD(), m, g,
kd.p() );
} else {
// standard relativistic BW
prop = propBreitWignerRel( m_m0, g, m );
}
} else {
// coupled width BW
EvtComplex G1, G2;
switch ( m_coupling2 ) {
case PicPic: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mPic = EvtPDL::getMass(
EvtPDL::getId( "pi+" ) );
G2 = m_g2 * m_g2 * psFactor( mPic, mPic, m );
break;
}
case PizPiz: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mPiz = EvtPDL::getMass(
EvtPDL::getId( "pi0" ) );
G2 = m_g2 * m_g2 * psFactor( mPiz, mPiz, m );
break;
}
case PiPi: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mPic = EvtPDL::getMass(
EvtPDL::getId( "pi+" ) );
static const double mPiz = EvtPDL::getMass(
EvtPDL::getId( "pi0" ) );
G2 = m_g2 * m_g2 * psFactor( mPic, mPic, mPiz, mPiz, m );
break;
}
case KcKc: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mKc = EvtPDL::getMass(
EvtPDL::getId( "K+" ) );
G2 = m_g2 * m_g2 * psFactor( mKc, mKc, m );
break;
}
case KzKz: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mKz = EvtPDL::getMass(
EvtPDL::getId( "K0" ) );
G2 = m_g2 * m_g2 * psFactor( mKz, mKz, m );
break;
}
case KK: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mKc = EvtPDL::getMass(
EvtPDL::getId( "K+" ) );
static const double mKz = EvtPDL::getMass(
EvtPDL::getId( "K0" ) );
G2 = m_g2 * m_g2 * psFactor( mKc, mKc, mKz, mKz, m );
break;
}
case EtaPic: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mEta = EvtPDL::getMass(
EvtPDL::getId( "eta" ) );
static const double mPic = EvtPDL::getMass(
EvtPDL::getId( "pi+" ) );
G2 = m_g2 * m_g2 * psFactor( mEta, mPic, m );
break;
}
case EtaPiz: {
G1 = m_g1 * m_g1 * psFactor( m_massFirst, m_massSecond, m );
static const double mEta = EvtPDL::getMass(
EvtPDL::getId( "eta" ) );
static const double mPiz = EvtPDL::getMass(
EvtPDL::getId( "pi0" ) );
G2 = m_g2 * m_g2 * psFactor( mEta, mPiz, m );
break;
}
case PicPicKK: {
static const double mPic = EvtPDL::getMass(
EvtPDL::getId( "pi+" ) );
G1 = m_g1 * psFactor( mPic, mPic, m );
static const double mKc = EvtPDL::getMass(
EvtPDL::getId( "K+" ) );
static const double mKz = EvtPDL::getMass(
EvtPDL::getId( "K0" ) );
G2 = m_g2 * psFactor( mKc, mKc, mKz, mKz, m );
break;
}
default:
std::cout
<< "EvtDalitzReso:evaluate(): PANIC, wrong coupling2 state."
<< std::endl;
assert( 0 );
break;
}
// calculate standard couple BW propagator
if ( m_coupling2 != WA76 )
prop = m_g1 * propBreitWignerRelCoupled( m_m0, G1, G2, m );
}
}
amp *= prop;
// Compute form-factors (Blatt-Weisskopf penetration factor)
amp *= vb.formFactor( kb );
amp *= vd.formFactor( kd );
// Compute numerator (angular distribution)
amp *= numerator( x, vb, vd, kb, kd );
// Compute electromagnetic mass mixing factor
if ( m_m0_mix > 0. ) {
EvtComplex prop_mix;
if ( m_typeN == NBW ) {
prop_mix = propBreitWigner( m_m0_mix, m_g0_mix, m );
} else {
assert( m_g1 < 0. ); // running width only
const double g_mix = m_g0_mix * vd.widthFactor( kd );
prop_mix = propBreitWignerRel( m_m0_mix, g_mix, m );
}
amp *= mixFactor( prop, prop_mix );
}
return amp;
}
EvtComplex EvtDalitzReso::psFactor( const double ma, const double mb,
const double m ) const
{
if ( m > ( ma + mb ) ) {
const EvtTwoBodyKine kd( ma, mb, m );
return EvtComplex( 0, 2 * kd.p() / m );
} else {
// analytical continuation
const double s = m * m;
const double phaseFactor_analyticalCont =
-0.5 * ( sqrt( 4 * ma * ma / s - 1 ) + sqrt( 4 * mb * mb / s - 1 ) );
return EvtComplex( phaseFactor_analyticalCont, 0 );
}
}
EvtComplex EvtDalitzReso::psFactor( const double ma1, const double mb1,
const double ma2, const double mb2,
const double m ) const
{
return 0.5 * ( psFactor( ma1, mb1, m ) + psFactor( ma2, mb2, m ) );
}
EvtComplex EvtDalitzReso::propGauss( const double m0, const double s0,
const double m ) const
{
// Gaussian
const double gauss = 1. / sqrt( EvtConst::twoPi ) / s0 *
exp( -( m - m0 ) * ( m - m0 ) / 2. / ( s0 * s0 ) );
return EvtComplex( gauss, 0. );
}
EvtComplex EvtDalitzReso::propBreitWigner( const double m0, const double g0,
const double m ) const
{
// non-relativistic BW
return sqrt( g0 / EvtConst::twoPi ) / ( m - m0 - EvtComplex( 0.0, g0 / 2. ) );
}
EvtComplex EvtDalitzReso::propBreitWignerRel( const double m0, const double g0,
const double m ) const
{
// relativistic BW with real width
return 1. / ( m0 * m0 - m * m - EvtComplex( 0., m0 * g0 ) );
}
EvtComplex EvtDalitzReso::propBreitWignerRel( const double m0,
const EvtComplex& g0,
const double m ) const
{
// relativistic BW with complex width
return 1. / ( m0 * m0 - m * m - EvtComplex( 0., m0 ) * g0 );
}
EvtComplex EvtDalitzReso::propBreitWignerRelCoupled( const double m0,
const EvtComplex& g1,
const EvtComplex& g2,
const double m ) const
{
// relativistic coupled BW
return 1. / ( m0 * m0 - m * m - ( g1 + g2 ) );
}
EvtComplex EvtDalitzReso::propGounarisSakurai( const double m0, const double g0,
const double k0, const double m,
const double g,
const double k ) const
{
// Gounaris-Sakurai parameterization of pi+pi- P wave. PRD, Vol61, 112002. PRL, Vol21, 244.
// Expressions taken from BAD637v4, after fixing the imaginary part of the BW denominator: i M_R Gamma_R(s) --> i sqrt(s) Gamma_R(s)
return ( 1. + GS_d( m0, k0 ) * g0 / m0 ) /
( m0 * m0 - m * m - EvtComplex( 0., m * g ) +
GS_f( m0, g0, k0, m, k ) );
}
inline double EvtDalitzReso::GS_f( const double m0, const double g0,
const double k0, const double m,
const double k ) const
{
// m: sqrt(s)
// m0: nominal resonance mass
// k: momentum of pion in resonance rest frame (at m)
// k0: momentum of pion in resonance rest frame (at nominal resonance mass)
return g0 * m0 * m0 / ( k0 * k0 * k0 ) *
( k * k * ( GS_h( m, k ) - GS_h( m0, k0 ) ) +
( m0 * m0 - m * m ) * k0 * k0 * GS_dhods( m0, k0 ) );
}
inline double EvtDalitzReso::GS_h( const double m, const double k ) const
{
return 2. / EvtConst::pi * k / m *
log( ( m + 2. * k ) / ( 2. * m_massFirst ) );
}
inline double EvtDalitzReso::GS_dhods( const double m0, const double k0 ) const
{
return GS_h( m0, k0 ) * ( 0.125 / ( k0 * k0 ) - 0.5 / ( m0 * m0 ) ) +
0.5 / ( EvtConst::pi * m0 * m0 );
}
inline double EvtDalitzReso::GS_d( const double m0, const double k0 ) const
{
return 3. / EvtConst::pi * m_massFirst * m_massFirst / ( k0 * k0 ) *
log( ( m0 + 2. * k0 ) / ( 2. * m_massFirst ) ) +
m0 / ( 2. * EvtConst::pi * k0 ) -
m_massFirst * m_massFirst * m0 / ( EvtConst::pi * k0 * k0 * k0 );
}
EvtComplex EvtDalitzReso::numerator( const EvtDalitzPoint& x,
const EvtTwoBodyVertex& vb,
const EvtTwoBodyVertex& vd,
const EvtTwoBodyKine& kb,
const EvtTwoBodyKine& kd ) const
{
EvtComplex ret( 0., 0. );
// Non-relativistic Breit-Wigner
if ( NBW == m_typeN ) {
ret = angDep( x );
}
// Standard relativistic Zemach propagator
else if ( RBW_ZEMACH == m_typeN ) {
ret = vd.phaseSpaceFactor( kd, EvtTwoBodyKine::AB ) * angDep( x );
}
// Standard relativistic Zemach propagator
else if ( RBW_ZEMACH2 == m_typeN ) {
ret = vd.phaseSpaceFactor( kd, EvtTwoBodyKine::AB ) *
vb.phaseSpaceFactor( kb, EvtTwoBodyKine::AB ) * angDep( x );
if ( m_spin == EvtSpinType::VECTOR ) {
ret *= -4.;
} else if ( m_spin == EvtSpinType::TENSOR ) {
ret *= 16. / 3.;
} else if ( m_spin != EvtSpinType::SCALAR )
assert( 0 );
}
// Kuehn-Santamaria normalization:
else if ( RBW_KUEHN == m_typeN ) {
ret = m_m0 * m_m0 * angDep( x );
}
// CLEO amplitude
else if ( ( RBW_CLEO == m_typeN ) || ( GS_CLEO == m_typeN ) ||
( RBW_CLEO_ZEMACH == m_typeN ) || ( GS_CLEO_ZEMACH == m_typeN ) ||
( GAUSS_CLEO == m_typeN ) || ( GAUSS_CLEO_ZEMACH == m_typeN ) ) {
const Index iA = other( m_pairAng ); // A = other(BC)
const Index iB = common( m_pairRes, m_pairAng ); // B = common(AB,BC)
const Index iC = other( m_pairRes ); // C = other(AB)
const double M = x.bigM();
const double mA = x.m( iA );
const double mB = x.m( iB );
const double mC = x.m( iC );
const double qAB = x.q( combine( iA, iB ) );
const double qBC = x.q( combine( iB, iC ) );
const double qCA = x.q( combine( iC, iA ) );
const double M2 = M * M;
const double m02 = ( ( RBW_CLEO_ZEMACH == m_typeN ) ||
( GS_CLEO_ZEMACH == m_typeN ) ||
( GAUSS_CLEO_ZEMACH == m_typeN ) )
- ? qAB
- : m_m0 * m_m0;
+ ? qAB
+ : m_m0 * m_m0;
const double mA2 = mA * mA;
const double mB2 = mB * mB;
const double mC2 = mC * mC;
if ( m_spin == EvtSpinType::SCALAR )
ret = EvtComplex( 1., 0. );
else if ( m_spin == EvtSpinType::VECTOR ) {
ret = qCA - qBC + ( M2 - mC2 ) * ( mB2 - mA2 ) / m02;
} else if ( m_spin == EvtSpinType::TENSOR ) {
const double x1 = qBC - qCA + ( M2 - mC2 ) * ( mA2 - mB2 ) / m02;
const double x2 = M2 - mC2;
const double x3 = qAB - 2 * M2 - 2 * mC2 + x2 * x2 / m02;
const double x4 = mA2 - mB2;
const double x5 = qAB - 2 * mB2 - 2 * mA2 + x4 * x4 / m02;
ret = x1 * x1 - x3 * x5 / 3.;
} else
assert( 0 );
}
return ret;
}
double EvtDalitzReso::angDep( const EvtDalitzPoint& x ) const
{
// Angular dependece for factorizable amplitudes
// unphysical cosines indicate we are in big trouble
const double cosTh = x.cosTh(
m_pairAng, m_pairRes ); // angle between common(reso,ang) and other(reso)
if ( fabs( cosTh ) > 1. ) {
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "cosTh " << cosTh << std::endl;
assert( 0 );
}
// in units of half-spin
return EvtdFunction::d( EvtSpinType::getSpin2( m_spin ), 2 * 0, 2 * 0,
acos( cosTh ) );
}
EvtComplex EvtDalitzReso::mixFactor( const EvtComplex& prop,
const EvtComplex& prop_mix ) const
{
const double Delta = m_delta_mix * ( m_m0 + m_m0_mix );
return 1 / ( 1 - Delta * Delta * prop * prop_mix ) *
( 1 + m_amp_mix * Delta * prop_mix );
}
EvtComplex EvtDalitzReso::Fvector( const double s, const int index ) const
{
assert( index >= 1 && index <= 6 );
//Define the complex coupling constant
//The convection is as follow
//i=0 --> pi+ pi-
//i=1 --> KK
//i=2 --> 4pi
//i=3 --> eta eta
//i=4 --> eta eta'
//The first index is the resonace-pole index
double g[5][5]; // Coupling constants. The first index is the pole index. The second index is the decay channel
double ma[5]; // Pole masses. The unit is in GeV
const int solution = ( m_typeN == K_MATRIX )
- ? 3
- : ( ( m_typeN == K_MATRIX_I )
- ? 1
- : ( ( m_typeN == K_MATRIX_II ) ? 2 : 0 ) );
+ ? 3
+ : ( ( m_typeN == K_MATRIX_I )
+ ? 1
+ : ( ( m_typeN == K_MATRIX_II ) ? 2 : 0 ) );
if ( solution == 0 ) {
std::cout << "EvtDalitzReso::Fvector() error. Kmatrix solution incorrectly chosen ! "
<< std::endl;
abort();
}
if ( solution == 3 ) {
// coupling constants
//pi+pi- channel
g[0][0] = 0.22889;
g[1][0] = 0.94128;
g[2][0] = 0.36856;
g[3][0] = 0.33650;
g[4][0] = 0.18171;
//K+K- channel
g[0][1] = -0.55377;
g[1][1] = 0.55095;
g[2][1] = 0.23888;
g[3][1] = 0.40907;
g[4][1] = -0.17558;
//4pi channel
g[0][2] = 0;
g[1][2] = 0;
g[2][2] = 0.55639;
g[3][2] = 0.85679;
g[4][2] = -0.79658;
//eta eta channel
g[0][3] = -0.39899;
g[1][3] = 0.39065;
g[2][3] = 0.18340;
g[3][3] = 0.19906;
g[4][3] = -0.00355;
//eta eta' channel
g[0][4] = -0.34639;
g[1][4] = 0.31503;
g[2][4] = 0.18681;
g[3][4] = -0.00984;
g[4][4] = 0.22358;
// Pole masses
ma[0] = 0.651;
ma[1] = 1.20360;
ma[2] = 1.55817;
ma[3] = 1.21000;
ma[4] = 1.82206;
} else if ( solution == 1 ) { // solnI.txt
// coupling constants
//pi+pi- channel
g[0][0] = 0.31896;
g[1][0] = 0.85963;
g[2][0] = 0.47993;
g[3][0] = 0.45121;
g[4][0] = 0.39391;
//K+K- channel
g[0][1] = -0.49998;
g[1][1] = 0.52402;
g[2][1] = 0.40254;
g[3][1] = 0.42769;
g[4][1] = -0.30860;
//4pi channel
g[0][2] = 0;
g[1][2] = 0;
g[2][2] = 1.0;
g[3][2] = 1.15088;
g[4][2] = 0.33999;
//eta eta channel
g[0][3] = -0.21554;
g[1][3] = 0.38093;
g[2][3] = 0.21811;
g[3][3] = 0.22925;
g[4][3] = 0.06919;
//eta eta' channel
g[0][4] = -0.18294;
g[1][4] = 0.23788;
g[2][4] = 0.05454;
g[3][4] = 0.06444;
g[4][4] = 0.32620;
// Pole masses
ma[0] = 0.7369;
ma[1] = 1.24347;
ma[2] = 1.62681;
ma[3] = 1.21900;
ma[4] = 1.74932;
} else if ( solution == 2 ) { // solnIIa.txt
// coupling constants
//pi+pi- channel
g[0][0] = 0.26014;
g[1][0] = 0.95289;
g[2][0] = 0.46244;
g[3][0] = 0.41848;
g[4][0] = 0.01804;
//K+K- channel
g[0][1] = -0.57849;
g[1][1] = 0.55887;
g[2][1] = 0.31712;
g[3][1] = 0.49910;
g[4][1] = -0.28430;
//4pi channel
g[0][2] = 0;
g[1][2] = 0;
g[2][2] = 0.70340;
g[3][2] = 0.96819;
g[4][2] = -0.90100;
//eta eta channel
g[0][3] = -0.32936;
g[1][3] = 0.39910;
g[2][3] = 0.22963;
g[3][3] = 0.24415;
g[4][3] = -0.07252;
//eta eta' channel
g[0][4] = -0.30906;
g[1][4] = 0.31143;
g[2][4] = 0.19802;
g[3][4] = -0.00522;
g[4][4] = 0.17097;
// Pole masses
ma[0] = 0.67460;
ma[1] = 1.21094;
ma[2] = 1.57896;
ma[3] = 1.21900;
ma[4] = 1.86602;
}
//Now define the K-matrix pole
double rho1sq, rho2sq, rho4sq, rho5sq;
EvtComplex rho[5];
double f[5][5];
//Initalize the mass of the resonance
const double mpi = 0.13957;
const double mK = 0.493677; //using charged K value
const double meta = 0.54775; //using PDG value
const double metap = 0.95778; //using PDG value
//Initialize the matrix to value zero
EvtComplex K[5][5];
for ( int i = 0; i < 5; i++ ) {
for ( int j = 0; j < 5; j++ ) {
K[i][j] = EvtComplex( 0, 0 );
f[i][j] = 0;
}
}
//Input the _f[i][j] scattering data
double s_scatt = 0.0;
if ( solution == 3 )
s_scatt = -3.92637;
else if ( solution == 1 )
s_scatt = -5.0;
else if ( solution == 2 )
s_scatt = -5.0;
const double sa = 1.0;
const double sa_0 = -0.15;
if ( solution == 3 ) {
f[0][0] = 0.23399; // f^scatt
f[0][1] = 0.15044;
f[0][2] = -0.20545;
f[0][3] = 0.32825;
f[0][4] = 0.35412;
} else if ( solution == 1 ) {
f[0][0] = 0.04214; // f^scatt
f[0][1] = 0.19865;
f[0][2] = -0.63764;
f[0][3] = 0.44063;
f[0][4] = 0.36717;
} else if ( solution == 2 ) {
f[0][0] = 0.26447; // f^scatt
f[0][1] = 0.10400;
f[0][2] = -0.35445;
f[0][3] = 0.31596;
f[0][4] = 0.42483;
}
f[1][0] = f[0][1];
f[2][0] = f[0][2];
f[3][0] = f[0][3];
f[4][0] = f[0][4];
//Now construct the phase-space factor
//For eta-eta' there is no difference term
rho1sq = 1. - pow( mpi + mpi, 2 ) / s; //pi+ pi- phase factor
if ( rho1sq >= 0 )
rho[0] = EvtComplex( sqrt( rho1sq ), 0 );
else
rho[0] = EvtComplex( 0, sqrt( -rho1sq ) );
rho2sq = 1. - pow( mK + mK, 2 ) / s;
if ( rho2sq >= 0 )
rho[1] = EvtComplex( sqrt( rho2sq ), 0 );
else
rho[1] = EvtComplex( 0, sqrt( -rho2sq ) );
//using the A&S 4pi phase space Factor:
//Shit, not continue
if ( s <= 1 ) {
const double real = 1.2274 + .00370909 / ( s * s ) - .111203 / s -
6.39017 * s + 16.8358 * s * s -
21.8845 * s * s * s + 11.3153 * s * s * s * s;
const double cont32 = sqrt( 1.0 - ( 16.0 * mpi * mpi ) );
rho[2] = EvtComplex( cont32 * real, 0 );
} else
rho[2] = EvtComplex( sqrt( 1. - 16. * mpi * mpi / s ), 0 );
rho4sq = 1. - pow( meta + meta, 2 ) / s;
if ( rho4sq >= 0 )
rho[3] = EvtComplex( sqrt( rho4sq ), 0 );
else
rho[3] = EvtComplex( 0, sqrt( -rho4sq ) );
rho5sq = 1. - pow( meta + metap, 2 ) / s;
if ( rho5sq >= 0 )
rho[4] = EvtComplex( sqrt( rho5sq ), 0 );
else
rho[4] = EvtComplex( 0, sqrt( -rho5sq ) );
double smallTerm = 1; // Factor to prevent divergences.
// Check if some pole may arise problems.
for ( int pole = 0; pole < 5; pole++ )
if ( fabs( pow( ma[pole], 2 ) - s ) < PRECISION )
smallTerm = pow( ma[pole], 2 ) - s;
//now sum all the pole
//equation (3) in the E791 K-matrix paper
for ( int i = 0; i < 5; i++ ) {
for ( int j = 0; j < 5; j++ ) {
for ( int pole_index = 0; pole_index < 5; pole_index++ ) {
const double A = g[pole_index][i] * g[pole_index][j];
const double B = ma[pole_index] * ma[pole_index] - s;
if ( fabs( B ) < PRECISION )
K[i][j] += EvtComplex( A, 0 );
else
K[i][j] += EvtComplex( A / B, 0 ) * smallTerm;
}
}
}
//now add the SVT part
for ( int i = 0; i < 5; i++ ) {
for ( int j = 0; j < 5; j++ ) {
const double C = f[i][j] * ( 1.0 - s_scatt );
const double D = ( s - s_scatt );
K[i][j] += EvtComplex( C / D, 0 ) * smallTerm;
}
}
//Fix the bug in the FOCUS paper
//Include the Alder zero term:
for ( int i = 0; i < 5; i++ ) {
for ( int j = 0; j < 5; j++ ) {
const double E = ( s - ( sa * mpi * mpi * 0.5 ) ) * ( 1.0 - sa_0 );
const double F = ( s - sa_0 );
K[i][j] *= EvtComplex( E / F, 0 );
}
}
//This is not correct!
//(1-ipK) != (1-iKp)
static thread_local EvtMatrix<EvtComplex> mat;
mat.setRange(
5 ); // Try to do in only the first time. DEFINE ALLOCATION IN CONSTRUCTOR.
for ( int row = 0; row < 5; row++ )
for ( int col = 0; col < 5; col++ )
mat( row, col ) = ( row == col ) * smallTerm -
EvtComplex( 0., 1. ) * K[row][col] * rho[col];
EvtMatrix<EvtComplex>* matInverse =
mat.inverse(); //The 1st row of the inverse matrix. This matrix is {(I-iKp)^-1}_0j
vector<EvtComplex> U1j;
for ( int j = 0; j < 5; j++ )
U1j.push_back( ( *matInverse )[0][j] );
delete matInverse;
//this calculates final F0 factor
EvtComplex value( 0, 0 );
if ( index <= 5 ) {
//this calculates the beta_idx Factors
for ( int j = 0; j < 5; j++ ) { // sum for 5 channel
const EvtComplex top = U1j[j] * g[index - 1][j];
const double bottom = ma[index - 1] * ma[index - 1] - s;
if ( fabs( bottom ) < PRECISION )
value += top;
else
value += top / bottom * smallTerm;
}
} else {
//this calculates fprod Factors
value += U1j[0];
value += U1j[1] * m_fr12prod;
value += U1j[2] * m_fr13prod;
value += U1j[3] * m_fr14prod;
value += U1j[4] * m_fr15prod;
value *= ( 1 - m_s0prod ) / ( s - m_s0prod ) * smallTerm;
}
return value;
}
//replace Breit-Wigner with LASS
EvtComplex EvtDalitzReso::lass( const EvtTwoBodyKine& kd,
const EvtTwoBodyVertex& vd ) const
{
const double m = kd.m();
const double q = kd.p();
const double GammaM = m_g0 * vd.widthFactor( kd ); // running width;
//calculate the background phase motion
const double cot_deltaB = 1.0 / ( m_a * q ) + 0.5 * m_r * q;
const double deltaB = atan( 1.0 / cot_deltaB );
const double totalB = deltaB + m_phiB;
//calculate the resonant phase motion
const double deltaR = atan( ( m_m0 * GammaM / ( m_m0 * m_m0 - m * m ) ) );
const double totalR = deltaR + m_phiR;
//sum them up
EvtComplex bkgB, resT;
bkgB = EvtComplex( m_Blass * sin( totalB ), 0 ) *
EvtComplex( cos( totalB ), sin( totalB ) );
resT = EvtComplex( m_R * sin( deltaR ), 0 ) *
EvtComplex( cos( totalR ), sin( totalR ) ) *
EvtComplex( cos( 2 * totalB ), sin( 2 * totalB ) );
EvtComplex T;
if ( m_cutoff > 0 && m > m_cutoff )
T = resT;
else
T = bkgB + resT;
if ( m_scaleByMOverQ )
T *= ( m / q );
return T;
}
EvtComplex EvtDalitzReso::flatte( const double s ) const
{
EvtComplex w;
for ( const auto& param : m_flatteParams ) {
const double m1 = param.m1();
const double m2 = param.m2();
const double g = param.g();
w += ( g * g *
sqrtCplx( ( 1 - ( ( m1 - m2 ) * ( m1 - m2 ) ) / ( s ) ) *
( 1 - ( ( m1 + m2 ) * ( m1 + m2 ) ) / ( s ) ) ) );
}
const EvtComplex denom = m_m0 * m_m0 - s - EvtComplex( 0, 1 ) * w;
return EvtComplex( 1.0, 0.0 ) / denom;
}
diff --git a/src/EvtGenModels/EvtBCLFF.cpp b/src/EvtGenModels/EvtBCLFF.cpp
index 1be1d08..a2a77cd 100644
--- a/src/EvtGenModels/EvtBCLFF.cpp
+++ b/src/EvtGenModels/EvtBCLFF.cpp
@@ -1,200 +1,204 @@
/***********************************************************************
* Copyright 1998-2021 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/EvtBCLFF.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtReport.hh"
#include <cmath>
#include <cstdlib>
#include <string>
EvtBCLFF::EvtBCLFF( int numarg, double* arglist ) :
m_numBCLFFCoefficients( numarg )
{
if ( numarg > 19 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Too large number of coefficients!\n";
::abort();
}
for ( int i = 0; i < m_numBCLFFCoefficients; ++i ) {
m_BCLFFCoefficients[i] = arglist[i];
}
}
void EvtBCLFF::getscalarff( EvtId parent, EvtId daughter, double t, double,
double* fpf, double* f0f )
{
if ( m_numBCLFFCoefficients != 8 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Wrong number of arguments for EvtBCLFF::getscalarff!\n";
::abort();
}
const auto mB = EvtPDL::getMeanMass( parent );
const auto mM = EvtPDL::getMeanMass( daughter );
const auto tplus = ( mB + mM ) * ( mB + mM );
const auto tzero = ( mB + mM ) * ( std::sqrt( mB ) - std::sqrt( mM ) ) *
( std::sqrt( mB ) - std::sqrt( mM ) );
const auto mR2 = m_resonance1Minus * m_resonance1Minus;
const auto pole = 1.0 / ( 1.0 - t / mR2 );
const std::array<double, 4> bplus{ m_BCLFFCoefficients[0],
m_BCLFFCoefficients[1],
m_BCLFFCoefficients[2],
m_BCLFFCoefficients[3] };
const std::array<double, 4> bzero{ m_BCLFFCoefficients[4],
m_BCLFFCoefficients[5],
m_BCLFFCoefficients[6],
m_BCLFFCoefficients[7] };
const auto N_fpf = bplus.size();
const auto N_f0f = bzero.size();
- auto z = [tplus, tzero]( decltype( t ) q2 ) {
+ auto z = [tplus, tzero]( decltype( t ) q2 )
+ {
const auto term1 = std::sqrt( tplus - q2 );
const auto term2 = std::sqrt( tplus - tzero );
return ( term1 - term2 ) / ( term1 + term2 );
};
double sum_fpf = 0;
for ( unsigned int n = 0; n < N_fpf; ++n ) {
sum_fpf += bplus[n] * ( std::pow( z( t ), n ) -
std::pow( -1, n - N_fpf ) * n / N_fpf *
std::pow( z( t ), N_fpf ) );
}
*fpf = pole * sum_fpf;
double sum_f0f = 0;
for ( unsigned int n = 0; n < N_f0f; ++n ) {
sum_f0f += bzero[n] * std::pow( z( t ), n );
}
*f0f = sum_f0f;
}
void EvtBCLFF::getvectorff( EvtId parent, EvtId daughter, double t, double,
double* a1f, double* a2f, double* vf, double* a0f )
{
if ( m_numBCLFFCoefficients != 11 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Wrong number of arguments for EvtBCLFF::getvectorff!\n";
::abort();
}
const auto mB = EvtPDL::getMeanMass( parent );
const auto mB2 = mB * mB;
const auto mM = EvtPDL::getMeanMass( daughter );
const auto mM2 = mM * mM;
const auto tplus = ( mB + mM ) * ( mB + mM );
const auto tminus = ( mB - mM ) * ( mB - mM );
const auto tzero = tplus * ( 1.0 - std::sqrt( 1.0 - tminus / tplus ) );
const auto mR2A0 = m_resonance0Minus * m_resonance0Minus;
const auto mR2A1 = m_resonance1Plus * m_resonance1Plus;
const auto mR2A12 = m_resonance1Plus * m_resonance1Plus;
const auto mR2V = m_resonance1Minus * m_resonance1Minus;
const auto poleA0 = 1.0 / ( 1.0 - t / mR2A0 );
const auto poleA1 = 1.0 / ( 1.0 - t / mR2A1 );
const auto poleA12 = 1.0 / ( 1.0 - t / mR2A12 );
const auto poleV = 1.0 / ( 1.0 - t / mR2V );
const std::array<double, 3> A0{
8 * mB * mM / ( mB2 - mM2 ) * m_BCLFFCoefficients[5],
m_BCLFFCoefficients[0], m_BCLFFCoefficients[1] };
const std::array<double, 3> A1{ m_BCLFFCoefficients[2],
m_BCLFFCoefficients[3],
m_BCLFFCoefficients[4] };
const std::array<double, 3> A12{ m_BCLFFCoefficients[5],
m_BCLFFCoefficients[6],
m_BCLFFCoefficients[7] };
const std::array<double, 3> V{ m_BCLFFCoefficients[8], m_BCLFFCoefficients[9],
m_BCLFFCoefficients[10] };
- auto z = [tplus, tzero]( decltype( t ) q2 ) {
+ auto z = [tplus, tzero]( decltype( t ) q2 )
+ {
const auto term1 = std::sqrt( tplus - q2 );
const auto term2 = std::sqrt( tplus - tzero );
return ( term1 - term2 ) / ( term1 + term2 );
};
- auto sum = [&z]( decltype( t ) q2, std::array<double, 3> par ) {
+ auto sum = [&z]( decltype( t ) q2, std::array<double, 3> par )
+ {
double tot = 0.0;
for ( unsigned int n = 0; n < par.size(); ++n ) {
tot += par[n] * std::pow( z( q2 ) - z( 0.0 ), n );
}
return tot;
};
- auto kaellen = [mB, mM]( decltype( t ) q2 ) {
+ auto kaellen = [mB, mM]( decltype( t ) q2 )
+ {
return ( ( mB + mM ) * ( mB + mM ) - q2 ) *
( ( mB - mM ) * ( mB - mM ) - q2 );
};
const auto ffA0 = poleA0 * sum( t, A0 );
const auto ffA1 = poleA1 * sum( t, A1 );
const auto ffA12 = poleA12 * sum( t, A12 );
const auto ffV = poleV * sum( t, V );
const auto ffA2 = ( ( mB + mM ) * ( mB + mM ) * ( mB2 - mM2 - t ) * ffA1 -
( 16 * mB * mM2 * ( mB + mM ) ) * ffA12 ) /
kaellen( t );
*a0f = ffA0;
*a1f = ffA1;
*a2f = ffA2;
*vf = ffV;
}
void EvtBCLFF::gettensorff( EvtId, EvtId, double, double, double*, double*,
double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :gettensorff in EvtBCLFF.\n";
::abort();
}
void EvtBCLFF::getbaryonff( EvtId, EvtId, double, double, double*, double*,
double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getbaryonff in EvtBCLFF.\n";
::abort();
}
void EvtBCLFF::getdiracff( EvtId, EvtId, double, double, double*, double*,
double*, double*, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getdiracff in EvtBCLFF.\n";
::abort();
}
void EvtBCLFF::getraritaff( EvtId, EvtId, double, double, double*, double*,
double*, double*, double*, double*, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getraritaff in EvtBCLFF.\n";
::abort();
}
diff --git a/src/EvtGenModels/EvtBCSFF.cpp b/src/EvtGenModels/EvtBCSFF.cpp
index 3dfafda..af72527 100644
--- a/src/EvtGenModels/EvtBCSFF.cpp
+++ b/src/EvtGenModels/EvtBCSFF.cpp
@@ -1,145 +1,145 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/EvtBCSFF.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtReport.hh"
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string>
using namespace std;
EvtBCSFF::EvtBCSFF( int idS, int fit )
{
m_idScalar = idS;
m_whichfit = fit;
m_MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
m_MD0 = EvtPDL::getMeanMass( EvtPDL::getId( "D0" ) );
return;
}
void EvtBCSFF::getscalarff( EvtId /*p*/, EvtId /*d*/, double t, double /*mass*/,
double* fpf, double* f0f )
{
double q2 = t;
if ( m_whichfit == 0 ) {
*fpf = 1;
*f0f = 0;
return;
}
if ( m_idScalar == EvtPDL::getId( "chi_c0" ).getId() ) { // Bc -> chi_c0
if ( m_whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
double ratio = q2 / ( m_MBc * m_MBc );
double fpf_0 = 0.47;
double fpf_c1 = 2.03;
double fpf_c2 = 0.43;
double f0f_0 = 0.47;
double f0f_c1 = -0.45;
double f0f_c2 = -1.31;
*fpf = fpf_0 * exp( fpf_c1 * ratio + fpf_c2 * ratio * ratio );
*f0f = f0f_0 * exp( f0f_c1 * ratio + f0f_c2 * ratio * ratio );
return;
} else {
EvtGenReport( EVTGEN_ERROR, "EvtBCSFF" )
<< "Must choose 0 (fpf = 1) or 3 (Wang).\n";
::abort();
}
} else if ( m_idScalar == EvtPDL::getId( "D0" ).getId() ||
m_idScalar == EvtPDL::getId( "anti-D0" ).getId() ) { // Bc -> D0
if ( m_whichfit == 1 ) { // FF from Kiselev:2002vz, tables III, IV
double q2invmass = q2 / ( m_MBc * m_MBc - m_MD0 * m_MD0 );
double den = 1 - q2 / ( 5.0 * 5.0 );
if ( fabs( den ) < 1e-10 ) {
*fpf = 0;
*f0f = 0;
} else {
double fPlus = 0.32 / den;
double fMinus = -0.34 / den;
*fpf = fPlus;
*f0f = q2invmass * fMinus + fPlus;
}
} else if ( m_whichfit == 2 ) { // FF from Ebert:2003cn, Fig 9
double ratio = q2 / m_MBc / m_MBc;
- double const fPlus_0 = 0.143, fPlus_a = 0.7, fPlus_b = 2.13;
- double const f0_0 = 0.136, f0_a = 1.63, f0_b = -0.139;
+ const double fPlus_0 = 0.143, fPlus_a = 0.7, fPlus_b = 2.13;
+ const double f0_0 = 0.136, f0_a = 1.63, f0_b = -0.139;
*fpf = fPlus_0 / ( 1 - fPlus_a * ratio - fPlus_b * ratio * ratio );
*f0f = f0_0 / ( 1 - f0_a * ratio - f0_b * ratio * ratio );
return;
} else {
EvtGenReport( EVTGEN_ERROR, "EvtBCSFF" )
<< "Should choose 1 (Kiselev:2002vz) or 2 (Ebert:2003cn).\n";
}
} else {
EvtGenReport( EVTGEN_ERROR, "EvtBCSFF" )
<< "Only chi_c0 and D0/anti-D0 implemented.\n";
::abort();
}
}
void EvtBCSFF::getvectorff( EvtId, EvtId, double, double, double*, double*,
double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getvectorff in EvtBCSFF.\n";
::abort();
}
void EvtBCSFF::gettensorff( EvtId /*p*/, EvtId /*d*/, double /*t*/,
double /*mass*/, double*, double*, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :gettensorff in EvtBCSFF.\n";
::abort();
}
void EvtBCSFF::getbaryonff( EvtId, EvtId, double, double, double*, double*,
double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getbaryonff in EvtBCSFF.\n";
::abort();
}
void EvtBCSFF::getdiracff( EvtId, EvtId, double, double, double*, double*,
double*, double*, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getdiracff in EvtBCSFF.\n";
::abort();
}
void EvtBCSFF::getraritaff( EvtId, EvtId, double, double, double*, double*,
double*, double*, double*, double*, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getraritaff in EvtBCSFF.\n";
::abort();
}
diff --git a/src/EvtGenModels/EvtBCVFF.cpp b/src/EvtGenModels/EvtBCVFF.cpp
index 516da34..a62894b 100644
--- a/src/EvtGenModels/EvtBCVFF.cpp
+++ b/src/EvtGenModels/EvtBCVFF.cpp
@@ -1,236 +1,236 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/EvtBCVFF.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtReport.hh"
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <string>
using namespace std;
EvtBCVFF::EvtBCVFF( int idV, int fit )
{
m_idVector = idV;
m_whichfit = fit;
m_MBc = EvtPDL::getMeanMass( EvtPDL::getId( "B_c+" ) );
m_MD0 = EvtPDL::getMeanMass( EvtPDL::getId( "D*0" ) );
m_Mpsi = EvtPDL::getMeanMass( EvtPDL::getId( "J/psi" ) );
m_Mpsi2S = EvtPDL::getMeanMass( EvtPDL::getId( "psi(2S)" ) );
m_kappa = m_Mpsi / m_Mpsi2S;
m_Mchi = EvtPDL::getMeanMass( EvtPDL::getId( "chi_c1" ) );
return;
}
void EvtBCVFF::getvectorff( EvtId, EvtId, double t, double, double* a1f,
double* a2f, double* vf, double* a0f )
{
double q2 = t;
if ( m_whichfit == 0 ) {
*vf = 0;
*a0f = 0;
*a1f = 1;
*a2f = 0;
return;
}
if ( m_idVector == EvtPDL::getId( "J/psi" ).getId() ) { // Bc -> J/psi
if ( m_whichfit ==
1 ) { // SR form factor set from [Kiselev, hep-ph/0211021]
double Mpole2 = 4.5 * 4.5, den = 1. / ( 1. - q2 / Mpole2 );
double FV = 0.11 * den, FAp = -0.074 * den, FA0 = 5.9 * den,
FAm = 0.12 * den;
*vf = ( m_MBc + m_Mpsi ) * FV;
*a2f = -( m_MBc + m_Mpsi ) * FAp;
*a1f = FA0 / ( m_MBc + m_Mpsi );
*a0f = ( q2 * FAm + ( m_MBc + m_Mpsi ) * ( *a1f ) -
( m_MBc - m_Mpsi ) * ( *a2f ) ) /
( 2 * m_Mpsi );
return;
} else if ( m_whichfit ==
2 ) { // form factor set from [Ebert, hep-ph/0306306]
*vf = ( 0.49077824756158533 - 0.0012925655191347828 * q2 ) /
( 1 - 0.06292520325875656 * q2 );
*a0f = ( 0.4160345034630221 - 0.0024720095310225023 * q2 ) /
( 1 - 0.061603451915567785 * q2 );
*a1f = ( 0.4970212860605933 - 0.0067519730024654745 * q2 ) /
( 1 - 0.050487026667172176 * q2 );
*a2f = ( 0.7315284919705497 + 0.0014263826220727142 * q2 -
0.0006946090066269195 * q2 * q2 ) /
( 1 - 0.04885587273651653 * q2 );
return;
} else {
EvtGenReport( EVTGEN_ERROR, "EvtBCVFF" )
<< "Must choose 0 (a1f = 1), 1 (Kiselev), or 2 (Ebert).\n";
::abort();
}
} else if ( m_idVector ==
EvtPDL::getId( "psi(2S)" ).getId() ) { // Bc -> psi((2S)
if ( m_whichfit == 1 ) {
double Mpole2 = 4.5 * 4.5, den = 1. / ( 1. - q2 / Mpole2 );
double FV = 0.11 * den * m_kappa / 3.1,
FAp = -0.074 * den * m_kappa / 4.9,
FA0 = 5.9 * den * m_kappa / 3.5,
FAm = 0.12 * den * m_kappa / 2.3;
*vf = ( m_MBc + m_Mpsi2S ) * FV;
*a2f = -( m_MBc + m_Mpsi2S ) * FAp;
*a1f = FA0 / ( m_MBc + m_Mpsi2S );
*a0f = ( q2 * FAm + ( m_MBc + m_Mpsi2S ) * ( *a1f ) -
( m_MBc - m_Mpsi2S ) * ( *a2f ) ) /
( 2 * m_Mpsi2S );
return;
} else if ( m_whichfit == 2 ) {
*vf = ( 0.24177223968739653 - 0.053589051007278135 * q2 ) /
( 1 - 0.0977848994260899 * q2 );
*a0f = ( 0.23996026570086615 - 0.03530198514007337 * q2 ) /
( 1 - 0.09371162519983989 * q2 );
*a1f = ( 0.17418379258849329 - 0.004129699022085851 * q2 * q2 ) /
( 1 + 0.06607665248402918 * q2 );
*a2f = ( 0.1352376939112041 - 0.040361722565209444 * q2 +
0.003343515369431853 * q2 * q2 ) /
( 1 - 0.1463698128333418 * q2 );
return;
} else {
EvtGenReport( EVTGEN_ERROR, "EvtBCVFF" )
<< "Must choose 0 (a1f = 1), 1 (Kiselev), or 2 (Ebert).\n";
::abort();
}
} else if ( m_idVector == EvtPDL::getId( "chi_c1" ).getId() ) { // Bc -> chi_c1
if ( m_whichfit == 3 ) { // FF from Wang et al 10.1103/PhysRevD.79.114018
double SoverD = ( m_MBc + m_Mchi ) / ( m_MBc - m_Mchi );
double DoverS = ( m_MBc - m_Mchi ) / ( m_MBc + m_Mchi );
double ratio = q2 / ( m_MBc * m_MBc );
double vf_0 = SoverD * 0.36;
double vf_c1 = 1.98;
double vf_c2 = 0.43;
double a2f_0 = SoverD * 0.15;
double a2f_c1 = 1.22;
double a2f_c2 = -0.08;
double a1f_0 = DoverS * 0.85;
double a1f_c1 = -0.51;
double a1f_c2 = -1.38;
double a0f_0 = 0.13;
double a0f_c1 = 2.99;
double a0f_c2 = 0.023;
*vf = vf_0 * exp( vf_c1 * ratio + vf_c2 * ratio * ratio );
*a2f = a2f_0 * exp( a2f_c1 * ratio + a2f_c2 * ratio * ratio );
*a1f = a1f_0 * exp( a1f_c1 * ratio + a1f_c2 * ratio * ratio );
*a0f = a0f_0 * exp( a0f_c1 * ratio + a0f_c2 * ratio * ratio );
return;
} else {
EvtGenReport( EVTGEN_ERROR, "EvtBCVFF" )
<< "Must choose 0 (a1f = 1) or 3 (Wang).\n";
::abort();
}
} else if ( m_idVector == EvtPDL::getId( "D*0" ).getId() ||
m_idVector == EvtPDL::getId( "anti-D*0" ).getId() ) {
if ( m_whichfit == 1 ) {
// SR form factor set from Kiselev, hep-ph/0211021
double Mpole2 = 6.2 * 6.2, den = ( 1. - q2 / Mpole2 );
if ( fabs( den ) < 1e-10 ) {
*vf = 0;
*a2f = 0;
*a1f = 0;
*a0f = 0;
} else {
double FV = 0.20 / den, FAp = -0.062 / den, FA0 = 3.6,
FAm = 0.11 / den;
*vf = ( m_MBc + m_MD0 ) * FV;
*a2f = -( m_MBc + m_MD0 ) * FAp;
*a1f = FA0 / ( m_MBc + m_MD0 );
*a0f = ( q2 * FAm + ( m_MBc + m_MD0 ) * ( *a1f ) -
( m_MBc - m_MD0 ) * ( *a2f ) ) /
( 2 * m_MD0 );
}
return;
} else if ( m_whichfit == 2 ) {
// form factors from Ebert, hep-ph/0306306
double ratio = q2 / m_MBc / m_MBc;
- double const fV_0 = 0.202, fV_a = 1.38, fV_b = 1.31;
- double const fA2_0 = 0.22, fA2_a = 2.44, fA2_b = -1.21;
- double const fA0_0 = 0.144, fA0_a = 1.18, fA0_b = 1.39;
- double const fA1_0 = 0.174, fA1_a = 1.69, fA1_b = -0.219;
+ const double fV_0 = 0.202, fV_a = 1.38, fV_b = 1.31;
+ const double fA2_0 = 0.22, fA2_a = 2.44, fA2_b = -1.21;
+ const double fA0_0 = 0.144, fA0_a = 1.18, fA0_b = 1.39;
+ const double fA1_0 = 0.174, fA1_a = 1.69, fA1_b = -0.219;
*vf = fV_0 / ( 1 - fV_a * ratio - fV_b * ratio * ratio );
*a2f = fA2_0 / ( 1 - fA2_a * ratio - fA2_b * ratio * ratio );
*a0f = fA0_0 / ( 1 - fA0_a * ratio - fA0_b * ratio * ratio );
*a1f = fA1_0 / ( 1 - fA1_a * ratio - fA1_b * ratio * ratio );
return;
} else {
EvtGenReport( EVTGEN_ERROR, "BCVFF" )
<< "FF should be 0 (a1f = 1), 1 (Kiselev 2002) or 2 (Ebert).\n";
::abort();
}
} else {
EvtGenReport( EVTGEN_ERROR, "ECVFF" )
<< "Only J/psi, psi(2S), chi_c1 and D*0/anti-D*0 implemented.\n";
::abort();
}
}
void EvtBCVFF::getscalarff( EvtId, EvtId, double, double, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getscalarff in EvtBCVFF.\n";
::abort();
}
void EvtBCVFF::gettensorff( EvtId, EvtId, double, double, double*, double*,
double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :gettensorff in EvtBCVFF.\n";
::abort();
}
void EvtBCVFF::getbaryonff( EvtId, EvtId, double, double, double*, double*,
double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getbaryonff in EvtBCVFF.\n";
::abort();
}
void EvtBCVFF::getdiracff( EvtId, EvtId, double, double, double*, double*,
double*, double*, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getdiracff in EvtBCVFF.\n";
::abort();
}
void EvtBCVFF::getraritaff( EvtId, EvtId, double, double, double*, double*,
double*, double*, double*, double*, double*, double* )
{
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Not implemented :getraritaff in EvtBCVFF.\n";
::abort();
}
diff --git a/src/EvtGenModels/EvtD0ToKspipi.cpp b/src/EvtGenModels/EvtD0ToKspipi.cpp
index fff52ef..afdac41 100644
--- a/src/EvtGenModels/EvtD0ToKspipi.cpp
+++ b/src/EvtGenModels/EvtD0ToKspipi.cpp
@@ -1,325 +1,324 @@
#include "EvtGenModels/EvtD0ToKspipi.hh"
#include "EvtGenBase/EvtDecayTable.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtReport.hh"
#include "EvtGenBase/EvtVector4R.hh"
#include <iostream>
std::string EvtD0ToKspipi::getName() const
{
return "D0TOKSPIPI";
}
EvtDecayBase* EvtD0ToKspipi::clone() const
{
return new EvtD0ToKspipi;
}
void EvtD0ToKspipi::init()
{
// Check that there are 0 arguments
checkNArg( 0 );
// Check parent and daughter types
checkNDaug( 3 );
checkSpinDaughter( 0, EvtSpinType::SCALAR );
checkSpinDaughter( 1, EvtSpinType::SCALAR );
checkSpinDaughter( 2, EvtSpinType::SCALAR );
checkSpinParent( EvtSpinType::SCALAR );
// Set the particle IDs and PDG masses
setPDGValues();
// Set the EvtId of the three D0 daughters
const int nDaug = 3;
std::vector<EvtId> dau;
for ( int index = 0; index < nDaug; index++ ) {
dau.push_back( getDaug( index ) );
}
// Look for K0bar h+ h-. The order will be K[0SL] h+ h-
for ( int index = 0; index < nDaug; index++ ) {
if ( ( dau[index] == m_K0B ) || ( dau[index] == m_KS ) ||
( dau[index] == m_KL ) ) {
m_d0 = index;
} else if ( dau[index] == m_PIP ) {
m_d1 = index;
} else if ( dau[index] == m_PIM ) {
m_d2 = index;
} else {
EvtGenReport( EVTGEN_ERROR, "EvtD0ToKspipi" )
<< "Daughter " << index << " has wrong ID" << std::endl;
}
}
// Setup the Dalitz plot resonances and their amplitude coefficients
initResonances();
}
void EvtD0ToKspipi::initProbMax()
{
setProbMax( 6000.0 );
}
void EvtD0ToKspipi::decay( EvtParticle* p )
{
// Phase space generation and 4-momenta
p->initializePhaseSpace( getNDaug(), getDaugs() );
const EvtVector4R p0 = p->getDaug( m_d0 )->getP4();
const EvtVector4R p1 = p->getDaug( m_d1 )->getP4();
const EvtVector4R p2 = p->getDaug( m_d2 )->getP4();
// Squared invariant masses
const double mSq01 = ( p0 + p1 ).mass2();
const double mSq02 = ( p0 + p2 ).mass2();
const double mSq12 = ( p1 + p2 ).mass2();
// For the decay amplitude
EvtComplex amp( 0.0, 0.0 );
// Direct and conjugated Dalitz points
const EvtDalitzPoint pointD0( m_mKs, m_mPi, m_mPi, mSq02, mSq12, mSq01 );
const EvtDalitzPoint pointD0b( m_mKs, m_mPi, m_mPi, mSq01, mSq12, mSq02 );
// Check if the D is from a B+- -> D0 K+- decay with the appropriate model
EvtParticle* parent = p->getParent();
EvtDecayBase* decayFun = ( parent != nullptr )
- ? EvtDecayTable::getInstance().getDecayFunc(
- parent )
- : nullptr;
+ ? EvtDecayTable::getInstance().getDecayFunc( parent )
+ : nullptr;
if ( parent != nullptr && decayFun != nullptr &&
decayFun->getName() == "BTODDALITZCPK" ) {
const EvtId parId = parent->getId();
if ( ( parId == m_BP ) || ( parId == m_BM ) || ( parId == m_B0 ) ||
( parId == m_B0B ) ) {
// D0 parent particle is a B meson from the BTODDALITZCPK decay model.
// D0 decay amplitude combines the interference of D0 and D0bar.
// Read the D decay parameters from the B decay model.
// Gamma angle in radians
const double gamma = decayFun->getArg( 0 );
// Strong phase in radians
const double delta = decayFun->getArg( 1 );
// Ratio between B -> D0 K and B -> D0bar K
const double rB = decayFun->getArg( 2 );
// Direct and conjugated amplitudes
const EvtComplex ampD0 = calcTotAmp( pointD0 );
const EvtComplex ampD0b = calcTotAmp( pointD0b );
if ( parId == m_BP || parId == m_B0 ) {
// B+ or B0
const EvtComplex iPhase( 0.0, delta + gamma );
const EvtComplex expo( exp( iPhase ) );
amp = ampD0b + rB * expo * ampD0;
} else {
// B- or B0bar
const EvtComplex iPhase( 0.0, delta - gamma );
const EvtComplex expo( exp( iPhase ) );
amp = ampD0 + rB * expo * ampD0b;
}
}
} else if ( !parent ) {
// D0 has no parent particle. Use direct or conjugated amplitude
if ( p->getId() == m_D0 ) {
amp = calcTotAmp( pointD0 );
} else {
amp = calcTotAmp( pointD0b );
}
}
// Set the decay vertex amplitude
vertex( amp );
}
EvtComplex EvtD0ToKspipi::calcTotAmp( const EvtDalitzPoint& point ) const
{
// Initialise the total amplitude
EvtComplex totAmp( 0.0, 0.0 );
// Check that the Dalitz plot point is OK
if ( point.isValid() == false ) {
return totAmp;
}
// Add the resonance amplitudes by iterating over the (resonance, coeff) pairs.
// This includes the BW and LASS lineshapes, as well as the K-matrix contributions
for ( const auto& [res, amp] : m_resonances ) {
// Evaluate the resonance amplitude and multiply by the coeff
totAmp += res.evaluate( point ) * amp;
}
// Return the total amplitude
return totAmp;
}
void EvtD0ToKspipi::initResonances()
{
// Dalitz plot model from combined BaBar and BELLE paper hep-ex/1804.06153
// Define the Dalitz plot axes
const EvtCyclic3::Pair AB = EvtCyclic3::AB;
const EvtCyclic3::Pair AC = EvtCyclic3::AC;
const EvtCyclic3::Pair BC = EvtCyclic3::BC;
// Define the particle spin and lineshape types
const EvtSpinType::spintype vector = EvtSpinType::VECTOR;
const EvtSpinType::spintype tensor = EvtSpinType::TENSOR;
const EvtDalitzReso::NumType RBW = EvtDalitzReso::RBW_CLEO_ZEMACH;
const EvtDalitzReso::NumType KMAT = EvtDalitzReso::K_MATRIX;
// Define the Dalitz plot
const EvtDalitzPlot DP( m_mKs, m_mPi, m_mPi, m_mD0, 0, 0 );
// Clear the internal vector of (resonance, coeff) pairs
m_resonances.clear();
// rho BW
const EvtDalitzReso rhoBW( DP, AB, BC, vector, 0.77155, 0.13469, RBW, 5.0,
1.5 );
const EvtComplex rhoCoeff( 1.0, 0.0 );
m_resonances.push_back( std::make_pair( rhoBW, rhoCoeff ) );
// Omega BW
const EvtDalitzReso omegaBW( DP, AB, BC, vector, 0.78265, 0.00849, RBW, 5.0,
1.5 );
const EvtComplex omegaCoeff( -0.019829903319132, 0.033339785741436 );
m_resonances.push_back( std::make_pair( omegaBW, omegaCoeff ) );
// K*(892)- BW
const EvtDalitzReso KstarBW( DP, BC, AB, vector, 0.893709298220334,
0.047193287094108, RBW, 5.0, 1.5 );
const EvtComplex KstarCoeff( -1.255025021860793, 1.176780750003210 );
m_resonances.push_back( std::make_pair( KstarBW, KstarCoeff ) );
// K*0(1430)- LASS
const double LASS_F = 0.955319683174069;
const double LASS_phi_F = 0.001737032480754;
const double LASS_R = 1.0;
const double LASS_phi_R = -1.914503836666840;
const double LASS_a = 0.112673863011817;
const double LASS_r = -33.799002116066454;
const EvtDalitzReso Kstar0_1430LASS = EvtDalitzReso(
DP, AB, 1.440549945739415, 0.192611512914605, LASS_a, LASS_r, LASS_F,
LASS_phi_F, LASS_R, LASS_phi_R, -1.0, false );
const EvtComplex Kstar0_1430Coeff( -0.386469884688245, 2.330315087713914 );
m_resonances.push_back( std::make_pair( Kstar0_1430LASS, Kstar0_1430Coeff ) );
// K*2(1430)- BW
const EvtDalitzReso Kstar2_1430BW( DP, BC, AB, tensor, 1.4256, 0.0985, RBW,
5.0, 1.5 );
const EvtComplex Kstar2_1430Coeff( 0.914470111251261, -0.885129049790117 );
m_resonances.push_back( std::make_pair( Kstar2_1430BW, Kstar2_1430Coeff ) );
// K*(1680)- BW
const EvtDalitzReso Kstar_1680BW( DP, BC, AB, vector, 1.717, 0.322, RBW,
5.0, 1.5 );
const EvtComplex Kstar_1680Coeff( -1.560837188791231, -2.916210561577914 );
m_resonances.push_back( std::make_pair( Kstar_1680BW, Kstar_1680Coeff ) );
// K*(1410)- BW
const EvtDalitzReso Kstar_1410BW( DP, BC, AB, vector, 1.414, 0.232, RBW,
5.0, 1.5 );
const EvtComplex Kstar_1410Coeff( -0.046795079734847, 0.283085379985959 );
m_resonances.push_back( std::make_pair( Kstar_1410BW, Kstar_1410Coeff ) );
// K*(892)+ DCS BW
const EvtDalitzReso Kstar_DCSBW( DP, BC, AC, vector, 0.893709298220334,
0.047193287094108, RBW, 5.0, 1.5 );
const EvtComplex Kstar_DCSCoeff( 0.121693743404499, -0.110206354657867 );
m_resonances.push_back( std::make_pair( Kstar_DCSBW, Kstar_DCSCoeff ) );
// K*0(1430)+ DCS LASS
const EvtDalitzReso Kstar0_1430_DCSLASS = EvtDalitzReso(
DP, AC, 1.440549945739415, 0.192611512914605, LASS_a, LASS_r, LASS_F,
LASS_phi_F, LASS_R, LASS_phi_R, -1.0, false );
const EvtComplex Kstar0_1430_DCSCoeff( -0.101484805664368, 0.032368302993344 );
m_resonances.push_back(
std::make_pair( Kstar0_1430_DCSLASS, Kstar0_1430_DCSCoeff ) );
// K*2(1430)+ DCS BW
const EvtDalitzReso Kstar2_1430_DCSBW( DP, AB, AC, tensor, 1.4256, 0.0985,
RBW, 5.0, 1.5 );
const EvtComplex Kstar2_1430_DCSCoeff( 0.000699701539252, -0.102571188336701 );
m_resonances.push_back(
std::make_pair( Kstar2_1430_DCSBW, Kstar2_1430_DCSCoeff ) );
// K*(1410)+ DCS BW
const EvtDalitzReso Kstar_1410_DCSBW( DP, BC, AC, vector, 1.414, 0.232, RBW,
5.0, 1.5 );
const EvtComplex Kstar_1410_DCSCoeff( -0.181330401419455, 0.103990039950039 );
m_resonances.push_back(
std::make_pair( Kstar_1410_DCSBW, Kstar_1410_DCSCoeff ) );
// f2(1270) BW
const EvtDalitzReso f2_1270BW( DP, AB, BC, tensor, 1.2751, 0.1842, RBW, 5.0,
1.5 );
const EvtComplex f2_1270Coeff( 1.151785277682948, -0.845612891825272 );
m_resonances.push_back( std::make_pair( f2_1270BW, f2_1270Coeff ) );
// rho(1450) BW
const EvtDalitzReso rho_1450BW( DP, AB, BC, vector, 1.465, 0.400, RBW, 5.0,
1.5 );
const EvtComplex rho_1450Coeff( -0.597963342540235, 2.787903868470057 );
m_resonances.push_back( std::make_pair( rho_1450BW, rho_1450Coeff ) );
// K-matrix pole 1
const double sProd0 = -0.07;
const EvtDalitzReso pole1( DP, BC, "Pole1", KMAT, 0, 0, 0, 0, sProd0 );
const EvtComplex p1Coeff( 3.122415682166643, 7.928823290976309 );
m_resonances.push_back( std::make_pair( pole1, p1Coeff ) );
// K-matrix pole 2
const EvtDalitzReso pole2( DP, BC, "Pole2", KMAT, 0, 0, 0, 0, sProd0 );
const EvtComplex p2Coeff( 11.139907856904129, 4.948420661321371 );
m_resonances.push_back( std::make_pair( pole2, p2Coeff ) );
// K-matrix pole 3
const EvtDalitzReso pole3( DP, BC, "Pole3", KMAT, 0, 0, 0, 0, sProd0 );
const EvtComplex p3Coeff( 29.146102368470210, -0.053588781806890 );
m_resonances.push_back( std::make_pair( pole3, p3Coeff ) );
// K-matrix pole 4
const EvtDalitzReso pole4( DP, BC, "Pole4", KMAT, 0, 0, 0, 0, sProd0 );
const EvtComplex p4Coeff( 6.631556203215280, -8.455370251307063 );
m_resonances.push_back( std::make_pair( pole4, p4Coeff ) );
// K-matrix pole 5 is not included since its amplitude coefficient is zero
// K-matrix slowly varying part
const EvtComplex fProd11( -4.724094278696236, -6.511009103363590 );
const EvtComplex fProd12( -23.289333360304212, -12.215597571354197 );
const EvtComplex fProd13( -1.860311896516422, -32.982507366353126 );
const EvtComplex fProd14( -13.638752211193912, -22.339804683783186 );
const EvtComplex fProd15( 0.0, 0.0 );
const EvtDalitzReso KMSVP( DP, BC, "f11prod", KMAT, fProd12 / fProd11,
fProd13 / fProd11, fProd14 / fProd11,
fProd15 / fProd11, sProd0 );
m_resonances.push_back( std::make_pair( KMSVP, fProd11 ) );
}
void EvtD0ToKspipi::setPDGValues()
{
// Set the EvtIds
m_BP = EvtPDL::getId( "B+" );
m_BM = EvtPDL::getId( "B-" );
m_B0 = EvtPDL::getId( "B0" );
m_B0B = EvtPDL::getId( "anti-B0" );
m_D0 = EvtPDL::getId( "D0" );
m_D0B = EvtPDL::getId( "anti-D0" );
m_KM = EvtPDL::getId( "K-" );
m_KP = EvtPDL::getId( "K+" );
m_K0 = EvtPDL::getId( "K0" );
m_K0B = EvtPDL::getId( "anti-K0" );
m_KL = EvtPDL::getId( "K_L0" );
m_KS = EvtPDL::getId( "K_S0" );
m_PIM = EvtPDL::getId( "pi-" );
m_PIP = EvtPDL::getId( "pi+" );
// Set the particle masses
m_mD0 = EvtPDL::getMeanMass( m_D0 );
m_mKs = EvtPDL::getMeanMass( m_KS );
m_mPi = EvtPDL::getMeanMass( m_PIP );
m_mK = EvtPDL::getMeanMass( m_KP );
}
diff --git a/src/EvtGenModels/EvtDDalitz.cpp b/src/EvtGenModels/EvtDDalitz.cpp
index 9f97a42..17de283 100644
--- a/src/EvtGenModels/EvtDDalitz.cpp
+++ b/src/EvtGenModels/EvtDDalitz.cpp
@@ -1,882 +1,882 @@
/***********************************************************************
* Copyright 1998-2023 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/EvtDDalitz.hh"
#include "EvtGenBase/EvtConst.hh"
#include "EvtGenBase/EvtDecayTable.hh"
#include "EvtGenBase/EvtFlatte.hh"
#include "EvtGenBase/EvtGenKine.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtReport.hh"
#include "EvtGenBase/EvtResonance.hh"
#include "EvtGenBase/EvtResonance2.hh"
#include <algorithm>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using std::endl;
std::string EvtDDalitz::getName() const
{
return "D_DALITZ";
}
EvtDecayBase* EvtDDalitz::clone() const
{
return new EvtDDalitz;
}
bool isNeutralKaon( const EvtId& theId )
{
// See if the particle id matches that for a neutral kaon
bool result( false );
static const EvtId K0 = EvtPDL::getId( "K0" );
static const EvtId KB = EvtPDL::getId( "anti-K0" );
static const EvtId KL = EvtPDL::getId( "K_L0" );
static const EvtId KS = EvtPDL::getId( "K_S0" );
// Compare EvtId integers, which are unique for each particle type,
// corresponding to the order particles appear in the "evt.pdl" table.
// Aliased particles will have the same ids (but different "alias" values)
if ( theId == KB || theId == K0 || theId == KL || theId == KS ) {
result = true;
}
return result;
}
bool compareIds( const std::pair<EvtId, int>& left,
const std::pair<EvtId, int>& right )
{
// Compare id numbers to achieve the ordering KB/K0/KS/KL, KM, PIM, PI0, PIP, KP, i.e.
// neutral kaon first, then normal PDG id ordering for the other particles.
// The current 12 decay modes do not use two or more neutral kaons. If in the future
// such modes are added, the ordering will be KM, KB, PIM, PI0, KL, PIP, KS, K0, KP
bool result( false );
if ( isNeutralKaon( left.first ) == true &&
isNeutralKaon( right.first ) == false ) {
// Left is a neutral kaon, right is not
result = true;
} else if ( isNeutralKaon( left.first ) == false &&
isNeutralKaon( right.first ) == true ) {
// Right is a neutral kaon, left is not
result = false;
} else {
// Just compare PDG integers to achieve ascending order
int leftPDGid = EvtPDL::getStdHep( left.first );
int rightPDGid = EvtPDL::getStdHep( right.first );
if ( leftPDGid < rightPDGid ) {
result = true;
}
}
return result;
}
void EvtDDalitz::init()
{
static const EvtId DM = EvtPDL::getId( "D-" );
static const EvtId DP = EvtPDL::getId( "D+" );
static const EvtId D0 = EvtPDL::getId( "D0" );
static const EvtId D0B = EvtPDL::getId( "anti-D0" );
static const EvtId DSP = EvtPDL::getId( "D_s+" );
static const EvtId DSM = EvtPDL::getId( "D_s-" );
static const EvtId KM = EvtPDL::getId( "K-" );
static const EvtId KP = EvtPDL::getId( "K+" );
static const EvtId PIM = EvtPDL::getId( "pi-" );
static const EvtId PIP = EvtPDL::getId( "pi+" );
static const EvtId PI0 = EvtPDL::getId( "pi0" );
static const double MPI = EvtPDL::getMeanMass( PI0 );
static const double MKP = EvtPDL::getMeanMass( KP );
// check that there are 0 arguments and 3 daughters
checkNArg( 0 );
checkNDaug( 3 );
checkSpinParent( EvtSpinType::SCALAR );
checkSpinDaughter( 0, EvtSpinType::SCALAR );
checkSpinDaughter( 1, EvtSpinType::SCALAR );
checkSpinDaughter( 2, EvtSpinType::SCALAR );
EvtId parnum = getParentId();
/*
* To decide which decay we have, we take the list of daughters (or charge
* conjugate of daughters for D-, D0B or Ds-), sort these in the order
* KB/K0/KS/KL, KM, PIM, PI0, PIP, KP, keeping track which daughter is which,
* and at the end have a single if statement picking up the decay and assigning
* the correct order for the daughters (same condition used for charm and anti-charm).
* If we have two or more neutral kaons in the daughter list, then the compareIds()
* ordering will simply follow ascending PDG ids: KM, KB, PIM, PI0, KL, PIP, KS, K0, KP
*/
std::vector<std::pair<EvtId, int>> daughters;
if ( parnum == D0 || parnum == DP || parnum == DSP ) {
for ( int i = 0; i < 3; ++i ) {
daughters.push_back( std::make_pair( getDaug( i ), i ) );
}
} else {
for ( int i = 0; i < 3; ++i ) {
daughters.push_back(
std::make_pair( EvtPDL::chargeConj( getDaug( i ) ), i ) );
}
}
// Sort daughters, they will end up in the order KB/K0/KS/KL, KM, PIM, PI0, PIP, KP
// for the current 12 decay modes
std::sort( daughters.begin(), daughters.end(), compareIds );
/*
std::cout << "DDALITZ sorting: ";
for (int i=0; i<3; ++i ) {
std::cout << EvtPDL::getStdHep(daughters[i].first) << " ";
}
std::cout << std::endl;
*/
m_flag = 0;
// D0 or anti-D0 modes. We only need to check the particle modes, since anti-particle
// modes have their ordered daughter ids charged-conjugated above
if ( parnum == D0 || parnum == D0B ) {
// Look for D0 to K- pi+ pi0
if ( daughters[0].first == KM && daughters[1].first == PI0 &&
daughters[2].first == PIP ) {
m_flag = 4;
m_d1 = daughters[0].second;
m_d2 = daughters[2].second;
m_d3 = daughters[1].second;
}
// Look for D0 to KB pi- pi+
if ( isNeutralKaon( daughters[0].first ) == true &&
daughters[1].first == PIM && daughters[2].first == PIP ) {
m_flag = 3;
m_d1 = daughters[0].second;
m_d2 = daughters[1].second;
m_d3 = daughters[2].second;
}
// Look for D0 to KB K+ K-
if ( isNeutralKaon( daughters[0].first ) == true &&
daughters[1].first == KM && daughters[2].first == KP ) {
m_flag = 5;
m_d1 = daughters[0].second;
m_d2 = daughters[2].second;
m_d3 = daughters[1].second;
}
// Look for D0 to pi- pi+ pi0
if ( daughters[0].first == PIM && daughters[1].first == PI0 &&
daughters[2].first == PIP ) {
m_flag = 12;
m_d1 = daughters[0].second;
m_d2 = daughters[2].second;
m_d3 = daughters[1].second;
}
}
// D+ (or D-) modes
if ( parnum == DP || parnum == DM ) {
// Look for D+ to KB pi+ pi0
if ( isNeutralKaon( daughters[0].first ) == true &&
daughters[1].first == PI0 && daughters[2].first == PIP ) {
m_flag = 2;
m_d1 = daughters[0].second;
m_d2 = daughters[2].second;
m_d3 = daughters[1].second;
}
// Look for D+ to K- pi+ pi+
if ( daughters[0].first == KM && daughters[1].first == PIP &&
daughters[2].first == PIP ) {
m_flag = 1;
m_d1 = daughters[0].second;
m_d2 = daughters[1].second;
m_d3 = daughters[2].second;
}
// Look for D+ to K- K+ pi+
if ( daughters[0].first == KM && daughters[1].first == PIP &&
daughters[2].first == KP ) {
m_flag = 7;
m_d1 = daughters[0].second;
m_d2 = daughters[2].second;
m_d3 = daughters[1].second;
}
// Look for D+ to pi- pi+ K+
if ( daughters[0].first == PIM && daughters[1].first == PIP &&
daughters[2].first == KP ) {
m_flag = 8;
m_d1 = daughters[0].second;
m_d2 = daughters[1].second;
m_d3 = daughters[2].second;
}
// Look for D+ to pi- pi+ pi+
if ( daughters[0].first == PIM && daughters[1].first == PIP &&
daughters[2].first == PIP ) {
m_flag = 10;
m_d1 = daughters[0].second;
m_d2 = daughters[1].second;
m_d3 = daughters[2].second;
}
}
// Ds+ (or Ds-) modes
if ( parnum == DSP || parnum == DSM ) {
// Look for Ds+ to K- K+ pi+
if ( daughters[0].first == KM && daughters[1].first == PIP &&
daughters[2].first == KP ) {
m_flag = 6;
m_d1 = daughters[0].second;
m_d2 = daughters[2].second;
m_d3 = daughters[1].second;
}
// Look for Ds+ to pi- pi+ K+
if ( daughters[0].first == PIM && daughters[1].first == PIP &&
daughters[2].first == KP ) {
m_flag = 9;
m_d1 = daughters[0].second;
m_d2 = daughters[1].second;
m_d3 = daughters[2].second;
}
// Look for Ds+ to pi- pi+ pi+
if ( daughters[0].first == PIM && daughters[1].first == PIP &&
daughters[2].first == PIP ) {
m_flag = 11;
m_d1 = daughters[0].second;
m_d2 = daughters[1].second;
m_d3 = daughters[2].second;
}
}
if ( m_flag == 6 ) {
m_kkpi_params.push_back( EvtFlatteParam( MPI, MPI, 0.406 ) );
m_kkpi_params.push_back( EvtFlatteParam( MKP, MKP, 0.800 ) );
}
if ( m_flag == 0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "EvtDDaltiz: Invalid mode." << endl;
assert( 0 );
}
/*
EvtGenReport(EVTGEN_INFO,"EvtGen") << "DDALITZ ordering for " << parnum.getName()
<< " with mode = " << m_flag << ": "
<< getDaug(m_d1).getName() << " "
<< getDaug(m_d2).getName() << " "
<< getDaug(m_d3).getName() << std::endl;
*/
}
void EvtDDalitz::initProbMax()
{
// probmax different for different modes!
if ( m_flag == 1 ) {
setProbMax( 2500.0 );
}
if ( m_flag == 2 ) {
setProbMax( 150.0 );
}
if ( m_flag == 3 ) {
setProbMax( 3000.0 );
}
if ( m_flag == 4 ) {
setProbMax( 600.0 );
}
if ( m_flag == 5 ) {
setProbMax( 2500000.0 );
}
if ( m_flag == 6 ) {
setProbMax( 45000.0 );
}
if ( m_flag == 7 ) {
setProbMax( 35000.0 );
}
if ( m_flag == 8 ) {
setProbMax( 2500.0 );
}
if ( m_flag == 9 ) {
setProbMax( 1700.0 );
}
if ( m_flag == 10 ) {
setProbMax( 1300.0 );
}
if ( m_flag == 11 ) {
setProbMax( 2200.0 );
}
if ( m_flag == 12 ) {
setProbMax( 1000.0 );
}
}
void EvtDDalitz::decay( EvtParticle* p )
{
static const EvtId BP = EvtPDL::getId( "B+" );
static const EvtId BM = EvtPDL::getId( "B-" );
static const EvtId B0 = EvtPDL::getId( "B0" );
static const EvtId B0B = EvtPDL::getId( "anti-B0" );
static const EvtId D0 = EvtPDL::getId( "D0" );
double oneby2 = 0.707106782;
bool isBToDK = false;
if ( p->getParent() ) {
EvtId parId = p->getParent()->getId();
if ( ( BP == parId ) || ( BM == parId ) || ( B0 == parId ) ||
( B0B == parId ) )
if ( EvtDecayTable::getInstance()
.getDecayFunc( p->getParent() )
->getName() == "BTODDALITZCPK" )
isBToDK = true;
}
//same structure for all of these decays
p->initializePhaseSpace( getNDaug(), getDaugs() );
EvtVector4R moms1 = p->getDaug( m_d1 )->getP4();
EvtVector4R moms2 = p->getDaug( m_d2 )->getP4();
EvtVector4R moms3 = p->getDaug( m_d3 )->getP4();
EvtVector4R p4_p;
p4_p.set( p->mass(), 0.0, 0.0, 0.0 );
EvtComplex amp( 1.0, 0.0 );
//now determine which D and which decay
//data from Anjos et al, Phys.Rev.D 1993, v.48,num.1,p.56 (E691 resuls)
//for D+ -> K- pi+ pi+, and from Adler et al, Phys.Lett. B196 (1987), 107
//(Mark III results) for D+ -> K0bar pi+ pi0.
//CLEO results for D0->k-pi+pi0
if ( m_flag == 1 ) {
// D+ -> K- pi+ pi+ decay, or charge conjugate
// //Anjos etal e691 - Phys Rev D48, 56 (1993)
// EvtResonance DplusRes11(p4_p,moms1,moms2,0.78,-60.0,0.0498,0.89610,1);
// EvtResonance DplusRes12(p4_p,moms3,moms1,0.78,-60.0,0.0498,0.89610,1);//K*(892)
// EvtResonance DplusRes21(p4_p,moms1,moms2,0.53,132.0,0.287,1.429,0);
// EvtResonance DplusRes22(p4_p,moms3,moms1,0.53,132.0,0.287,1.429,0);//K*(1430)
// EvtResonance DplusRes31(p4_p,moms1,moms2,0.47,-51.0,0.323,1.714,1);
// EvtResonance DplusRes32(p4_p,moms3,moms1,0.47,-51.0,0.323,1.714,1);//K*(1680)
// amp = amp + oneby2*(-DplusRes11.resAmpl()+DplusRes12.resAmpl()) + oneby2*(DplusRes21.resAmpl() + DplusRes22.resAmpl()) + oneby2*(-DplusRes31.resAmpl()+ DplusRes32.resAmpl());
// EvtResonance DplusRes11(p4_p,moms1,moms2,amp,phase,width,mass,L);
//CLEO-c p15,arxiv:0802.4214v2
EvtResonance2 DplusRes11( p4_p, moms1, moms2, 1.0, 0.0, 0.0503, 0.896,
1, true );
EvtResonance2 DplusRes12( p4_p, moms3, moms1, 1.0, 0.0, 0.0503, 0.896,
1, true ); //K*(892)
EvtResonance2 DplusRes21( p4_p, moms1, moms2, 3.0, 49.7 - 180.0, 0.164,
1.463, 0 );
EvtResonance2 DplusRes22( p4_p, moms3, moms1, 3.0, 49.7 - 180.0, 0.164,
1.463, 0 ); //K*(1430)
EvtResonance2 DplusRes31( p4_p, moms1, moms2, 0.96, -29.9 + 180.0,
0.109, 1.4324, 2, true );
EvtResonance2 DplusRes32( p4_p, moms3, moms1, 0.96, -29.9 + 180.0,
0.109, 1.4324, 2, true ); // K*_2(1430)
EvtResonance2 DplusRes41( p4_p, moms1, moms2, 6.5, 29.0, 0.323, 1.717,
1, true );
EvtResonance2 DplusRes42( p4_p, moms3, moms1, 6.5, 29.0, 0.323, 1.717,
1, true ); //K*(1680)
EvtResonance2 DplusRes51( p4_p, moms1, moms2, 5.01, -163.7 + 180.0,
0.470, 0.809, 0 );
EvtResonance2 DplusRes52( p4_p, moms3, moms1, 5.01, -163.7 + 180.0,
0.470, 0.809, 0 ); //kappa(800)
double pi180inv = 1.0 / EvtConst::radToDegrees;
amp = EvtComplex( 7.4 * cos( ( -18.4 + 180.0 ) * pi180inv ),
7.4 * sin( ( -18.4 + 180.0 ) * pi180inv ) ) +
oneby2 * ( -DplusRes11.resAmpl() + DplusRes12.resAmpl() ) +
oneby2 * ( DplusRes21.resAmpl() + DplusRes22.resAmpl() ) +
oneby2 * ( DplusRes31.resAmpl() + DplusRes32.resAmpl() ) +
oneby2 * ( -DplusRes41.resAmpl() + DplusRes42.resAmpl() ) +
oneby2 * ( DplusRes51.resAmpl() + DplusRes52.resAmpl() );
//amp = amp+oneby2*(-DplusRes11.resAmpl()+DplusRes12.resAmpl());
}
if ( m_flag == 2 ) {
//have a D+ -> K0bar pi+ pi0 decay
//adler etal MarkIII - Phys Lett B196, 107 (1987)
// Results in this paper:
// Kbar rho+ FitFraction = 68+/-8+/-12 Phase 0
// Kbar* pi+ 19+/-6+/-6 43+/-23
// nonres 13+/-7+/-8 250+/-19
// These numbers below seem not to be exactly the same
// the phases are equiv to -106=254 and 41
//
EvtResonance DplusKpipi0Res1( p4_p, moms2, moms3, 1.00, 0.00, 0.1512,
0.7699, 1 ); //rho+
EvtResonance DplusKpipi0Res2( p4_p, moms3, moms1, 0.8695, 0.7191,
0.0498, 0.89159, 1 ); //K*0
amp = 0.9522 * EvtComplex( cos( -1.8565 ), sin( -1.8565 ) ) +
1.00 * DplusKpipi0Res1.relBrWig( 0 ) +
0.8695 * EvtComplex( cos( 0.7191 ), sin( 0.7191 ) ) *
DplusKpipi0Res2.relBrWig( 1 );
}
if ( m_flag == 3 ) {
// D0 -> K0bar pi- pi+ & CC
// If it does not come from a B->DK, decay it as D0 or D0bar separately
// if p4_p is D0, moms1 is K0, moms2 is pi-, moms3 is pi+
// if p4_p is D0bar, moms1 is K0, moms2 is pi+, moms3 is pi-
if ( isBToDK ) {
// Gamma angle in rad.
const double gamma = EvtDecayTable::getInstance()
.getDecayFunc( p->getParent() )
->getArg( 0 );
// Strong phase in rad.
const double delta = EvtDecayTable::getInstance()
.getDecayFunc( p->getParent() )
->getArg( 1 );
// Ratio between B->D0K and B->D0barK
const double A = EvtDecayTable::getInstance()
.getDecayFunc( p->getParent() )
->getArg( 2 );
EvtComplex Factor( fabs( A ) * cos( delta ),
fabs( A ) * sin( delta ) );
if ( ( p->getParent()->getId() == BP ) ||
( p->getParent()->getId() == B0 ) ) {
// the ratio D/Dbar
Factor = Factor * EvtComplex( cos( gamma ), sin( gamma ) );
if ( p->getId() == D0 ) {
// the flavor of the particle has no meaning. But we need
// it to know which daughter is pi+ or pi-
// M( B+ or B0 ) = f(Dbar) + factor * f(D)
// f(Dbar) = amplDtoK0PiPi(pD, K0, pi+, pi-)
// f(D) = amplDtoK0PiPi(pD, K0, pi-, pi+)
// Then ...
amp = amplDtoK0PiPi( p4_p, moms1, moms3, moms2 ) +
Factor * amplDtoK0PiPi( p4_p, moms1, moms2, moms3 );
} else {
amp = amplDtoK0PiPi( p4_p, moms1, moms2, moms3 ) +
Factor * amplDtoK0PiPi( p4_p, moms1, moms3, moms2 );
}
} else if ( ( p->getParent()->getId() == BM ) ||
( p->getParent()->getId() == B0B ) ) {
Factor = Factor * EvtComplex( cos( gamma ), -sin( gamma ) );
// here M( B- or B0bar ) = f(D) + factor * f(Dbar) then ...
if ( p->getId() == D0 ) {
amp = amplDtoK0PiPi( p4_p, moms1, moms2, moms3 ) +
Factor * amplDtoK0PiPi( p4_p, moms1, moms3, moms2 );
} else {
amp = amplDtoK0PiPi( p4_p, moms1, moms3, moms2 ) +
Factor * amplDtoK0PiPi( p4_p, moms1, moms2, moms3 );
}
}
} else {
amp = amplDtoK0PiPi( p4_p, moms1, moms2, moms3 );
}
}
if ( m_flag == 4 ) {
// D0 to K- pi+ pi0
EvtResonance2 DKpipi0Res1( p4_p, moms2, moms3, 1.0, 0.0, 0.1507, 0.770,
1 ); //rho
EvtResonance2 DKpipi0Res2( p4_p, moms1, moms2, 0.39, -0.2, 0.0505,
0.8961, 1 ); //k*0
EvtResonance2 DKpipi0Res3( p4_p, moms1, moms3, 0.44, 163.0, 0.050,
0.8915, 1 ); //k*-
EvtResonance2 DKpipi0Res4( p4_p, moms1, moms3, 0.77, 55.5, 0.294, 1.412,
0 ); //k01430-
EvtResonance2 DKpipi0Res5( p4_p, moms1, moms2, 0.85, 166.0, 0.294,
1.412, 0 ); //k01430bar
EvtResonance2 DKpipi0Res6( p4_p, moms2, moms3, 2.5, 171.0, 0.240, 1.700,
1 ); //rho1700
EvtResonance2 DKpipi0Res7( p4_p, moms1, moms3, 2.5, 103.0, 0.322, 1.717,
1 ); //K*1680-
double pi180inv = 1.0 / EvtConst::radToDegrees;
amp = EvtComplex( 1.75 * cos( 31.2 * pi180inv ),
1.75 * sin( 31.2 * pi180inv ) ) +
DKpipi0Res1.resAmpl() + DKpipi0Res2.resAmpl() +
DKpipi0Res3.resAmpl() + DKpipi0Res4.resAmpl() +
DKpipi0Res5.resAmpl() + DKpipi0Res6.resAmpl() +
DKpipi0Res7.resAmpl();
}
if ( m_flag == 5 ) {
// D0 -> K0bar K+ K- & CC
// If it does not come from a B->DK, decay it as D0 or D0bar separately
// if p4_p is D0, moms1 is K0, moms2 is pi-, moms3 is pi+
// if p4_p is D0bar, moms1 is K0, moms2 is pi+, moms3 is pi-
if ( isBToDK ) {
// Gamma angle in rad.
double gamma = EvtDecayTable::getInstance()
.getDecayFunc( p->getParent() )
->getArg( 0 );
// Strong phase in rad.
double delta = EvtDecayTable::getInstance()
.getDecayFunc( p->getParent() )
->getArg( 1 );
// Ratio between B->D0K and B->D0barK
double A = EvtDecayTable::getInstance()
.getDecayFunc( p->getParent() )
->getArg( 2 );
EvtComplex Factor( fabs( A ) * cos( delta ),
fabs( A ) * sin( delta ) );
if ( ( p->getParent()->getId() == BP ) ||
( p->getParent()->getId() == B0 ) ) {
// the ratio D/Dbar
Factor = Factor * EvtComplex( cos( gamma ), sin( gamma ) );
if ( p->getId() == D0 ) {
// the flavor of the particle has no meaning. But we need
// it to know which daughter is pi+ or pi-
// M( B+ or B0 ) = f(Dbar) + factor * f(D)
// f(Dbar) = amplDtoK0PiPi(pD, K0, K+, K-)
// f(D) = amplDtoK0PiPi(pD, K0, K-, K+)
// Then ...
amp = amplDtoK0KK( p4_p, moms1, moms3, moms2 ) +
Factor * amplDtoK0KK( p4_p, moms1, moms2, moms3 );
} else {
amp = amplDtoK0KK( p4_p, moms1, moms2, moms3 ) +
Factor * amplDtoK0KK( p4_p, moms1, moms3, moms2 );
}
} else if ( ( p->getParent()->getId() == BM ) ||
( p->getParent()->getId() == B0B ) ) {
Factor = Factor * EvtComplex( cos( gamma ), -sin( gamma ) );
// here M( B- or B0bar ) = f(D) + factor * f(Dbar) then ...
if ( p->getId() == D0 ) {
amp = amplDtoK0KK( p4_p, moms1, moms2, moms3 ) +
Factor * amplDtoK0KK( p4_p, moms1, moms3, moms2 );
} else {
amp = amplDtoK0KK( p4_p, moms1, moms3, moms2 ) +
Factor * amplDtoK0KK( p4_p, moms1, moms2, moms3 );
}
}
} else {
amp = amplDtoK0KK( p4_p, moms1, moms2, moms3 );
}
}
// Ds+ -> K- K+ pi+
//Babar, arxiv:1011.4190
if ( m_flag == 6 ) {
EvtResonance2 DsKKpiRes1( p4_p, moms3, moms1, 1.0, 0.0, 0.0455, 0.8944,
1, true ); // K*(892)
EvtResonance2 DsKKpiRes2( p4_p, moms3, moms1, 1.48, 138., 0.290, 1.414,
0 ); // K*_0(1430)
EvtFlatte DsKKpiRes3( p4_p, moms1, moms2, 5.07, 156., 0.965,
m_kkpi_params ); // f_0(980)
EvtResonance2 DsKKpiRes4( p4_p, moms1, moms2, 1.15, -10., 0.00426,
1.019455, 1, true ); // phi(1020)
EvtResonance2 DsKKpiRes5( p4_p, moms1, moms2, 1.28, 53., 0.265, 1.350,
0 ); // f_0(1370)
EvtResonance2 DsKKpiRes6( p4_p, moms1, moms2, 1.19, 87., 0.137, 1.724,
0 ); // f_0(1710)
amp = DsKKpiRes1.resAmpl() + DsKKpiRes2.resAmpl() + DsKKpiRes3.resAmpl() +
DsKKpiRes4.resAmpl() + DsKKpiRes5.resAmpl() + DsKKpiRes6.resAmpl();
}
//D+ -> K- K+ pi+
//CLEO PRD 78, 072003 (2008) Fit A
if ( m_flag == 7 ) {
EvtResonance2 DpKKpiRes1( p4_p, moms3, moms1, 1.0, 0.0, 0.0503, 0.8960,
1, true ); // K*(892)
EvtResonance2 DpKKpiRes2( p4_p, moms3, moms1, 3.7, 73.0, 0.290, 1.414,
0 ); // K*_0(1430)
EvtResonance2 DpKKpiRes3( p4_p, moms1, moms2, 1.189, -179.0 + 180.0,
0.00426, 1.019455, 1, true ); // phi(1020)
EvtResonance2 DpKKpiRes4( p4_p, moms1, moms2, 1.72, 123., 0.265, 1.474,
0 ); // a_0(1450)
EvtResonance2 DpKKpiRes5( p4_p, moms1, moms2, 1.9, -52.0 + 180.0, 0.15,
1.68, 1, true ); // phi(1680)
EvtResonance2 DpKKpiRes6( p4_p, moms3, moms1, 6.4, 150., 0.109, 1.4324,
2, true ); // K*_2(1430)
double pi180inv = 1.0 / EvtConst::radToDegrees;
amp = EvtComplex( 5.1 * cos( ( 53.0 ) * pi180inv ),
5.1 * sin( ( 53.0 ) * pi180inv ) ) +
DpKKpiRes1.resAmpl() + DpKKpiRes2.resAmpl() + DpKKpiRes3.resAmpl() +
DpKKpiRes4.resAmpl() + DpKKpiRes5.resAmpl() + DpKKpiRes6.resAmpl();
}
//D+ -> pi- pi+ K+ WS (DCS)
//FOCUS PLB 601 10 (2004) ; amplitudes there are individually normalized (although not explicit in the paper)
// thus the magnitudes appearing below come from dividing the ones appearing in the paper by the sqrt of the
// integral over the DP of the corresponding squared amplitude. Writing as pi- pi+ K+ so pipi resonances are (12)
// and Kpi resonances are (31); masses and widths corresponds to PDG 2010
if ( m_flag == 8 ) {
EvtResonance2 DpKpipiDCSRes1( p4_p, moms1, moms2, 1.0, 0.0, 0.149,
0.775, 1, true ); // rho(770)
EvtResonance2 DpKpipiDCSRes2( p4_p, moms3, moms1, 1.0971, -167.1,
0.0487, 0.896, 1, true ); // K*(890)
EvtResonance2 DpKpipiDCSRes3( p4_p, moms1, moms2, 0.4738, -134.5, 0.059,
0.972, 0 ); // f0(980) as simple BW
EvtResonance2 DpKpipiDCSRes4( p4_p, moms3, moms1, 2.2688, 54.4, 0.109,
1.432, 2, true ); // K*2(1430)
amp = DpKpipiDCSRes1.resAmpl() + DpKpipiDCSRes2.resAmpl() +
DpKpipiDCSRes3.resAmpl() + DpKpipiDCSRes4.resAmpl();
}
//Ds+ -> pi- pi+ K+ WS (CS)
//FOCUS PLB 601 10 (2004) ; amplitudes there are individually normalized (although not explicit in the paper)
// thus the magnitudes appearing below come from dividing the ones appearing in the paper by the sqrt of the
// integral over the DP of the corresponding squared amplitude. Writing as pi- pi+ K+ so pipi resonances are (12)
// and Kpi resonances are (31); masses and widths corresponds to PDG 2010
// PROBLEM: by simply doing the procedure for D+, the resulting DP and projections do not resemble what is
// in the paper; the best model is by adding 180 to the vector Kpi resonances
if ( m_flag == 9 ) {
EvtResonance2 DsKpipiCSRes1( p4_p, moms1, moms2, 1.0, 0.0, 0.149, 0.775,
1, true ); // rho(770)
EvtResonance2 DsKpipiCSRes2( p4_p, moms3, moms1, 0.7236, -18.3, 0.0487,
0.896, 1, true ); // K*(890)
EvtResonance2 DsKpipiCSRes3( p4_p, moms3, moms1, 2.711, 145.2, 0.232,
1.414, 1, true ); // K*(1410)
EvtResonance2 DsKpipiCSRes4( p4_p, moms3, moms1, 1.7549, 59.3, 0.270,
1.425, 0 ); // K*0(1430)
EvtResonance2 DsKpipiCSRes5( p4_p, moms1, moms2, 7.0589, -151.7, 0.400,
1.465, 1, true ); // rho(1450)
double pi180inv = 1.0 / EvtConst::radToDegrees;
amp = EvtComplex( 3.98 * cos( 43.1 * pi180inv ),
3.98 * sin( 43.1 * pi180inv ) ) +
DsKpipiCSRes1.resAmpl() + DsKpipiCSRes2.resAmpl() +
DsKpipiCSRes3.resAmpl() + DsKpipiCSRes4.resAmpl() +
DsKpipiCSRes5.resAmpl();
}
// D+ -> pi- pi+ pi+ from E791 [PRL 86 770 (2001)]
// masses and widths below correspond to what they used; there, the amplitudes were individually normalized
// (although not explicit) so magnitudes here are obtained after correcting for that
// Breit-Wigner has a factor of (-1) there which changes the relative phase of the NR wrt to the resonances
// thus the NR magnitude is set as negative
if ( m_flag == 10 ) {
EvtResonance2 DppipipiRes11( p4_p, moms1, moms2, 1.0, 0.0, 0.150, 0.769,
1, true ); // rho(770)
EvtResonance2 DppipipiRes12( p4_p, moms3, moms1, 1.0, 0.0, 0.150, 0.769,
1, true ); // rho(770)
EvtResonance2 DppipipiRes21( p4_p, moms1, moms2, 2.2811, 205.7, 0.324,
0.478, 0 ); // sigma(500)
EvtResonance2 DppipipiRes22( p4_p, moms3, moms1, 2.2811, 205.7, 0.324,
0.478, 0 ); // sigma(500)
EvtResonance2 DppipipiRes31( p4_p, moms1, moms2, 0.4265, 165.0, 0.044,
0.977, 0 ); // f0(980) simple BW
EvtResonance2 DppipipiRes32( p4_p, moms3, moms1, 0.4265, 165.0, 0.044,
0.977, 0 ); // f0(980) simple BW
EvtResonance2 DppipipiRes41( p4_p, moms1, moms2, 2.0321, 57.3, 0.185,
1.275, 2, true ); // f2(1270)
EvtResonance2 DppipipiRes42( p4_p, moms3, moms1, 2.0321, 57.3, 0.185,
1.275, 2, true ); // f2(1270)
EvtResonance2 DppipipiRes51( p4_p, moms1, moms2, 0.7888, 105.4, 0.173,
1.434, 0 ); // f0(1370)
EvtResonance2 DppipipiRes52( p4_p, moms3, moms1, 0.7888, 105.4, 0.173,
1.434, 0 ); // f0(1370)
EvtResonance2 DppipipiRes61( p4_p, moms1, moms2, 0.7363, 319.1, 0.310,
1.465, 1, true ); // rho(1450)
EvtResonance2 DppipipiRes62( p4_p, moms3, moms1, 0.7363, 319.1, 0.310,
1.465, 1, true ); // rho(1450)
double pi180inv = 1.0 / EvtConst::radToDegrees;
amp = EvtComplex( -3.98 * cos( 57.3 * pi180inv ),
-3.98 * sin( 57.3 * pi180inv ) ) +
- ( DppipipiRes11.resAmpl() - DppipipiRes12.resAmpl() ) //spin1
- + ( DppipipiRes21.resAmpl() + DppipipiRes22.resAmpl() ) +
+ ( DppipipiRes11.resAmpl() - DppipipiRes12.resAmpl() ) + //spin1
+ ( DppipipiRes21.resAmpl() + DppipipiRes22.resAmpl() ) +
( DppipipiRes31.resAmpl() + DppipipiRes32.resAmpl() ) +
( DppipipiRes41.resAmpl() + DppipipiRes42.resAmpl() ) +
( DppipipiRes51.resAmpl() + DppipipiRes52.resAmpl() ) +
( DppipipiRes61.resAmpl() - DppipipiRes62.resAmpl() ); //spin1
}
// Ds+ -> pi- pi+ pi+ from E791 [PRL 86 765 (2001)]
// masses and widths below correspond to what they used; there, the amplitudes were individually normalized
// (although not explicit) so magnitudes here are obtained after correcting for that
// Breit-Wigner has a factor of (-1) there which changes the relative phase of the NR wrt to the resonances
// thus the NR magnitude is set as negative
if ( m_flag == 11 ) {
EvtResonance2 DspipipiRes11( p4_p, moms1, moms2, 0.288, 109., 0.150,
0.769, 1, true ); // rho(770)
EvtResonance2 DspipipiRes12( p4_p, moms3, moms1, 0.288, 109., 0.150,
0.769, 1, true ); // rho(770)
EvtResonance2 DspipipiRes21( p4_p, moms1, moms2, 1.0, 0.0, 0.044, 0.977,
0 ); // f0(980) simple BW
EvtResonance2 DspipipiRes22( p4_p, moms3, moms1, 1.0, 0.0, 0.044, 0.977,
0 ); // f0(980) simple BW
EvtResonance2 DspipipiRes31( p4_p, moms1, moms2, 1.075, 133., 0.185,
1.275, 2, true ); // f2(1270)
EvtResonance2 DspipipiRes32( p4_p, moms3, moms1, 1.075, 133., 0.185,
1.275, 2, true ); // f2(1270)
EvtResonance2 DspipipiRes41( p4_p, moms1, moms2, 2.225, 198., 0.173,
1.434, 0 ); // f0(1370)
EvtResonance2 DspipipiRes42( p4_p, moms3, moms1, 2.225, 198., 0.173,
1.434, 0 ); // f0(1370)
EvtResonance2 DspipipiRes51( p4_p, moms1, moms2, 1.107, 162., 0.310,
1.465, 1, true ); // rho(1450)
EvtResonance2 DspipipiRes52( p4_p, moms3, moms1, 1.107, 162., 0.310,
1.465, 1, true ); // rho(1450)
double pi180inv = 1.0 / EvtConst::radToDegrees;
amp = EvtComplex( -0.723 * cos( 181. * pi180inv ),
-0.723 * sin( 181. * pi180inv ) ) +
- ( DspipipiRes11.resAmpl() - DspipipiRes12.resAmpl() ) //spin1
- + ( DspipipiRes21.resAmpl() + DspipipiRes22.resAmpl() ) +
+ ( DspipipiRes11.resAmpl() - DspipipiRes12.resAmpl() ) + //spin1
+ ( DspipipiRes21.resAmpl() + DspipipiRes22.resAmpl() ) +
( DspipipiRes31.resAmpl() + DspipipiRes32.resAmpl() ) +
( DspipipiRes41.resAmpl() + DspipipiRes42.resAmpl() ) +
( DspipipiRes51.resAmpl() - DspipipiRes52.resAmpl() ); //spin1
}
//D0 -> pi- pi+ pi0
//PRL 99, 251801 (2007)
//arXiv:hep-ex/0703037
// Amplitude magnitudes taken from the above paper, but corrected for normalization
// For details, see https://phab.hepforge.org/T219
if ( m_flag == 12 ) {
EvtResonance2 DpipipiRes1p( p4_p, moms2, moms3, 1.0, 0.0, 0.149, 0.775,
1, true ); //rho+(770)
EvtResonance2 DpipipiRes1( p4_p, moms1, moms2, 0.6237, 16.2, 0.149,
0.775, 1, true ); //rho0(770)
EvtResonance2 DpipipiRes1m( p4_p, moms3, moms1, 0.7143, -2.0, 0.149,
0.775, 1, true ); //rho-(770)
EvtResonance2 DpipipiRes2p( p4_p, moms2, moms3, 0.2587, -146.0, 0.400,
1.465, 1, true ); //rho+(1450)
EvtResonance2 DpipipiRes2( p4_p, moms1, moms2, 0.4258, 10.0, 0.400,
1.465, 1, true ); //rho0(1450)
EvtResonance2 DpipipiRes2m( p4_p, moms3, moms1, 1.043, 16.0, 0.400,
1.465, 1, true ); //rho-(1450)
EvtResonance2 DpipipiRes3p( p4_p, moms2, moms3, 4.155, -17.0, 0.250,
1.720, 1, true ); //rho+(1700)
EvtResonance2 DpipipiRes3( p4_p, moms1, moms2, 4.508, -17.0, 0.250,
1.720, 1, true ); //rho0(1700)
EvtResonance2 DpipipiRes3m( p4_p, moms3, moms1, 3.670, -50.0, 0.250,
1.720, 1, true ); //rho-(1700)
EvtResonance2 DpipipiRes4( p4_p, moms1, moms2, 0.07289, -59.0, 0.07,
0.980, 0 ); //f0(980)
EvtResonance2 DpipipiRes5( p4_p, moms1, moms2, 0.3186, 156.0, 0.350,
1.370, 0 ); //f0(1370)
EvtResonance2 DpipipiRes6( p4_p, moms1, moms2, 0.2075, 12.0, 0.109,
1.505, 0 ); //f0(1500)
EvtResonance2 DpipipiRes7( p4_p, moms1, moms2, 0.3823, 51.0, 0.135,
1.720, 0 ); //f0(1720)
EvtResonance2 DpipipiRes8( p4_p, moms1, moms2, 0.3878, -171.0, 0.185,
1.275, 2, true ); //f2(1270)
EvtResonance2 DpipipiRes9( p4_p, moms1, moms2, 0.3249, 8.0, 0.600, 0.400,
0 ); //sigma(400)
double pi180inv = 1.0 / EvtConst::radToDegrees;
amp = EvtComplex( 0.6087 * cos( -11.0 * pi180inv ),
0.6087 * sin( -11.0 * pi180inv ) ) +
DpipipiRes1p.resAmpl() + DpipipiRes1.resAmpl() +
DpipipiRes1m.resAmpl() + DpipipiRes2p.resAmpl() +
DpipipiRes2.resAmpl() + DpipipiRes2m.resAmpl() +
DpipipiRes3p.resAmpl() + DpipipiRes3.resAmpl() +
DpipipiRes3m.resAmpl() + DpipipiRes4.resAmpl() +
DpipipiRes5.resAmpl() + DpipipiRes6.resAmpl() +
DpipipiRes7.resAmpl() + DpipipiRes8.resAmpl() +
DpipipiRes9.resAmpl();
}
vertex( amp );
return;
}
EvtComplex EvtDDalitz::amplDtoK0PiPi( EvtVector4R p4_p, EvtVector4R moms1,
EvtVector4R moms2, EvtVector4R moms3 )
{
//K*(892)-
EvtResonance2 DK2piRes1( p4_p, moms1, moms2, 1.418, -190.0, 0.0508, 0.89166,
1 );
//K0*(1430)-
EvtResonance2 DK2piRes2( p4_p, moms1, moms2, 1.818, -337.0, 0.294, 1.412, 0 );
//K2*(1430)-
EvtResonance2 DK2piRes3( p4_p, moms1, moms2, 0.909, -5.0, 0.0985, 1.4256, 2 );
//K*(1680)-
EvtResonance2 DK2piRes4( p4_p, moms1, moms2, 5.091, -166.0, 0.322, 1.717, 1 );
//DCS K*(892)+
EvtResonance2 DK2piRes5( p4_p, moms1, moms3, 0.100, -19.0, 0.0508, 0.89166,
1 );
//Rho0
EvtResonance2 DK2piRes6( p4_p, moms3, moms2, 0.909, -340.0, 0.1502, 0.7693,
1 );
//Omega
EvtResonance2 DK2piRes7( p4_p, moms3, moms2, .0336, -226.0, 0.00844,
0.78257, 1 );
//f0(980)
EvtResonance2 DK2piRes8( p4_p, moms3, moms2, 0.309, -152.0, 0.05, 0.977, 0 );
//f0(1370)
EvtResonance2 DK2piRes9( p4_p, moms3, moms2, 1.636, -255.0, 0.272, 1.31, 0 );
//f2(1270)
EvtResonance2 DK2piRes10( p4_p, moms3, moms2, 0.636, -32.0, 0.1851, 1.2754,
2 );
return EvtComplex( 1.0, 0.0 ) + DK2piRes1.resAmpl() + DK2piRes2.resAmpl() +
DK2piRes3.resAmpl() + DK2piRes4.resAmpl() + DK2piRes5.resAmpl() +
DK2piRes6.resAmpl() + DK2piRes7.resAmpl() + DK2piRes8.resAmpl() +
DK2piRes9.resAmpl() + DK2piRes10.resAmpl();
}
//
// BaBar decay amplitudes for D0->Ks K+ K-
//
// p4_p is D0
// moms1 is K0s
// moms2 is K+
// moms3 is K-
// Amplitudes and phases are taken from BaBar hep-ex/0207089
// with convention : Non Resonant = Amp 1. / Phase 0.
EvtComplex EvtDDalitz::amplDtoK0KK( EvtVector4R p4_p, EvtVector4R moms1,
EvtVector4R moms2, EvtVector4R moms3 )
{
//phi
EvtResonance DK0KKRes1( p4_p, moms2, moms3, 113.75, -40.0, 0.0043, 1.019456,
1 );
//a0(980)
EvtResonance DK0KKRes2( p4_p, moms2, moms3, 152.25, 69.0, 0.1196, 0.9847, 0 );
//f0(980)
EvtResonance DK0KKRes3( p4_p, moms2, moms3, 30.5, -201.0, 0.05, 0.980, 0 );
//a0(980)+
EvtResonance DK0KKRes4( p4_p, moms1, moms2, 85.75, -93.0, 0.1196, 0.9847, 0 );
//a0(980)-
EvtResonance DK0KKRes5( p4_p, moms3, moms1, 8., -53.0, 0.1196, 0.9847, 0 );
return EvtComplex( 1.0, 0.0 ) + DK0KKRes1.resAmpl() + DK0KKRes2.resAmpl() +
DK0KKRes3.resAmpl() + DK0KKRes4.resAmpl() + DK0KKRes5.resAmpl();
}
diff --git a/src/EvtGenModels/EvtFourBodyPhsp.cpp b/src/EvtGenModels/EvtFourBodyPhsp.cpp
index 010421e..3fbb961 100644
--- a/src/EvtGenModels/EvtFourBodyPhsp.cpp
+++ b/src/EvtGenModels/EvtFourBodyPhsp.cpp
@@ -1,446 +1,446 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/EvtFourBodyPhsp.hh"
#include "EvtGenBase/EvtKine.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtRandom.hh"
#include "EvtGenBase/EvtReport.hh"
#include <cmath>
std::string EvtFourBodyPhsp::getName() const
{
return "FOURBODYPHSP";
}
EvtDecayBase* EvtFourBodyPhsp::clone() const
{
return new EvtFourBodyPhsp;
}
std::array<double, 4> EvtFourBodyPhsp::phspFactor(
const double mM, const double m12, const double m34,
std::array<double, 4>& daughters ) const
{
std::array<double, 4> result;
result[1] = twoBodyMomentum( mM, m12, m34 );
result[2] = twoBodyMomentum( m12, daughters[0], daughters[1] );
result[3] = twoBodyMomentum( m34, daughters[2], daughters[3] );
result[0] = result[1] * result[2] * result[3];
return result;
}
void EvtFourBodyPhsp::init()
{
// Check that we have right number of daughters
checkNDaug( 4 );
// Check whether mother is quasi-stable
auto parent = getParentId();
double width = EvtPDL::getWidth( parent );
if ( width > 1e-6 ) {
m_stableMother = false;
}
// Check whether all daughters are stable
for ( int i = 0; i < 4; ++i ) {
auto daughter = getDaug( i );
width = EvtPDL::getWidth( daughter );
if ( width > 1e-6 ) {
m_stableDaughters = false;
m_daughterMasses[i] = EvtPDL::getMinMass( daughter );
} else {
m_daughterMasses[i] = EvtPDL::getMass( daughter );
}
}
// check correct number of arguments
checkNArg( 0, 2, 4 );
double mass1 = m_daughterMasses[0];
double mass2 = m_daughterMasses[1];
double mass3 = m_daughterMasses[2];
double mass4 = m_daughterMasses[3];
double mMother = EvtPDL::getMaxMass( parent );
if ( getNArg() > 2 ) {
m_m12Min = getArg( 0 );
m_m12Max = getArg( 1 );
m_m34Min = getArg( 2 );
m_m34Max = getArg( 3 );
} else {
if ( getNArg() > 0 ) {
m_m12Min = getArg( 0 );
m_m12Max = getArg( 1 );
} else {
m_m12Min = mass1 + mass2;
m_m12Max = mMother - mass3 - mass4;
}
m_m34Min = mass3 + mass4;
m_m34Max = mMother - mass1 - mass2;
if ( m_stableDaughters == false || m_stableMother == false ) {
m_fixedBoundary = false;
}
}
// Make sure that we have correct boundaries
if ( m_m12Min < mass1 + mass2 ) {
m_m12Min = mass1 + mass2;
}
if ( m_m12Max > mMother - mass3 - mass4 ) {
m_m12Max = mMother - mass3 - mass4;
}
if ( m_m34Min < mass3 + mass4 ) {
m_m34Min = mass3 + mass4;
}
if ( m_m34Max > mMother - mass1 - mass2 ) {
m_m34Max = mMother - mass1 - mass2;
}
if ( m_stableDaughters && m_stableMother ) {
m_boundaryShape = determineBoundaryShape( m_m12Min, m_m12Max, m_m34Max,
mMother );
} else {
m_boundaryShape = Shape::variable;
}
// If we have fixed boundary, we can precalculate some variables for
// m12 and m34 generation
if ( m_fixedBoundary ) {
if ( m_boundaryShape == Shape::trapezoid ) {
const double m12Diff = m_m12Max - m_m12Min;
const double minSum = m_m12Min + m_m34Min;
m_trapNorm = ( mMother - m_m34Min ) * m12Diff -
0.5 * ( m12Diff * ( m_m12Max + m_m12Min ) );
m_trapCoeff1 = mMother - m_m34Min;
m_trapCoeff2 = mMother * mMother - 2 * mMother * minSum +
minSum * minSum;
}
if ( m_boundaryShape == Shape::pentagon ) {
m_pentagonSplit = mMother - m_m34Max;
const double area1 = ( m_pentagonSplit - m_m12Min ) *
( m_m34Max - m_m34Min );
const double pm12Diff = m_m12Max - m_pentagonSplit;
const double area2 = 0.5 * pm12Diff *
( mMother + m_m34Max - m_m12Max ) -
pm12Diff * m_m34Min;
m_pentagonFraction = area1 / ( area1 + area2 );
const double m12Diff = m_m12Max - m_pentagonSplit;
const double minSum = m_pentagonSplit + m_m34Min;
m_trapNorm = ( mMother - m_m34Min ) * m12Diff -
0.5 * ( m12Diff * ( m_m12Max + m_pentagonSplit ) );
m_trapCoeff1 = mMother - m_m34Min;
m_trapCoeff2 = mMother * mMother - 2 * mMother * minSum +
minSum * minSum;
}
}
}
void EvtFourBodyPhsp::initProbMax()
{
double startM12 = m_m12Min + ( m_m12Max - m_m12Min ) / 20.;
double startM34 = m_m34Min + ( m_m34Max - m_m34Min ) / 20.;
bool contCond = true;
int iteration = 0;
auto parent = getParentId();
double mMother = EvtPDL::getMaxMass( parent );
double funcValue = 0;
while ( contCond ) {
++iteration;
double currentM12 = startM12;
double currentM34 = startM34;
funcValue = phspFactor( mMother, currentM12, currentM34,
m_daughterMasses )[0];
// Maximum along m12
double step = ( m_m12Max - m_m12Min ) / 100.;
while ( step > 1e-4 ) {
double point1 = currentM12 + step;
if ( point1 > m_m12Max ) {
point1 = m_m12Max;
}
if ( currentM34 > mMother - point1 ) {
point1 = mMother - currentM34;
}
double point2 = currentM12 - step;
if ( point2 < m_m12Min ) {
point2 = m_m12Min;
}
double value1 = phspFactor( mMother, point1, currentM34,
m_daughterMasses )[0];
double value2 = phspFactor( mMother, point2, currentM34,
m_daughterMasses )[0];
if ( value1 > funcValue && value1 > value2 ) {
currentM12 = point1;
funcValue = value1;
} else if ( value2 > funcValue ) {
currentM12 = point2;
funcValue = value2;
}
step /= 2.;
}
// Maximum along m34
step = ( mMother - currentM12 - m_m34Min ) / 100.;
while ( step > 1e-4 ) {
double point1 = currentM34 + step;
if ( point1 > m_m34Max ) {
point1 = m_m34Max;
}
if ( point1 > mMother - currentM12 ) {
point1 = mMother - currentM12;
}
double point2 = currentM34 - step;
if ( point2 < m_m34Min ) {
point2 = m_m34Min;
}
double value1 = phspFactor( mMother, currentM12, point1,
m_daughterMasses )[0];
double value2 = phspFactor( mMother, currentM12, point2,
m_daughterMasses )[0];
if ( value1 > funcValue && value1 > value2 ) {
currentM34 = point1;
funcValue = value1;
} else if ( value2 > funcValue ) {
currentM34 = point2;
funcValue = value2;
}
step /= 2.;
}
// Check termination condition
double m12Diff = currentM12 - startM12;
double m34Diff = currentM34 - startM34;
double distSq = m12Diff * m12Diff + m34Diff * m34Diff;
if ( distSq < 1e-8 || iteration > 50 ) {
contCond = false;
}
startM12 = currentM12;
startM34 = currentM34;
}
setProbMax( funcValue * 1.05 );
}
void EvtFourBodyPhsp::decay( EvtParticle* parent )
{
parent->makeDaughters( getNDaug(), getDaugs() );
bool massTreeStatus = parent->generateMassTree();
if ( !massTreeStatus ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "Failed to generate daughters masses in EvtFourBodyPhsp."
<< std::endl;
::abort();
}
double mMother = parent->mass();
// Need to check whether boundaries are OK and whether we need to work
// out boundary shape
double cM12Min, cM12Max;
double cM34Min, cM34Max;
EvtFourBodyPhsp::Shape cShape;
if ( m_fixedBoundary ) {
cM12Min = m_m12Min;
cM12Max = m_m12Max;
cM34Min = m_m34Min;
cM34Max = m_m34Max;
cShape = m_boundaryShape;
} else {
// In this case at least one particle has non-zero width and thus
// boundaries and shape of the region can change
for ( int i = 0; i < 4; ++i ) {
auto daughter = parent->getDaug( i );
m_daughterMasses[i] = daughter->mass();
}
cM12Min = m_m12Min > ( m_daughterMasses[0] + m_daughterMasses[1] )
- ? m_m12Min
- : m_daughterMasses[0] + m_daughterMasses[1];
+ ? m_m12Min
+ : m_daughterMasses[0] + m_daughterMasses[1];
cM12Max = m_m12Max <
( mMother - m_daughterMasses[2] - m_daughterMasses[3] )
- ? m_m12Max
- : mMother - m_daughterMasses[2] - m_daughterMasses[3];
+ ? m_m12Max
+ : mMother - m_daughterMasses[2] - m_daughterMasses[3];
cM34Min = m_m34Min > ( m_daughterMasses[2] + m_daughterMasses[3] )
- ? m_m34Min
- : m_daughterMasses[2] + m_daughterMasses[3];
+ ? m_m34Min
+ : m_daughterMasses[2] + m_daughterMasses[3];
cM34Max = m_m34Max <
( mMother - m_daughterMasses[0] - m_daughterMasses[1] )
- ? m_m34Max
- : mMother - m_daughterMasses[0] - m_daughterMasses[1];
+ ? m_m34Max
+ : mMother - m_daughterMasses[0] - m_daughterMasses[1];
cShape = determineBoundaryShape( cM12Min, cM12Max, cM34Max, mMother );
}
// Generate m12 and m34
auto masses = generatePairMasses( cM12Min, cM12Max, cM34Min, cM34Max,
mMother, cShape );
const double m12 = masses.first;
const double m34 = masses.second;
// calculate probability, it will return array with 4 elements with
// probability, q, p1 and p3
auto probEval = phspFactor( mMother, m12, m34, m_daughterMasses );
setProb( probEval[0] );
// initialise kinematics
const double cosTheta1 = EvtRandom::Flat( -1.0, 1.0 );
const double sinTheta1 = std::sqrt( 1 - cosTheta1 * cosTheta1 );
const double cosTheta3 = EvtRandom::Flat( -1.0, 1.0 );
const double sinTheta3 = std::sqrt( 1 - cosTheta3 * cosTheta3 );
const double phi = EvtRandom::Flat( 0., EvtConst::twoPi );
// m12 and m34 are put along z-axis, 1 and 2 go to x-z plane and 3-4
// plane is rotated by phi compared to 1-2 plane. All momenta are set
// in 12 and 34 rest frames and then boosted to parent rest frame
const double p1x = probEval[2] * sinTheta1;
const double p1z = probEval[2] * cosTheta1;
const double p1Sq = probEval[2] * probEval[2];
const double en1 = std::sqrt( m_daughterMasses[0] * m_daughterMasses[0] +
p1Sq );
const double en2 = std::sqrt( m_daughterMasses[1] * m_daughterMasses[1] +
p1Sq );
const double p3T = probEval[3] * sinTheta3;
const double p3x = p3T * std::cos( phi );
const double p3y = p3T * std::sin( phi );
const double p3z = probEval[3] * cosTheta3;
const double p3Sq = probEval[3] * probEval[3];
const double en3 = std::sqrt( m_daughterMasses[2] * m_daughterMasses[2] +
p3Sq );
const double en4 = std::sqrt( m_daughterMasses[3] * m_daughterMasses[3] +
p3Sq );
EvtVector4R mom1( en1, p1x, 0.0, p1z );
EvtVector4R mom2( en2, -p1x, 0.0, -p1z );
EvtVector4R mom3( en3, p3x, p3y, p3z );
EvtVector4R mom4( en4, -p3x, -p3y, -p3z );
const double qSq = probEval[1] * probEval[1];
const double en12 = std::sqrt( m12 * m12 + qSq );
const double en34 = std::sqrt( m34 * m34 + qSq );
EvtVector4R q12( en12, 0.0, 0.0, probEval[1] );
EvtVector4R q34( en34, 0.0, 0.0, -probEval[1] );
mom1.applyBoostTo( q12 );
mom2.applyBoostTo( q12 );
mom3.applyBoostTo( q34 );
mom4.applyBoostTo( q34 );
// As final step, rotate everything randomly in space
const double euler1 = EvtRandom::Flat( 0., EvtConst::twoPi );
const double euler2 = std::acos( EvtRandom::Flat( -1.0, 1.0 ) );
const double euler3 = EvtRandom::Flat( 0., EvtConst::twoPi );
mom1.applyRotateEuler( euler1, euler2, euler3 );
mom2.applyRotateEuler( euler1, euler2, euler3 );
mom3.applyRotateEuler( euler1, euler2, euler3 );
mom4.applyRotateEuler( euler1, euler2, euler3 );
// Set momenta for daughters
auto daug = parent->getDaug( 0 );
daug->init( daug->getId(), mom1 );
daug = parent->getDaug( 1 );
daug->init( daug->getId(), mom2 );
daug = parent->getDaug( 2 );
daug->init( daug->getId(), mom3 );
daug = parent->getDaug( 3 );
daug->init( daug->getId(), mom4 );
}
EvtFourBodyPhsp::Shape EvtFourBodyPhsp::determineBoundaryShape(
const double m12Min, const double m12Max, const double m34Max,
const double mMother ) const
{
double maxY = mMother - m12Min;
const bool corner1 = m34Max < maxY;
maxY = mMother - m12Max;
const bool corner2 = m34Max < maxY;
if ( corner1 && corner2 ) {
return Shape::rectangle;
} else if ( !corner1 && !corner2 ) {
return Shape::trapezoid;
}
return Shape::pentagon;
}
std::pair<double, double> EvtFourBodyPhsp::generatePairMasses(
const double m12Min, const double m12Max, const double m34Min,
const double m34Max, const double mMother,
const EvtFourBodyPhsp::Shape shape ) const
{
switch ( shape ) {
case EvtFourBodyPhsp::Shape::rectangle:
return generateRectangle( m12Min, m12Max, m34Min, m34Max );
break;
case EvtFourBodyPhsp::Shape::trapezoid:
return generateTrapezoid( m12Min, m12Max, m34Min, mMother );
break;
case EvtFourBodyPhsp::Shape::pentagon:
double split, fraction;
if ( m_fixedBoundary ) {
split = m_pentagonSplit;
fraction = m_pentagonFraction;
} else {
split = mMother - m34Max;
const double area1 = ( split - m12Min ) * ( m34Max - m34Min );
const double pm12Diff = m12Max - split;
const double area2 = 0.5 * pm12Diff *
( mMother + m34Max - m12Max ) -
pm12Diff * m34Min;
fraction = area1 / ( area1 + area2 );
}
if ( EvtRandom::Flat() < fraction ) {
return generateRectangle( m12Min, split, m34Min, m34Max );
} else {
return generateTrapezoid( split, m12Max, m34Min, mMother );
}
break;
default:
return std::make_pair( m12Min, m34Min );
break;
}
}
std::pair<double, double> EvtFourBodyPhsp::generateRectangle(
const double m12Min, const double m12Max, const double m34Min,
const double m34Max ) const
{
return std::make_pair( EvtRandom::Flat( m12Min, m12Max ),
EvtRandom::Flat( m34Min, m34Max ) );
}
std::pair<double, double> EvtFourBodyPhsp::generateTrapezoid(
const double m12Min, const double m12Max, const double m34Min,
const double mMother ) const
{
double norm, coeff1, coeff2;
if ( m_fixedBoundary ) {
norm = m_trapNorm;
coeff1 = m_trapCoeff1;
coeff2 = m_trapCoeff2;
} else {
const double m12Diff = m12Max - m12Min;
const double minSum = m12Min + m34Min;
norm = ( mMother - m34Min ) * m12Diff -
0.5 * ( m12Diff * ( m12Max + m12Min ) );
coeff1 = mMother - m34Min;
coeff2 = mMother * mMother - 2 * mMother * minSum + minSum * minSum;
}
const double rnd = EvtRandom::Flat();
const double m12 = coeff1 - std::sqrt( -2.0 * rnd * norm + coeff2 );
const double m34 = EvtRandom::Flat( m34Min, mMother - m12 );
return std::make_pair( m12, m34 );
}
diff --git a/src/EvtGenModels/EvtWilsonCoefficients.cpp b/src/EvtGenModels/EvtWilsonCoefficients.cpp
index 45b8aee..bbb93a5 100644
--- a/src/EvtGenModels/EvtWilsonCoefficients.cpp
+++ b/src/EvtGenModels/EvtWilsonCoefficients.cpp
@@ -1,576 +1,578 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/EvtWilsonCoefficients.hh"
#include "EvtGenBase/EvtConst.hh"
#include "EvtGenBase/EvtReport.hh"
#include <cstdlib>
double li2spence( double );
EvtWilsonCoefficients::EvtWilsonCoefficients()
{
int i, j;
double tmpa[8] = { 14. / 23., 16. / 23., 6. / 23., -12. / 23.,
0.4086, -0.4230, -0.8994, 0.1456 };
double tmph[8] = { 2.2996, -1.0880, -3. / 7., -1. / 14.,
-0.6494, -0.0380, -0.0186, -0.0057 };
double tmpp[8] = { 0, 0, -80. / 203., 8. / 33.,
0.0433, 0.1384, 0.1648, -0.0073 };
double tmps[8] = { 0, 0, -0.2009, -0.3579,
0.0490, -0.3616, -0.3554, 0.0072 };
double tmpq[8] = { 0, 0, 0, 0, 0.0318, 0.0918, -0.2700, 0.0059 };
double tmpg[8] = { 313063. / 363036., 0, 0, 0,
-0.9135, 0.0873, -0.0571, -0.0209 };
double tmpk[6][8] = {
- { 0, 0, 1. / 2., -1. / 2., 0, 0, 0, 0 },
- { 0, 0, 1. / 2., +1. / 2., 0, 0, 0, 0 },
- { 0, 0, -1. / 14., +1. / 6., 0.0510, -0.1403, -0.0113, 0.0054 },
- { 0, 0, -1. / 14., -1. / 6., 0.0984, +0.1214, +0.0156, 0.0026 },
- { 0, 0, 0, 0, -0.0397, 0.0117, -0.0025, +0.0304 },
- { 0, 0, 0, 0, +0.0335, 0.0239, -0.0462, -0.0112 } };
+ {0, 0, 1. / 2., -1. / 2., 0, 0, 0, 0},
+ {0, 0, 1. / 2., +1. / 2., 0, 0, 0, 0},
+ {0, 0, -1. / 14., +1. / 6., 0.0510, -0.1403, -0.0113, 0.0054},
+ {0, 0, -1. / 14., -1. / 6., 0.0984, +0.1214, +0.0156, 0.0026},
+ {0, 0, 0, 0, -0.0397, 0.0117, -0.0025, +0.0304},
+ {0, 0, 0, 0, +0.0335, 0.0239, -0.0462, -0.0112}
+ };
double tmpr[2][8] = {
- { 0, 0, +0.8966, -0.1960, -0.2011, 0.1328, -0.0292, -0.1858 },
- { 0, 0, -0.1193, +0.1003, -0.0473, 0.2323, -0.0133, -0.1799 } };
+ {0, 0, +0.8966, -0.1960, -0.2011, 0.1328, -0.0292, -0.1858},
+ {0, 0, -0.1193, +0.1003, -0.0473, 0.2323, -0.0133, -0.1799}
+ };
for ( i = 0; i < 8; i++ ) {
m_a[i] = tmpa[i];
m_h[i] = tmph[i];
m_p[i] = tmpp[i];
m_s[i] = tmps[i];
m_q[i] = tmpq[i];
m_g[i] = tmpg[i];
for ( j = 0; j < 6; j++ )
m_k[j][i] = tmpk[j][i];
for ( j = 0; j < 2; j++ )
m_r[j][i] = tmpr[j][i];
}
m_n_f = 5;
m_Lambda = 0.2167;
m_alphaMZ = 0.1187;
m_mu = 4.8;
m_M_Z = 91.1876;
m_M_t = 174.3;
m_M_W = 80.425;
m_alphaS = 0;
m_eta = 0;
m_sin2W = 0.23120;
m_ialpha = 137.036;
m_C1 = m_C2 = m_C3 = m_C4 = m_C5 = m_C6 = m_C7 = m_C7eff0 = m_C8 =
m_C8eff0 = m_C9 = m_C9tilda = m_C10 = m_C10tilda = m_P0 = 0;
m_A = m_B = m_C = m_D = m_E = m_F = m_Y = m_Z = m_PE = 0;
m_ksi = 0;
}
void EvtWilsonCoefficients::SetRenormalizationScheme( std::string scheme )
{
if ( scheme == "NDR" )
m_ksi = 0;
else if ( scheme == "HV" )
m_ksi = 1;
else {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "ERROR: EvtWilsonCoefficients knows only NDR and HV schemes !"
<< std::endl;
::abort();
}
}
double EvtWilsonCoefficients::alphaS( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167 )
{
// calculate strong coupling constant for n_f flavours and scale mu
double beta0 = 11. - 2. / 3. * n_f;
double beta1 = 51. - 19. / 3. * n_f;
double beta2 = 2857. - 5033. / 9. * n_f + 325. / 27. * n_f * n_f;
double lnratio = log( mu * mu / Lambda / Lambda );
double aS = 4. * EvtConst::pi / beta0 / lnratio *
( 1. - 2 * beta1 / beta0 / beta0 * log( lnratio ) / lnratio +
4 * beta1 * beta1 / beta0 / beta0 / beta0 / beta0 / lnratio /
lnratio *
( ( log( lnratio ) - 0.5 ) * ( log( lnratio ) - 0.5 ) +
beta2 * beta0 / 8 / beta1 / beta1 - 5. / 4. ) );
return aS;
}
double EvtWilsonCoefficients::Lambda( double alpha = 0.1187, int n_f = 5,
double mu = 91.1876,
double epsilon = 0.00005,
int maxstep = 1000 )
{
// calculate Lambda matching alphaS using simple iterative method
int i;
double difference = 0;
double Lambda = mu * 0.9999999999;
double step = -mu / 20;
for ( i = 0;
i < maxstep &&
( difference = fabs( alphaS( mu, n_f, Lambda ) - alpha ) ) >= epsilon;
i++ ) {
EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
<< " Difference of alpha_S from " << alpha << " is " << difference
<< " at Lambda = " << Lambda << std::endl;
if ( alphaS( mu, n_f, Lambda ) > alpha ) {
if ( step > 0 )
step *= -0.4;
if ( alphaS( mu, n_f, Lambda + step - epsilon ) <
alphaS( mu, n_f, Lambda + step ) )
Lambda += step;
else
step *= 0.4;
} else {
if ( step < 0 )
step *= -0.4;
if ( Lambda + step < mu )
Lambda += step;
else
step *= 0.4;
}
}
EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
<< " Difference of alpha_S from " << alpha << " is " << difference
<< " at Lambda = " << Lambda << std::endl;
if ( difference >= epsilon ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< " ERROR: Did not converge Lambda for alpha_s = " << alpha
<< " , difference " << difference << " >= " << epsilon << " after "
<< i << " steps !" << std::endl;
::abort();
return -1;
} else {
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " For alpha_s = " << alphaS( mu, n_f, Lambda )
<< " was found Lambda = " << Lambda << std::endl;
return Lambda;
}
}
double EvtWilsonCoefficients::eta( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
return alphaS( M_W, n_f, Lambda ) / alphaS( mu, n_f, Lambda );
}
EvtComplex EvtWilsonCoefficients::C1( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
EvtComplex myC1( 0, 0 );
for ( i = 0; i < 8; i++ )
myC1 += m_k[0][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
return myC1;
}
EvtComplex EvtWilsonCoefficients::C2( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
EvtComplex myC2( 0, 0 );
for ( i = 0; i < 8; i++ )
myC2 += m_k[1][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
return myC2;
}
EvtComplex EvtWilsonCoefficients::C3( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
EvtComplex myC3( 0, 0 );
for ( i = 0; i < 8; i++ )
myC3 += m_k[2][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
return myC3;
}
EvtComplex EvtWilsonCoefficients::C4( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
EvtComplex myC4( 0, 0 );
for ( i = 0; i < 8; i++ )
myC4 += m_k[3][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
return myC4;
}
EvtComplex EvtWilsonCoefficients::C5( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
EvtComplex myC5( 0, 0 );
for ( i = 0; i < 8; i++ )
myC5 += m_k[4][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
return myC5;
}
EvtComplex EvtWilsonCoefficients::C6( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
EvtComplex myC6( 0, 0 );
for ( i = 0; i < 8; i++ )
myC6 += m_k[5][i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
return myC6;
}
EvtComplex EvtWilsonCoefficients::C7( double M_t = 174.3, double M_W = 80.425 )
{
return EvtComplex( -0.5 * A( M_t * M_t / M_W / M_W ), 0 );
}
EvtComplex EvtWilsonCoefficients::C8( double M_t = 174.3, double M_W = 80.425 )
{
return EvtComplex( -0.5 * F( M_t * M_t / M_W / M_W ), 0 );
}
EvtComplex EvtWilsonCoefficients::C7eff0( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167,
double M_t = 174.3, double M_W = 80.425 )
{
int i;
EvtComplex myC7eff( 0, 0 );
for ( i = 0; i < 8; i++ )
myC7eff += m_h[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
myC7eff *= C2( mu, n_f, Lambda, M_W );
myC7eff += pow( eta( mu, n_f, Lambda, M_W ), 16. / 23. ) * C7( M_t, M_W );
myC7eff += 8. / 3. *
( pow( eta( mu, n_f, Lambda, M_W ), 14. / 23. ) -
pow( eta( mu, n_f, Lambda, M_W ), 16. / 23. ) ) *
C8( M_t, M_W );
return myC7eff;
}
EvtComplex EvtWilsonCoefficients::C8eff0( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167,
double M_t = 174.3, double M_W = 80.425 )
{
int i;
EvtComplex myC8eff( 0, 0 );
for ( i = 0; i < 8; i++ )
myC8eff += m_g[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] );
myC8eff += pow( eta( mu, n_f, Lambda, M_W ), 14. / 23. ) * C8( M_t, M_W );
return myC8eff;
}
EvtComplex EvtWilsonCoefficients::C10tilda( double sin2W = 0.23120,
double M_t = 174.3,
double M_W = 80.425 )
{
return EvtComplex( -Y( M_t * M_t / M_W / M_W ) / sin2W, 0 );
}
EvtComplex EvtWilsonCoefficients::C10( double sin2W = 0.23120,
double M_t = 174.3, double M_W = 80.425,
double ialpha = 137.036 )
{
return ( 1. / 2 / EvtConst::pi / ialpha * C10tilda( sin2W, M_t, M_W ) );
}
double EvtWilsonCoefficients::A( double x )
{
return ( x * ( 8 * x * x + 5 * x - 7 ) / 12 / pow( x - 1, 3 ) +
x * x * ( 2 - 3 * x ) * log( x ) / 2 / pow( x - 1, 4 ) );
}
double EvtWilsonCoefficients::B( double x )
{
return ( x / 4 / ( 1 - x ) + x / 4 / ( x - 1 ) / ( x - 1 ) * log( x ) );
}
double EvtWilsonCoefficients::C( double x )
{
return ( x * ( x - 6 ) / 8 / ( x - 1 ) +
x * ( 3 * x + 2 ) / 8 / ( x - 1 ) / ( x - 1 ) * log( x ) );
}
double EvtWilsonCoefficients::D( double x )
{
return ( ( -19 * x * x * x + 25 * x * x ) / 36 / pow( x - 1, 3 ) +
x * x * ( 5 * x * x - 2 * x - 6 ) / 18 / pow( x - 1, 4 ) * log( x ) -
4. / 9 * log( x ) );
}
double EvtWilsonCoefficients::E( double x )
{
return ( x * ( 18 - 11 * x - x * x ) / 12 / pow( 1 - x, 3 ) +
x * x * ( 15 - 16 * x + 4 * x * x ) / 6 / pow( 1 - x, 4 ) * log( x ) -
2. / 3 * log( x ) );
}
double EvtWilsonCoefficients::F( double x )
{
return ( x * ( x * x - 5 * x - 2 ) / 4 / pow( x - 1, 3 ) +
3 * x * x / 2 / pow( x - 1, 4 ) * log( x ) );
}
double EvtWilsonCoefficients::Y( double x )
{
return ( C( x ) - B( x ) );
}
double EvtWilsonCoefficients::Z( double x )
{
return ( C( x ) + 1. / 4 * D( x ) );
}
EvtComplex EvtWilsonCoefficients::C9( int ksi = 0, double mu = 4.8, int n_f = 5,
double Lambda = 0.2167,
double sin2W = 0.23120,
double M_t = 174.3, double M_W = 80.425,
double ialpha = 137.036 )
{
return ( 1. / 2 / EvtConst::pi / ialpha *
C9tilda( ksi, mu, n_f, Lambda, sin2W, M_t, M_W ) );
}
EvtComplex EvtWilsonCoefficients::C9tilda( int ksi = 0, double mu = 4.8,
int n_f = 5, double Lambda = 0.2167,
double sin2W = 0.23120,
double M_t = 174.3,
double M_W = 80.425 )
{
return ( P0( ksi, mu, n_f, Lambda, M_W ) +
Y( M_t * M_t / M_W / M_W ) / sin2W - 4 * Z( M_t * M_t / M_W / M_W ) +
PE( mu, n_f, Lambda, M_W ) * E( M_t * M_t / M_W / M_W ) );
}
EvtComplex EvtWilsonCoefficients::P0( int ksi = 0, double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
EvtComplex myP0( 0, 0 );
for ( i = 0; i < 8; i++ )
myP0 += m_p[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] + 1 );
myP0 = EvtConst::pi / alphaS( M_W, n_f, Lambda ) * ( -0.1875 + myP0 );
myP0 += 1.2468 -
ksi * 4. / 9. *
( 3 * C1( mu, n_f, Lambda, M_W ) + C2( mu, n_f, Lambda, M_W ) -
C3( mu, n_f, Lambda, M_W ) - 3 * C4( mu, n_f, Lambda, M_W ) );
for ( i = 0; i < 8; i++ )
myP0 += pow( eta( mu, n_f, Lambda, M_W ), m_a[i] ) *
( m_r[ksi][i] + m_s[i] * eta( mu, n_f, Lambda, M_W ) );
return myP0;
}
double EvtWilsonCoefficients::PE( double mu = 4.8, int n_f = 5,
double Lambda = 0.2167, double M_W = 80.425 )
{
int i;
double myPE = 0.1405;
for ( i = 0; i < 8; i++ )
myPE += m_q[i] * pow( eta( mu, n_f, Lambda, M_W ), m_a[i] + 1 );
return myPE;
}
void EvtWilsonCoefficients::CalculateAllCoefficients()
{
m_Lambda = Lambda( m_alphaMZ, m_n_f, m_M_Z );
m_C1 = C1( m_mu, m_n_f, m_Lambda, m_M_W );
m_C2 = C2( m_mu, m_n_f, m_Lambda, m_M_W );
m_C3 = C3( m_mu, m_n_f, m_Lambda, m_M_W );
m_C4 = C4( m_mu, m_n_f, m_Lambda, m_M_W );
m_C5 = C5( m_mu, m_n_f, m_Lambda, m_M_W );
m_C6 = C6( m_mu, m_n_f, m_Lambda, m_M_W );
m_C7 = C7( m_M_t, m_M_W );
m_C8 = C8( m_M_t, m_M_W );
m_C7eff0 = C7eff0( m_mu, m_n_f, m_Lambda, m_M_t, m_M_W );
m_C8eff0 = C8eff0( m_mu, m_n_f, m_Lambda, m_M_t, m_M_W );
m_C10tilda = C10tilda( m_sin2W, m_M_t, m_M_W );
m_C10 = C10( m_sin2W, m_M_t, m_M_W, m_ialpha );
m_A = A( m_M_t * m_M_t / m_M_W / m_M_W );
m_B = B( m_M_t * m_M_t / m_M_W / m_M_W );
m_C = C( m_M_t * m_M_t / m_M_W / m_M_W );
m_D = D( m_M_t * m_M_t / m_M_W / m_M_W );
m_E = E( m_M_t * m_M_t / m_M_W / m_M_W );
m_F = F( m_M_t * m_M_t / m_M_W / m_M_W );
m_Y = Y( m_M_t * m_M_t / m_M_W / m_M_W );
m_Z = Z( m_M_t * m_M_t / m_M_W / m_M_W );
m_C9 = C9( m_ksi, m_mu, m_n_f, m_Lambda, m_sin2W, m_M_t, m_M_W, m_ialpha );
m_C9tilda = C9tilda( m_ksi, m_mu, m_n_f, m_Lambda, m_sin2W, m_M_t, m_M_W );
m_P0 = P0( m_ksi, m_mu, m_n_f, m_Lambda, m_M_W );
m_PE = PE( m_mu, m_n_f, m_Lambda, m_M_W );
m_alphaS = alphaS( m_mu, m_n_f, m_Lambda );
m_eta = eta( m_mu, m_n_f, m_Lambda, m_M_W );
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " +---------------------------------------" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Table of Wilson coeficients:" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " +---------------------------------------" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C1 = " << m_C1 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C2 = " << m_C2 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C3 = " << m_C3 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C4 = " << m_C4 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C5 = " << m_C5 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C6 = " << m_C6 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C7 = " << m_C7 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | C7eff0 = " << m_C7eff0 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C8 = " << m_C8 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | C8eff0 = " << m_C8eff0 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | C9 = " << m_C9 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | C10 = " << m_C10 << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " +---------------------------------------" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " | Other constants:" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " +---------------------------------------" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Scale = " << m_mu << " GeV" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Number of effective flavors = " << m_n_f << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Corresponding to aS(M_Z)"
<< "=" << m_alphaMZ << " Lambda = " << m_Lambda << " GeV" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Strong coupling constant = " << m_alphaS << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Electromagnetic constant = 1/" << m_ialpha << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Top mass = " << m_M_t << " GeV" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | W-boson mass = " << m_M_W << " GeV" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Z-boson mass = " << m_M_Z << " GeV" << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " | Sinus squared of Weinberg angle = " << m_sin2W << std::endl;
EvtGenReport( EVTGEN_INFO, "EvtGen" )
<< " +---------------------------------------" << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
<< " | Intermediate functions:" << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
<< " +---------------------------------------" << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | A = " << m_A << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | B = " << m_B << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | C = " << m_C << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | D = " << m_D << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | E = " << m_E << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | F = " << m_F << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | Y = " << m_Y << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | Z = " << m_Z << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | eta = " << m_eta << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
<< " | C9~ = " << m_C9tilda << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
<< " | C10~ = " << m_C10tilda << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | P0 = " << m_P0 << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " | PE = " << m_PE << std::endl;
EvtGenReport( EVTGEN_DEBUG, "EvtGen" )
<< " +--------------------------------------" << std::endl;
}
EvtComplex EvtWilsonCoefficients::hzs( double z, double shat, double mu = 4.8,
double M_b = 4.8 )
{
EvtComplex i1( 0, 1 );
double x = 4. * z * z / shat;
if ( x == 0 )
return ( 8. / 27. - 8. / 9. * log( M_b / mu ) - 4. / 9. * log( shat ) +
4. / 9. * i1 * EvtConst::pi );
else if ( x > 1 )
return ( 8. / 27. - 8. / 9. * log( M_b / mu ) - 8. / 9. * log( z ) +
4. / 9. * x -
2. / 9. * ( 2. + x ) * sqrt( x - 1. ) * 2 *
atan( 1. / sqrt( x - 1. ) ) );
else
return (
8. / 27. - 8. / 9. * log( M_b / mu ) - 8. / 9. * log( z ) +
4. / 9. * x -
2. / 9. * ( 2. + x ) * sqrt( 1. - x ) *
( log( fabs( sqrt( 1. - x ) + 1 ) / fabs( sqrt( 1. - x ) - 1 ) ) -
i1 * EvtConst::pi ) );
}
double EvtWilsonCoefficients::fz( double z )
{
return ( 1. - 8. * z * z + 8. * pow( z, 6. ) - pow( z, 8. ) -
24. * pow( z, 4. ) * log( z ) );
}
double EvtWilsonCoefficients::kappa( double z, double alpha_S )
{
return ( 1. - 2. * alpha_S / 3. / EvtConst::pi *
( ( EvtConst::pi * EvtConst::pi - 31. / 4. ) *
( 1. - z ) * ( 1. - z ) +
1.5 ) );
}
double EvtWilsonCoefficients::etatilda( double shat, double alpha_S )
{
return ( 1. + alpha_S / EvtConst::pi * omega( shat ) );
}
double EvtWilsonCoefficients::omega( double shat )
{
double o = 0;
o -= ( 2. / 9. ) * EvtConst::pi * EvtConst::pi;
o -= ( 4. / 3. ) * li2spence( shat );
o -= ( 2. / 3. ) * log( shat ) * log( 1. - shat );
o -= log( 1. - shat ) * ( 5. + 4. * shat ) / ( 3. + 6. * shat );
o -= log( shat ) * 2. * shat * ( 1. + shat ) * ( 1. - 2. * shat ) / 3. /
( 1. - shat ) / ( 1. - shat ) / ( 1. + 2. * shat );
o += ( 5. + 9. * shat - 6. * shat * shat ) / 6. / ( 1. - shat ) /
( 1. + 2. * shat );
return o;
}
EvtComplex EvtWilsonCoefficients::C9efftilda( double z, double shat,
double alpha_S, EvtComplex c1,
EvtComplex c2, EvtComplex c3,
EvtComplex c4, EvtComplex c5,
EvtComplex c6, EvtComplex c9tilda,
int ksi = 0 )
{
EvtComplex c( 0, 0 );
c += ( c9tilda + ksi * 4. / 9. * ( 3. * c1 + c2 - c3 - 3. * c4 ) ) *
etatilda( shat, alpha_S );
c += hzs( z, shat ) * ( 3. * c1 + c2 + 3. * c3 + c4 + 3. * c5 + c6 );
c -= 0.5 * hzs( 1, shat ) * ( 4. * c3 + 4. * c4 + 3. * c5 + c6 );
c -= 0.5 * hzs( 0, shat ) * ( c3 + 3. * c4 );
c += 2. / 9. * ( 3. * c3 + c4 + 3. * c5 + c6 );
return c;
}
EvtComplex EvtWilsonCoefficients::C7b2sg( double alpha_S, double et,
EvtComplex c2, double M_t = 174.3,
double M_W = 80.425 )
{
EvtComplex i1( 0, 1 );
return ( i1 * alpha_S *
( 2. / 9. * pow( et, 14. / 23. ) *
( 0.5 * F( M_t * M_t / M_W / M_W ) - 0.1687 ) -
0.03 * c2 ) );
}
EvtComplex EvtWilsonCoefficients::Yld( double q2, double* ki, double* Gi,
double* Mi, int ni, EvtComplex c1,
EvtComplex c2, EvtComplex c3,
EvtComplex c4, EvtComplex c5,
EvtComplex c6, double ialpha = 137.036 )
{
EvtComplex i1( 0, 1 );
EvtComplex y( 0, 0 );
int i;
for ( i = 0; i < ni; i++ )
y += ki[i] * Gi[i] * Mi[i] / ( q2 - Mi[i] * Mi[i] - i1 * Mi[i] * Gi[i] );
return ( -3. * ialpha * ialpha * y * EvtConst::pi *
( 3. * c1 + c2 + 3. * c3 + c4 + 3. * c5 + c6 ) );
}
diff --git a/src/EvtGenModels/EvtWnPi.cpp b/src/EvtGenModels/EvtWnPi.cpp
index a104872..8fa2e10 100644
--- a/src/EvtGenModels/EvtWnPi.cpp
+++ b/src/EvtGenModels/EvtWnPi.cpp
@@ -1,156 +1,156 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/EvtWnPi.hh"
#include "EvtGenBase/EvtDiracSpinor.hh"
#include "EvtGenBase/EvtGenKine.hh"
#include "EvtGenBase/EvtIdSet.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParser.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtReport.hh"
#include "EvtGenBase/EvtTensor4C.hh"
#include "EvtGenBase/EvtVector4C.hh"
#include "EvtGenModels/EvtTauHadnu.hh"
#include <ctype.h>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <stdlib.h>
#include <string.h>
using namespace std;
// W+ -> pi_ current
EvtVector4C EvtWnPi::WCurrent( EvtVector4R q1 )
{
return q1;
}
// W+ -> pi+ pi0 current
EvtVector4C EvtWnPi::WCurrent( EvtVector4R q1, EvtVector4R q2 )
{
return BWr( q1 + q2 ) * ( q1 - q2 );
}
// W+ -> pi+ pi+ pi- current
EvtVector4C EvtWnPi::WCurrent( EvtVector4R q1, EvtVector4R q2, EvtVector4R q3 )
{
EvtVector4R Q = q1 + q2 + q3;
double Q2 = Q.mass2();
return BWa( Q ) *
( ( q1 - q3 ) - ( Q * ( Q * ( q1 - q3 ) ) / Q2 ) * BWr( q2 + q3 ) +
( q2 - q3 ) - ( Q * ( Q * ( q2 - q3 ) ) / Q2 ) * BWr( q1 + q3 ) );
}
// W+ -> pi+ pi+ pi- pi- pi+ current with symmetrization
EvtVector4C EvtWnPi::WCurrent( EvtVector4R q1, EvtVector4R q2, EvtVector4R q3,
EvtVector4R q4, EvtVector4R q5 )
{
// double Q2 = Qtot*Qtot;
// return q1-Qtot*(q1*Qtot)/Q2;
EvtVector4C V = JB( q1, q2, q3, q4, q5 ) + JB( q5, q2, q3, q4, q1 ) +
JB( q1, q5, q3, q4, q2 ) + JB( q1, q2, q4, q3, q5 ) +
JB( q5, q2, q4, q3, q1 ) + JB( q1, q5, q4, q3, q2 );
// cout<<"BC2: Qtot="<<Qtot<<", V="<<V<<endl;
return V;
}
// a1 -> pi+ pi+ pi- BW
EvtComplex EvtWnPi::BWa( EvtVector4R q )
{
- double const _mA1 = 1.26, _GA1 = 0.4;
+ const double _mA1 = 1.26, _GA1 = 0.4;
EvtComplex I( 0, 1 );
double Q2 = q.mass2();
double GA1 = _GA1 * pi3G( Q2 ) / pi3G( _mA1 * _mA1 );
EvtComplex denBA1( _mA1 * _mA1 - Q2, -1. * _mA1 * GA1 );
return _mA1 * _mA1 / denBA1;
}
EvtComplex EvtWnPi::BWf( EvtVector4R q )
{
- double const mf = 0.8, Gf = 0.6;
+ const double mf = 0.8, Gf = 0.6;
EvtComplex I( 0, 1 );
double Q2 = q.mass2();
return mf * mf / ( mf * mf - Q2 - I * mf * Gf );
}
EvtComplex EvtWnPi::BWr( EvtVector4R q )
{
double _mRho = 0.775, _gammaRho = 0.149, _mRhopr = 1.364,
_gammaRhopr = 0.400, _beta = -0.108;
double m1 = EvtPDL::getMeanMass( EvtPDL::getId( "pi+" ) ),
m2 = EvtPDL::getMeanMass( EvtPDL::getId( "pi+" ) );
double mQ2 = q.mass2();
// momenta in the rho->pipi decay
double dRho = _mRho * _mRho - m1 * m1 - m2 * m2;
double pPiRho = ( 1.0 / _mRho ) *
sqrt( ( dRho * dRho ) / 4.0 - m1 * m1 * m2 * m2 );
double dRhopr = _mRhopr * _mRhopr - m1 * m1 - m2 * m2;
double pPiRhopr = ( 1.0 / _mRhopr ) *
sqrt( ( dRhopr * dRhopr ) / 4.0 - m1 * m1 * m2 * m2 );
double dQ = mQ2 - m1 * m1 - m2 * m2;
double pPiQ = ( 1.0 / sqrt( mQ2 ) ) *
sqrt( ( dQ * dQ ) / 4.0 - m1 * m1 * m2 * m2 );
double gammaRho = _gammaRho * _mRho / sqrt( mQ2 ) *
pow( ( pPiQ / pPiRho ), 3 );
EvtComplex BRhoDem( _mRho * _mRho - mQ2, -1.0 * _mRho * gammaRho );
EvtComplex BRho = _mRho * _mRho / BRhoDem;
double gammaRhopr = _gammaRhopr * _mRhopr / sqrt( mQ2 ) *
pow( ( pPiQ / pPiRhopr ), 3 );
EvtComplex BRhoprDem( _mRhopr * _mRhopr - mQ2, -1.0 * _mRho * gammaRhopr );
EvtComplex BRhopr = _mRhopr * _mRhopr / BRhoprDem;
return ( BRho + _beta * BRhopr ) / ( 1 + _beta );
}
double EvtWnPi::pi3G( double m2 )
{
double mPi = EvtPDL::getMeanMass( EvtPDL::getId( "pi+" ) );
double _mRho = 0.775;
if ( m2 > ( _mRho + mPi ) ) {
return m2 * ( 1.623 + 10.38 / m2 - 9.32 / ( m2 * m2 ) +
0.65 / ( m2 * m2 * m2 ) );
} else {
double t1 = m2 - 9.0 * mPi * mPi;
return 4.1 * pow( t1, 3.0 ) * ( 1.0 - 3.3 * t1 + 5.8 * t1 * t1 );
};
}
EvtVector4C EvtWnPi::JB( EvtVector4R p1, EvtVector4R p2, EvtVector4R p3,
EvtVector4R p4, EvtVector4R p5 )
{
EvtVector4R Qtot = p1 + p2 + p3 + p4 + p5, Qa = p1 + p2 + p3;
EvtTensor4C T = ( 1 / Qtot.mass2() ) *
EvtGenFunctions::directProd( Qtot, Qtot ) -
EvtTensor4C::g();
EvtVector4R V13 = Qa * ( p2 * ( p1 - p3 ) ) / Qa.mass2() - ( p1 - p3 );
EvtVector4R V23 = Qa * ( p1 * ( p2 - p3 ) ) / Qa.mass2() - ( p2 - p3 );
return BWa( Qtot ) * BWa( Qa ) * BWf( p4 + p5 ) *
( T.cont1( V13 ) * BWr( p1 + p3 ) + T.cont1( V23 ) * BWr( p2 + p3 ) );
}
diff --git a/src/EvtGenModels/Evtbs2llGammaAmp.cpp b/src/EvtGenModels/Evtbs2llGammaAmp.cpp
index 5f46912..aa3787e 100644
--- a/src/EvtGenModels/Evtbs2llGammaAmp.cpp
+++ b/src/EvtGenModels/Evtbs2llGammaAmp.cpp
@@ -1,857 +1,857 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/Evtbs2llGammaAmp.hh"
#include "EvtGenBase/EvtAmp.hh"
#include "EvtGenBase/EvtComplex.hh"
#include "EvtGenBase/EvtDiracSpinor.hh"
#include "EvtGenBase/EvtGenKine.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtIdSet.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtReport.hh"
#include "EvtGenBase/EvtScalarParticle.hh"
#include "EvtGenBase/EvtTensor4C.hh"
#include "EvtGenBase/EvtVector4C.hh"
#include "EvtGenBase/EvtVectorParticle.hh"
#include "EvtGenModels/EvtbTosllWilsCoeffNLO.hh"
#include "EvtGenModels/Evtbs2llGammaFFMNT.hh"
#include <cstdlib>
// input: *parent - the pointer to the parent particle (B-meson, the
// object of the EvtParticle class);
// *formFactors - the pointer to instance of EvtbTosllGammaFF class object;
// *WilsCoeff - the pointer to the Standart Model Wilson Coefficients class;
// mu - the scale parameter, GeV;
// Nf - number of "effective" flavors (for b-quark Nf=5);
// res_swch - resonant switching parameter:
// = 0 the resonant contribution switched OFF,
// = 1 the resonant contribution switched ON;
// ias - switching parameter for \alpha_s(M_Z) value:
// = 0 PDG 1sigma minimal alpha_s(M_Z),
// = 1 PDG average value alpha_s(M_Z),
// = 2 PDG 1sigma maximal alpha_s(M_Z).
// Egamma_min - photon energy cut, GeV;
// Wolfenstein parameterization for CKM matrix
// CKM_A, CKM_lambda, CKM_barrho, CKM_bareta
void Evtbs2llGammaAmp::CalcAmp( EvtParticle* parent, EvtAmp& amp,
Evtbs2llGammaFF* formFactors,
EvtbTosllWilsCoeffNLO* WilsCoeff, double mu,
int Nf, int res_swch, int ias, double Egamma_min,
double CKM_A, double CKM_lambda,
double CKM_barrho, double CKM_bareta )
{
// FILE *mytest;
int iG = 0; // photon is the first daughter particle
int il1 = 1,
il2 = 2; // leptons are the second and thirds daughter particles
EvtComplex unit1( 1.0, 0.0 ); // real unit
EvtComplex uniti( 0.0, 1.0 ); // imaginary unit
double M1 = parent->mass(); // B - meson mass, GeV
double ml = parent->getDaug( il1 )->mass(); // leptonic mass, GeV
double mq = 0.0; // light quark mass from the dispersion QM, GeV
double mc = formFactors->getQuarkMass(
4 ); // m_c mass from the dispersion QM, GeV
double mb = formFactors->getQuarkMass(
5 ); // m_b mass from the dispersion QM, GeV
double Mw = 80.403; // GeV W-boson mass, GeV
double mt = 174.2; // GeV t-quark mass, GeV
double fb = 0.0; // leptonic decay constant of B-meson, Gev
EvtComplex Vtb, Vtq, Vub, Vuq, Vcb,
Vcq; // V_{tb}, V_{tq}, V_{ub}, V_{uq}, V_{cb}, V_{cq}
EvtComplex CKM_factor; // V^*_{tq}*V_{tb}, where q={d,s}
EvtComplex lambda_qu; // V^*_{uq}*V_{ub}/V^*_{tq}*V_{tb}, where q={d,s}
EvtComplex lambda_qc; // V^*_{cq}*V_{cb}/V^*_{tq}*V_{tb}, where q={d,s}
double Relambda_qu, Imlambda_qu;
// to find charges of ell^+ and ell^- in the B-meson daughters
int charge1 = EvtPDL::chg3( parent->getDaug( il1 )->getId() );
int charge2 = EvtPDL::chg3( parent->getDaug( il2 )->getId() );
if ( charge1 == 0 || charge2 == 0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function EvtbsTollGammaAmp::CalcAmp(...)"
<< "\n Error in the leptonic charge getting!"
<< "\n charge1 =" << charge1
<< "\n charge2 =" << charge2 << "\n charge gamma ="
<< EvtPDL::chg3( parent->getDaug( iG )->getId() )
<< "\n number of daughters =" << parent->getNDaug() << std::endl;
::abort();
}
EvtParticle* lepPlus = nullptr;
EvtParticle* lepMinus = nullptr;
lepPlus = ( charge1 > charge2 )
- ? parent->getDaug( il1 )
- : parent->getDaug( il2 ); // positive charged
+ ? parent->getDaug( il1 )
+ : parent->getDaug( il2 ); // positive charged
lepMinus = ( charge1 < charge2 )
- ? parent->getDaug( il1 )
- : parent->getDaug( il2 ); // negative charged
+ ? parent->getDaug( il1 )
+ : parent->getDaug( il2 ); // negative charged
EvtVector4R p = parent->getP4Restframe(); // B-meson momentum in the B-rest frame
EvtVector4R k =
parent->getDaug( iG )->getP4(); // 4-momentum of photon in the B-rest frame
EvtVector4R q = p - k; // transition 4-momentum q=p-k in the B-rest frame
EvtVector4R p_1; // 4-momentum of ell^+ in the B-rest frame
EvtVector4R p_2; // 4-momentum of ell^- in the B-rest frame
// the preparation of the leptonic 4-momentums in the B-rest frame
if ( charge1 > charge2 ) {
p_1 = parent->getDaug( il1 )->getP4();
p_2 = parent->getDaug( il2 )->getP4();
} else {
p_1 = parent->getDaug( il2 )->getP4();
p_2 = parent->getDaug( il1 )->getP4();
}
EvtVector4R p_minus_p_1 =
p - p_1; // transition momentum of the B-meson and antilepton p-p_1
EvtVector4R p_minus_p_2 =
p - p_2; // transition momentum of the B-meson and lepton p-p_2
double q2 = q.mass2(); // Mandelstam variable s=q^2
double p2 = p.mass2(); // p^2=M1^2
double t = p_minus_p_1.mass2(); // Mandelstam variable t=(p-p_1)^2
double u = p_minus_p_2.mass2(); // Mandelstam variable u=(p-p_2)^2
// scalar products
double pk = 0.5 * ( p2 - q2 ); // (p*k)
double p1k = 0.5 * ( pow( ml, 2.0 ) - u ); // (p1*k)
double p2k = 0.5 * ( pow( ml, 2.0 ) - t ); // (p2*k)
double hatq2 = q2 / ( M1 * M1 ); // \hat s = q^2/M_1^2
double Egam = 0.5 * M1 *
( 1 - hatq2 ); // photon energy in the B-meson rest frame
EvtVector4R hatp = p / M1;
EvtVector4R hatk = k / M1;
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n\n The function EvtbsTollGammaAmp::CalcAmp(...)"
// << "\n q = p-k =" << p-k << " q^2 = " << (p-k).mass2()
// << "\n q = p1+p2 =" << p_1+p_2 << " q^2 = " << (p_1+p_2).mass2()
// << "\n m_ell =" << parent->getDaug(il1)->mass()
// << "\n m_ell =" << parent->getDaug(il2)->mass()
// << "\n m_gamma =" << parent->getDaug(iG)->mass()
// << std::endl;
EvtId idparent = parent->getId(); // B-meson Id
if ( idparent == EvtPDL::getId( std::string( "B_s0" ) ) ||
idparent == EvtPDL::getId( std::string( "anti-B_s0" ) ) ) {
mq = formFactors->getQuarkMass( 3 ); // m_s mass from the dispersion QM
fb = 0.24; // leptonic decay constant
// V_{ts}
Vtq = unit1 * ( 1.0 - 0.5 * pow( CKM_lambda, 2.0 ) ) +
pow( CKM_lambda, 2.0 ) *
( CKM_barrho * unit1 + CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) );
Vtq = -CKM_A * pow( CKM_lambda, 2.0 ) * Vtq;
// V_{us}
Vuq = CKM_lambda * unit1;
// V_{cs}
Vcq = unit1 - 0.5 * pow( CKM_lambda, 2.0 ) -
0.125 * pow( CKM_lambda, 4.0 ) * ( 1.0 + 4.0 * pow( CKM_A, 2.0 ) );
}
if ( idparent == EvtPDL::getId( std::string( "B0" ) ) ||
idparent == EvtPDL::getId( std::string( "anti-B0" ) ) ) {
mq = formFactors->getQuarkMass( 2 ); // m_d mass from the dispersion QM
fb = 0.20; // leptonic decay constant
// V_{td}
Vtq = unit1 - ( 1.0 - 0.5 * pow( CKM_lambda, 2.0 ) ) *
( CKM_barrho * unit1 + CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) );
Vtq = CKM_A * pow( CKM_lambda, 3.0 ) * Vtq;
// V_{ud}
Vuq = unit1 * ( 1.0 - 0.5 * pow( CKM_lambda, 2.0 ) -
0.125 * pow( CKM_lambda, 4.0 ) );
// V_{cd}
Vcq = unit1 *
( -CKM_lambda +
0.5 * pow( CKM_A, 2.0 ) * pow( CKM_lambda, 5.0 ) *
( 1.0 - 2.0 * ( CKM_barrho * unit1 + CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) ) ) );
}
if ( mq < 0.001 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function EvtbsTollGammaAmp::CalcAmp(..// 4-momentum of ell^+.)"
<< "\n Error in the model set!"
<< " mq = " << mq << std::endl;
::abort();
}
Vtb = unit1 * ( 1.0 - 0.5 * pow( CKM_A * CKM_lambda * CKM_lambda,
2.0 ) ); // V_{tb}
Vub = CKM_A * pow( CKM_lambda, 3.0 ) *
( CKM_barrho * unit1 - CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) ); // V_{ub}
Vcb = unit1 * CKM_A * pow( CKM_lambda, 2.0 ); // V_{cb}
CKM_factor = conj( Vtq ) * Vtb; // V^*_{tq}*V_{tb}
lambda_qu = conj( Vuq ) * Vub /
CKM_factor; // V^*_{uq}*V_{ub}/V^*_{tq}*V_{tb}
Relambda_qu = real( lambda_qu );
Imlambda_qu = imag( lambda_qu );
lambda_qc = conj( Vcq ) * Vcb /
CKM_factor; // V^*_{cq}*V_{cb}/V^*_{tq}*V_{tb}
// The Wilson Coefficients preparation according to the paper
// A.J.Buras, M.Munz, Phys.Rev.D52, p.189 (1995)
double c1, c2;
EvtComplex a1, c7gam, c9eff_b2q, c9eff_barb2barq, c10a;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min || ( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ) {
c1 = 0.0;
c2 = 0.0;
a1 = unit1 * 0.0;
c7gam = unit1 * 0.0;
c9eff_b2q = unit1 * 0.0;
c9eff_barb2barq = unit1 * 0.0;
c10a = unit1 * 0.0;
} else {
c1 = WilsCoeff->C1( mu, Mw, Nf, ias );
c2 = WilsCoeff->C2( mu, Mw, Nf, ias );
a1 = unit1 * ( c1 + c2 / 3.0 );
c7gam = WilsCoeff->GetC7Eff( mu, Mw, mt, Nf, ias );
c9eff_b2q = WilsCoeff->GetC9Eff( 0, res_swch, ias, Nf, q2, mb, mq, mc, mu,
mt, Mw, ml, Relambda_qu, Imlambda_qu );
c9eff_barb2barq = WilsCoeff->GetC9Eff( 1, res_swch, ias, Nf, q2, mb, mq,
mc, mu, mt, Mw, ml, Relambda_qu,
Imlambda_qu );
c10a = WilsCoeff->GetC10Eff( mt, Mw );
}
EvtComplex Fv,
Fa; // The change of the sign is included in the amplitudes definition!
EvtComplex Ftv_b2q, Ftv_barb2barq;
EvtComplex Fta_b2q, Fta_barb2barq;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min || ( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ) {
fb = 0.0;
Fa = unit1 * 0.0;
Fv = unit1 * 0.0;
Fta_b2q = unit1 * 0.0;
Fta_barb2barq = unit1 * 0.0;
Ftv_b2q = unit1 * 0.0;
Ftv_barb2barq = unit1 * 0.0;
} else {
if ( fb < 0.01 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function EvtbsTollGammaAmp::CalcAmp(...)"
<< "\n Leptonic decay constant fb is not uninitialized in this function!"
<< " fb = " << fb << std::endl;
::abort();
}
// For \bar B^0_q -> l^+ l^- gamma
formFactors->getPhotonFF( 0, fb, parent->getId(), q2, M1, mb, mq, c7gam,
a1, lambda_qu, lambda_qc, Fv, Fa, Ftv_b2q,
Fta_b2q );
// For B^0_q -> l^+ l^- gamma
formFactors->getPhotonFF( 1, fb, parent->getId(), q2, M1, mb, mq, c7gam,
a1, lambda_qu, lambda_qc, Fv, Fa,
Ftv_barb2barq, Fta_barb2barq );
}
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n ============================================================================"
// << "\n ============================================================================"
// << "\n\n The function Evtbs2llGammaAmp::CalcAmp(...) passed."
// << "\n Particle masses:"
// << "\n B - meson mass M1 = " << M1
// << "\n photon minimum E = " << Egamma_min
// << "\n q2 = " << q2
// << "\n leptonic mass ml = " << ml
// << "\n light quark mass = " << mq
// << "\n c - quark mass mc = " << mc
// << "\n b - quark mass mb = " << mb
// << "\n t - quark mass mt = " << mt
// << "\n W - boson mass Mw = " << Mw
// << "\n ============================================================================"
// << "\n Input parameters:"
// << "\n scale parameter mu = " << mu
// << "\n number of flavors Nf = " << Nf
// << "\n resonant switching = " << res_swch
// << "\n parameter for alpha_s(M_Z) = " << ias
// << "\n photon energy cut (GeV) = " << Egamma_min
// << "\n ============================================================================"
// << "\n Form-factors"
// << "\n Egam = " << Egam
// << "\n Egamma_min = " << Egamma_min
// << "\n Fv = " << Fv
// << "\n Fa = " << Fa
// << "\n Ftv_b2q = " << Ftv_b2q
// << "\n Fta_b2q = " << Fta_b2q
// << "\n Ftv_barb2barq = " << Ftv_barb2barq
// << "\n Fta_barb2barq = " << Fta_barb2barq
// << "\n ============================================================================"
// << "\n Wilson Coefficients:"
// << "\n Egam = " << Egam
// << "\n Egamma_min = " << Egamma_min
// << "\n Re(c7gam) = " << real(c7gam)
// << " Im(c7gam) = " << imag(c7gam)
// << "\n Re(c9eff_b2q) = " << real(c9eff_b2q)
// << " Im(c9eff_b2q) = " << imag(c9eff_b2q)
// << "\n Re(c9eff_barb2barq) = " << real(c9eff_barb2barq)
// << " Im(c9eff_barb2barq) = " << imag(c9eff_barb2barq)
// << "\n Re(c10a) = " << real(c10a)
// << " Im(c10a) = " << imag(c10a)
// << std::endl;
// Hadronic matrix element coefficients
EvtComplex a_b2q, a_barb2barq, b_b2q, b_barb2barq, e_b2q, e_barb2barq,
f_b2q, f_barb2barq;
EvtComplex brammS, brammT;
a_b2q = c9eff_b2q * Fv + 2.0 * c7gam * Ftv_b2q * mb * M1 / q2;
a_barb2barq = c9eff_barb2barq * Fv +
2.0 * c7gam * Ftv_barb2barq * mb * M1 / q2;
b_b2q = ( c9eff_b2q * Fa + 2.0 * c7gam * Fta_b2q * mb * M1 / q2 ) * pk /
( M1 * M1 );
b_barb2barq = ( c9eff_barb2barq * Fa +
2.0 * c7gam * Fta_barb2barq * mb * M1 / q2 ) *
pk / ( M1 * M1 );
e_b2q = c10a * Fv;
e_barb2barq = e_b2q;
f_b2q = c10a * Fa * pk / ( M1 * M1 );
f_barb2barq = f_b2q;
brammS = 0.0; // in the Bq-meson rest frame!
brammT = 0.5 * c10a * ml * fb *
( 1.0 / p2k + 1.0 / p1k ); // for Bramsstrahlung
EvtTensor4C T1, T2; // hadronic matrix element tensor structures
EvtVector4C E1, E2;
EvtComplex E3;
int i; // photon polarisations counter
EvtVector4C lvc11, lvc12; // spin structures for
EvtVector4C lvc21, lvc22; // the leptonic vector current
EvtVector4C lac11, lac12; // spin structures for
EvtVector4C lac21, lac22; // the leptonic axial current
EvtComplex lsc11, lsc12; // spin structures for
EvtComplex lsc21, lsc22; // the leptonic scalar current
EvtTensor4C ltc11, ltc12; // spin structures for
EvtTensor4C ltc21, ltc22; // the leptonic tensor current
// B - and barB - mesons descriptors
static const EvtIdSet bmesons{ "anti-B0", "anti-B_s0" };
static const EvtIdSet bbarmesons{ "B0", "B_s0" };
EvtId parentID = parent->getId();
if ( bmesons.contains( parentID ) ) {
// The amplitude for the decay barB -> gamma ell^+ ell^- or
// b \bar q -> gamma ell^+ ell^-
T1 = -a_b2q * unit1 * dual( EvtGenFunctions::directProd( hatp, hatk ) ) -
b_b2q * uniti * EvtTensor4C::g();
T2 = -e_b2q * unit1 * dual( EvtGenFunctions::directProd( hatp, hatk ) ) -
f_b2q * uniti * EvtTensor4C::g();
// spin combinations for vector lepton current
lvc11 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lvc21 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lvc12 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lvc22 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lac11 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lac21 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lac12 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lac22 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lsc11 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lsc21 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lsc12 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lsc22 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
// \epsilon^{\alpha\beta\mu\nu}*TCurrent_{\mu\nu}
ltc11 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) ) );
ltc21 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) ) );
ltc12 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) ) );
ltc22 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) ) );
// summing up photon polarisations
for ( i = 0; i < 2; i++ ) {
// conjaction of epsG (photon polarization vector)
EvtVector4C epsG = parent->getDaug( 0 )->epsParentPhoton( i ).conj();
// de-escalation T with epsG
E1 = T1.cont2( epsG );
E2 = T2.cont2( epsG );
E3 = ( epsG * hatp ) * brammS;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min ||
( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ) {
CKM_factor = 0.0 * unit1;
}
// 1
amp.vertex( i, 0, 0,
CKM_factor *
( lvc11 * E1 + lac11 * E2 + uniti * lsc11 * E3 +
uniti * ( ( ltc11.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 1" << CKM_factor*(lvc11*E1+lac11*E2+uniti*lsc11*E3+uniti*((ltc11.cont2(hatp))*epsG)*brammT)
// << std::endl;
// 2
amp.vertex( i, 0, 1,
CKM_factor *
( lvc12 * E1 + lac12 * E2 + uniti * lsc12 * E3 +
uniti * ( ( ltc12.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 2" << CKM_factor*(lvc12*E1+lac12*E2+uniti*lsc12*E3+uniti*((ltc12.cont2(hatp))*epsG)*brammT)
// << std::endl;
// 3
amp.vertex( i, 1, 0,
CKM_factor *
( lvc21 * E1 + lac21 * E2 + uniti * lsc21 * E3 +
uniti * ( ( ltc21.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 3" << CKM_factor*(lvc21*E1+lac21*E2+uniti*lsc21*E3+uniti*((ltc21.cont2(hatp))*epsG)*brammT)
// << std::endl;
// 4
amp.vertex( i, 1, 1,
CKM_factor *
( lvc22 * E1 + lac22 * E2 + uniti * lsc22 * E3 +
uniti * ( ( ltc22.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 4" << CKM_factor*(lvc22*E1+lac22*E2+uniti*lsc22*E3+uniti*((ltc22.cont2(hatp))*epsG)*brammT)
// << std::endl;
}
} else {
if ( bbarmesons.contains( parentID ) ) {
// The amplitude for the decay B -> gamma ell^+ ell^- or
// q bar b -> gamma ell^+ ell^-
T1 = -a_barb2barq * unit1 *
dual( EvtGenFunctions::directProd( hatp, hatk ) ) +
b_barb2barq * uniti * EvtTensor4C::g();
T2 = -e_barb2barq * unit1 *
dual( EvtGenFunctions::directProd( hatp, hatk ) ) +
f_barb2barq * uniti * EvtTensor4C::g();
lvc11 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lvc21 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lvc12 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lvc22 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lac11 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lac21 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lac12 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lac22 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lsc11 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lsc21 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lsc12 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lsc22 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
// \epsilon^{\alpha\beta\mu\nu}*TCurrent_{\mu\nu}
ltc11 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) ) );
ltc21 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) ) );
ltc12 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) ) );
ltc22 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) ) );
// summing up photon polarisations
for ( i = 0; i < 2; i++ ) {
EvtVector4C barepsG = parent->getDaug( 0 )->epsParentPhoton( i );
E1 = T1.cont2( barepsG );
E2 = T2.cont2( barepsG );
E3 = ( barepsG * hatp ) * brammS;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min ||
( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ) {
CKM_factor = 0.0 * unit1;
}
amp.vertex( i, 1, 1,
conj( CKM_factor ) *
( lvc11 * E1 + lac11 * E2 +
uniti * lsc11 * E3 + // -?
uniti * ( ( ltc11.cont2( hatp ) ) * barepsG ) *
brammT ) );
amp.vertex( i, 1, 0,
conj( CKM_factor ) *
( lvc12 * E1 + lac12 * E2 +
uniti * lsc12 * E3 + // -?
uniti * ( ( ltc12.cont2( hatp ) ) * barepsG ) *
brammT ) );
amp.vertex( i, 0, 1,
conj( CKM_factor ) *
( lvc21 * E1 + lac21 * E2 +
uniti * lsc21 * E3 + // -?
uniti * ( ( ltc21.cont2( hatp ) ) * barepsG ) *
brammT ) );
amp.vertex( i, 0, 0,
conj( CKM_factor ) *
( lvc22 * E1 + lac22 * E2 +
uniti * lsc22 * E3 + // -?
uniti * ( ( ltc22.cont2( hatp ) ) * barepsG ) *
brammT ) );
}
} else {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function Evtbs2llGammaAmp::CalcAmp(...)"
<< "\n Wrong B-meson number" << std::endl;
::abort();
}
}
}
//
// The decays B -> Gamma ell^+ ell^- maximum probability calculation for the
// d^2\Gamma/dq^2 d\cos\theta distribution.
//
// \theta - the angle between the photon and ell^- directions in the
// B-meson rest frame.
//
// If ias=0 (nonresonant case), the maximum is achieved at q2
// B0s: q2 = 4*ml^2, Mphi^2, q_max^2;
// B0d: q2 = 4*ml^2, Mrho^2, Momega^2, q_max^2;
// If ias=1 (resonant case), the maximum in the same points, because the
// resonat area is remove
//
double Evtbs2llGammaAmp::CalcMaxProb( EvtId parnum, EvtId photnum, EvtId l1num,
EvtId l2num, Evtbs2llGammaFF* formFactors,
EvtbTosllWilsCoeffNLO* WilsCoeff,
double mu, int Nf, int res_swch, int ias,
double Egamma_min, double CKM_A,
double CKM_lambda, double CKM_barrho,
double CKM_bareta )
{
double maxfoundprob = -100.0; // maximum of the probability
// int ijk_atmax = 1000000;
double M1 = EvtPDL::getMeanMass( parnum ); // B - meson mass
double ml = EvtPDL::getMeanMass( l1num ); // leptonic mass
double Mrho = EvtPDL::getMeanMass(
EvtPDL::getId( std::string( "rho0" ) ) ); // mass of the rho-meson, MeV
double Momega = EvtPDL::getMeanMass( EvtPDL::getId(
std::string( "omega" ) ) ); // mass of the omega-meson, MeV
double Mphi = EvtPDL::getMeanMass(
EvtPDL::getId( std::string( "phi" ) ) ); // mass of the phi-meson, MeV
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n M1 = " << M1
// << "\n ml = " << ml
// << "\n Mrho = " << Mrho
// << "\n Momega = " << Momega
// << "\n Mphi = " << Mphi
// << "\n Egamma_min = " << Egamma_min
// << std::endl;
double list_of_max_q2_points[5];
list_of_max_q2_points[0] = pow( 2.0 * ml, 2.0 );
list_of_max_q2_points[1] = pow( Mrho, 2.0 );
list_of_max_q2_points[2] = pow( Momega, 2.0 );
list_of_max_q2_points[3] = pow( Mphi, 2.0 );
list_of_max_q2_points[4] =
pow( M1, 2.0 ) - 2.0 * M1 * Egamma_min; // q^2_max at photon energy cut
// if(list_of_max_points[4]<0){
// EvtGenReport(EVTGEN_ERROR,"EvtGen")
// << "\n\n In the function EvtbsTollGammaAmp::CalcScalarMaxProb(...)"
// << "\n Bad photon energy cut: Egamma_min > M1 in the rest frame of B-meson!"
// << "\n q2_max = " << list_of_max_points[4]
// << "\n M1 = " << M1
// << "\n Egamma_min = " << Egamma_min
// << std::endl;
// ::abort();
// }
if ( Egamma_min > Mrho ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollGammaAmp::CalcScalarMaxProb(...)"
<< "\n Bad photon energy cut: Egamma_min > M_rho0 in the rest frame of B-meson."
<< "\n Mrho = " << Mrho << "\n Egamma_min = " << Egamma_min
<< std::endl;
::abort();
}
if ( Egamma_min <= 0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollGammaAmp::CalcScalarMaxProb(...)"
<< "\n Bad photon energy cut: Egamma_min <= 0 in the rest frame of B-meson."
<< "\n Egamma_min = " << Egamma_min << std::endl;
::abort();
}
if ( res_swch == 0 || res_swch == 1 ) {
int i_list;
for ( i_list = 0; i_list <= 4; i_list++ ) {
double s; // mandelstam variable "s";
double t_minus; // minimum and maximum of the mandelstam variable "t"
double t_plus; // as function of the mandelstam variable "s=q2";
double t_for_s;
int ijk; // counter for variable "t";
int max_ijk; // maximal value of this counter;
s = list_of_max_q2_points[i_list];
t_plus = pow( M1, 2.0 ) + 2.0 * pow( ml, 2.0 ) - s;
t_plus = t_plus + sqrt( 1.0 - 4.0 * pow( ml, 2.0 ) / s ) *
( pow( M1, 2.0 ) - s );
t_plus *= 0.5;
t_minus = pow( M1, 2.0 ) + 2.0 * pow( ml, 2.0 ) - s;
t_minus = t_minus - sqrt( 1.0 - 4.0 * pow( ml, 2.0 ) / s ) *
( pow( M1, 2.0 ) - s );
t_minus *= 0.5;
if ( fabs( t_plus - t_minus ) < 0.000001 )
t_minus = t_plus;
max_ijk = 1000;
double dt = ( t_plus - t_minus ) / ( (double)max_ijk );
if ( fabs( dt ) < 0.00001 )
dt = 0.0;
if ( dt < 0.0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollGammaAmp::CalcScalarMaxProb(...)"
<< "\n dt = " << dt << " < 0."
<< "\n s = " << s << "\n t_plus = " << t_plus
<< "\n t_minus = " << t_minus << "\n M1 = " << M1
<< "\n ml = " << ml << std::endl;
::abort();
}
for ( ijk = 0; ijk <= max_ijk; ijk++ ) {
t_for_s = t_minus + dt * ( (double)ijk );
// B-meson rest frame particles and they kinematics inicialization
double Eg, El2;
Eg = ( pow( M1, 2.0 ) - s ) / ( 2.0 * M1 ); // photon energy
El2 = ( s + t_for_s - pow( ml, 2.0 ) ) /
( 2.0 * M1 ); // ell^- energy
double modl2;
modl2 = sqrt( pow( El2, 2.0 ) - pow( ml, 2.0 ) );
double cosBellminus; // angle between the B-meson and ell^- directions
cosBellminus = ( pow( ml, 2.0 ) + 2.0 * Eg * El2 - t_for_s ) /
( 2.0 * Eg * modl2 );
if ( ( fabs( cosBellminus ) > 1.0 ) &&
( fabs( cosBellminus ) <= 1.0001 ) ) {
EvtGenReport( EVTGEN_NOTICE, "EvtGen" )
<< "\n Debug in the function EvtbsTollGammaAmp::CalcMaxProb(...):"
<< "\n cos(theta) = " << cosBellminus << std::endl;
cosBellminus = cosBellminus / fabs( cosBellminus );
}
if ( fabs( cosBellminus ) > 1.0001 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollGammaAmp::CalcMaxProb(...)"
<< "\n |cos(theta)| = " << fabs( cosBellminus ) << " > 1"
<< "\n s = " << s << "\n t_for_s = " << t_for_s
<< "\n t_plus = " << t_plus << "\n t_minus = " << t_minus
<< "\n dt = " << dt << "\n Eg = " << Eg
<< "\n El2 = " << El2 << "\n modl2 = " << modl2
<< "\n ml = " << ml << std::endl;
::abort();
}
EvtVector4R p, k, p1, p2;
p.set( M1, 0.0, 0.0, 0.0 );
k.set( Eg, Eg, 0.0, 0.0 );
p2.set( El2, modl2 * cosBellminus,
-modl2 * sqrt( 1.0 - pow( cosBellminus, 2.0 ) ), 0.0 );
p1 = p - k - p2;
// B-meson state preparation at the rest frame of B-meson
EvtScalarParticle* scalar_part;
EvtParticle* root_part;
scalar_part = new EvtScalarParticle;
scalar_part->noLifeTime();
scalar_part->init( parnum, p );
root_part = (EvtParticle*)scalar_part;
root_part->setDiagonalSpinDensity();
// Amplitude initialization
EvtId listdaug[3];
listdaug[0] = photnum;
listdaug[1] = l1num;
listdaug[2] = l2num;
EvtAmp amp;
amp.init( parnum, 3, listdaug );
// Daughters states preparation at the rest frame of B-meson
root_part->makeDaughters( 3, listdaug );
EvtParticle *gamm, *lep1, *lep2;
gamm = root_part->getDaug( 0 );
lep1 = root_part->getDaug( 1 );
lep2 = root_part->getDaug( 2 );
gamm->noLifeTime();
lep1->noLifeTime();
lep2->noLifeTime();
gamm->init( photnum, k );
lep1->init( l1num, p1 );
lep2->init( l2num, p2 );
EvtSpinDensity rho;
rho.setDiag( root_part->getSpinStates() );
// The amplitude calculation at the
// "maximum amplitude" kinematical configuration
CalcAmp( root_part, amp, formFactors, WilsCoeff, mu, Nf,
res_swch, ias, Egamma_min, CKM_A, CKM_lambda,
CKM_barrho, CKM_bareta );
// Now find the probability at this q2 and cos theta lepton point
double nikmax = rho.normalizedProb( amp.getSpinDensity() );
if ( nikmax > maxfoundprob ) {
maxfoundprob = nikmax;
EvtGenReport( EVTGEN_NOTICE, "EvtGen" )
<< "\n maxfoundprob ( s =" << s << ", t = " << t_for_s
<< " ) = " << maxfoundprob << "\n ijk =" << ijk
<< std::endl;
}
delete scalar_part;
// delete root_part;
delete gamm;
delete lep1;
delete lep2;
} // for(ijk=0; ijk<=max_ijk; ijk++)
} // i_list - variable loop
} // if(res_swch==0||res_swch==1)
else {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollVectorAmpNew::CalcMaxProb(...)"
<< "\n Unexpected value of the variable res_swch !!!"
<< "\n res_swch = " << res_swch << std::endl;
::abort();
}
if ( maxfoundprob <= 0.0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollVectorAmpNew::CalcMaxProb(...)"
<< "\n maxfoundprob = " << maxfoundprob << " <0 or =0!"
<< "\n res_swch = " << res_swch << std::endl;
::abort();
}
maxfoundprob *= 1.01;
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n **********************************************************************"
// << "\n The function Evtbs2llGammaAmp::CalcMaxProb(...) passed with arguments:"
// << "\n mu =" << mu << " Nf =" << Nf
// << " res_swch =" << res_swch
// << " ias =" << ias
// << "\n CKM_A = " << CKM_A
// << " CKM_lambda = " << CKM_lambda
// << "\n CKM_barrho = " << CKM_barrho
// << " CKM_bareta = " << CKM_bareta
// << "\n The distribution maximum maxfoundprob =" << maxfoundprob
// << "\n ijk = " << ijk_atmax
// << "\n **********************************************************************"
// << std::endl;
return maxfoundprob;
}
// Triangular function
double Evtbs2llGammaAmp::lambda( double a, double b, double c )
{
double l;
l = pow( a, 2.0 ) + pow( b, 2.0 ) + pow( c, 2.0 ) - 2.0 * a * b -
2.0 * a * c - 2.0 * b * c;
return l;
}
diff --git a/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp b/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp
index ec336a8..ce0b42d 100644
--- a/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp
+++ b/src/EvtGenModels/Evtbs2llGammaISRFSRAmp.cpp
@@ -1,896 +1,896 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "EvtGenModels/Evtbs2llGammaISRFSRAmp.hh"
#include "EvtGenBase/EvtAmp.hh"
#include "EvtGenBase/EvtComplex.hh"
#include "EvtGenBase/EvtDiracSpinor.hh"
#include "EvtGenBase/EvtGenKine.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtIdSet.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtReport.hh"
#include "EvtGenBase/EvtScalarParticle.hh"
#include "EvtGenBase/EvtTensor4C.hh"
#include "EvtGenBase/EvtVector4C.hh"
#include "EvtGenBase/EvtVectorParticle.hh"
#include "EvtGenModels/EvtbTosllWilsCoeffNLO.hh"
#include "EvtGenModels/Evtbs2llGammaFFMNT.hh"
#include <cstdlib>
// input: *parent - the pointer to the parent particle (B-meson, the
// object of the EvtParticle class);
// *formFactors - the pointer to instance of EvtbTosllGammaFF class object;
// *WilsCoeff - the pointer to the Standart Model Wilson Coefficients class;
// mu - the scale parameter, GeV;
// Nf - number of "effective" flavors (for b-quark Nf=5);
// sr - state radiation type:
// = 0 the ISR only,
// = 1 the FSR only,
// = 2 both ISR + FSR (== BSTOGLLMNT model);
// res_swch - resonant switching parameter:
// = 0 the resonant contribution switched OFF,
// = 1 the resonant contribution switched ON;
// ias - switching parameter for \alpha_s(M_Z) value:
// = 0 PDG 1sigma minimal alpha_s(M_Z),
// = 1 PDG average value alpha_s(M_Z),
// = 2 PDG 1sigma maximal alpha_s(M_Z).
// Egamma_min - photon energy cut, GeV;
// Wolfenstein parameterization for CKM matrix
// CKM_A, CKM_lambda, CKM_barrho, CKM_bareta
void Evtbs2llGammaISRFSRAmp::CalcAmp( EvtParticle* parent, EvtAmp& amp,
Evtbs2llGammaFF* formFactors,
EvtbTosllWilsCoeffNLO* WilsCoeff,
double mu, int Nf, int sr, int res_swch,
int ias, double Egamma_min, double CKM_A,
double CKM_lambda, double CKM_barrho,
double CKM_bareta, double mumumass_min )
{
// FILE *mytest;
int iG = 0; // photon is the first daughter particle
int il1 = 1,
il2 = 2; // leptons are the second and thirds daughter particles
EvtComplex unit1( 1.0, 0.0 ); // real unit
EvtComplex uniti( 0.0, 1.0 ); // imaginary unit
double M1 = parent->mass(); // B - meson mass, GeV
double ml = parent->getDaug( il1 )->mass(); // leptonic mass, GeV
double mq = 0.0; // light quark mass from the dispersion QM, GeV
double mc = formFactors->getQuarkMass(
4 ); // m_c mass from the dispersion QM, GeV
double mb = formFactors->getQuarkMass(
5 ); // m_b mass from the dispersion QM, GeV
double Mw = 80.403; // GeV W-boson mass, GeV
double mt = 174.2; // GeV t-quark mass, GeV
double fb = 0.0; // leptonic decay constant of B-meson, Gev
EvtComplex Vtb, Vtq, Vub, Vuq, Vcb,
Vcq; // V_{tb}, V_{tq}, V_{ub}, V_{uq}, V_{cb}, V_{cq}
EvtComplex CKM_factor; // V^*_{tq}*V_{tb}, where q={d,s}
EvtComplex lambda_qu; // V^*_{uq}*V_{ub}/V^*_{tq}*V_{tb}, where q={d,s}
EvtComplex lambda_qc; // V^*_{cq}*V_{cb}/V^*_{tq}*V_{tb}, where q={d,s}
double Relambda_qu, Imlambda_qu;
// to find charges of ell^+ and ell^- in the B-meson daughters
int charge1 = EvtPDL::chg3( parent->getDaug( il1 )->getId() );
int charge2 = EvtPDL::chg3( parent->getDaug( il2 )->getId() );
if ( charge1 == 0 || charge2 == 0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function EvtbsTollGammaAmp::CalcAmp(...)"
<< "\n Error in the leptonic charge getting!"
<< "\n charge1 =" << charge1
<< "\n charge2 =" << charge2 << "\n charge gamma ="
<< EvtPDL::chg3( parent->getDaug( iG )->getId() )
<< "\n number of daughters =" << parent->getNDaug() << std::endl;
::abort();
}
EvtParticle* lepPlus = nullptr;
EvtParticle* lepMinus = nullptr;
lepPlus = ( charge1 > charge2 )
- ? parent->getDaug( il1 )
- : parent->getDaug( il2 ); // positive charged
+ ? parent->getDaug( il1 )
+ : parent->getDaug( il2 ); // positive charged
lepMinus = ( charge1 < charge2 )
- ? parent->getDaug( il1 )
- : parent->getDaug( il2 ); // negative charged
+ ? parent->getDaug( il1 )
+ : parent->getDaug( il2 ); // negative charged
EvtVector4R p = parent->getP4Restframe(); // B-meson momentum in the B-rest frame
EvtVector4R k =
parent->getDaug( iG )->getP4(); // 4-momentum of photon in the B-rest frame
EvtVector4R q = p - k; // transition 4-momentum q=p-k in the B-rest frame
EvtVector4R p_1; // 4-momentum of ell^+ in the B-rest frame
EvtVector4R p_2; // 4-momentum of ell^- in the B-rest frame
// the preparation of the leptonic 4-momentums in the B-rest frame
if ( charge1 > charge2 ) {
p_1 = parent->getDaug( il1 )->getP4();
p_2 = parent->getDaug( il2 )->getP4();
} else {
p_1 = parent->getDaug( il2 )->getP4();
p_2 = parent->getDaug( il1 )->getP4();
}
EvtVector4R p_minus_p_1 =
p - p_1; // transition momentum of the B-meson and antilepton p-p_1
EvtVector4R p_minus_p_2 =
p - p_2; // transition momentum of the B-meson and lepton p-p_2
double q2 = q.mass2(); // Mandelstam variable s=q^2
double p2 = p.mass2(); // p^2=M1^2
double t = p_minus_p_1.mass2(); // Mandelstam variable t=(p-p_1)^2
double u = p_minus_p_2.mass2(); // Mandelstam variable u=(p-p_2)^2
// scalar products
double pk = 0.5 * ( p2 - q2 ); // (p*k)
double p1k = 0.5 * ( pow( ml, 2.0 ) - u ); // (p1*k)
double p2k = 0.5 * ( pow( ml, 2.0 ) - t ); // (p2*k)
double hatq2 = q2 / ( M1 * M1 ); // \hat s = q^2/M_1^2
double Egam = 0.5 * M1 *
( 1 - hatq2 ); // photon energy in the B-meson rest frame
EvtVector4R hatp = p / M1;
EvtVector4R hatk = k / M1;
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n\n The function EvtbsTollGammaISRFSRAmp::CalcAmp(...)"
// << "\n q = p-k =" << p-k << " q^2 = " << (p-k).mass2()
// << "\n q = p1+p2 =" << p_1+p_2 << " q^2 = " << (p_1+p_2).mass2()
// << "\n m_ell =" << parent->getDaug(il1)->mass()
// << "\n m_ell =" << parent->getDaug(il2)->mass()
// << "\n m_gamma =" << parent->getDaug(iG)->mass()
// << std::endl;
EvtId idparent = parent->getId(); // B-meson Id
if ( idparent == EvtPDL::getId( std::string( "B_s0" ) ) ||
idparent == EvtPDL::getId( std::string( "anti-B_s0" ) ) ) {
mq = formFactors->getQuarkMass( 3 ); // m_s mass from the dispersion QM
fb = 0.24; // leptonic decay constant
// V_{ts}
Vtq = unit1 * ( 1.0 - 0.5 * pow( CKM_lambda, 2.0 ) ) +
pow( CKM_lambda, 2.0 ) *
( CKM_barrho * unit1 + CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) );
Vtq = -CKM_A * pow( CKM_lambda, 2.0 ) * Vtq;
// V_{us}
Vuq = CKM_lambda * unit1;
// V_{cs}
Vcq = unit1 - 0.5 * pow( CKM_lambda, 2.0 ) -
0.125 * pow( CKM_lambda, 4.0 ) * ( 1.0 + 4.0 * pow( CKM_A, 2.0 ) );
}
if ( idparent == EvtPDL::getId( std::string( "B0" ) ) ||
idparent == EvtPDL::getId( std::string( "anti-B0" ) ) ) {
mq = formFactors->getQuarkMass( 2 ); // m_d mass from the dispersion QM
fb = 0.20; // leptonic decay constant
// V_{td}
Vtq = unit1 - ( 1.0 - 0.5 * pow( CKM_lambda, 2.0 ) ) *
( CKM_barrho * unit1 + CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) );
Vtq = CKM_A * pow( CKM_lambda, 3.0 ) * Vtq;
// V_{ud}
Vuq = unit1 * ( 1.0 - 0.5 * pow( CKM_lambda, 2.0 ) -
0.125 * pow( CKM_lambda, 4.0 ) );
// V_{cd}
Vcq = unit1 *
( -CKM_lambda +
0.5 * pow( CKM_A, 2.0 ) * pow( CKM_lambda, 5.0 ) *
( 1.0 - 2.0 * ( CKM_barrho * unit1 + CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) ) ) );
}
if ( mq < 0.001 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function EvtbsTollGammaISRFSRAmp::CalcAmp(..// 4-momentum of ell^+.)"
<< "\n Error in the model set!"
<< " mq = " << mq << std::endl;
::abort();
}
Vtb = unit1 * ( 1.0 - 0.5 * pow( CKM_A * CKM_lambda * CKM_lambda,
2.0 ) ); // V_{tb}
Vub = CKM_A * pow( CKM_lambda, 3.0 ) *
( CKM_barrho * unit1 - CKM_bareta * uniti ) /
sqrt( 1.0 - pow( CKM_lambda, 2.0 ) ); // V_{ub}
Vcb = unit1 * CKM_A * pow( CKM_lambda, 2.0 ); // V_{cb}
CKM_factor = conj( Vtq ) * Vtb; // V^*_{tq}*V_{tb}
lambda_qu = conj( Vuq ) * Vub /
CKM_factor; // V^*_{uq}*V_{ub}/V^*_{tq}*V_{tb}
Relambda_qu = real( lambda_qu );
Imlambda_qu = imag( lambda_qu );
lambda_qc = conj( Vcq ) * Vcb /
CKM_factor; // V^*_{cq}*V_{cb}/V^*_{tq}*V_{tb}
// The Wilson Coefficients preparation according to the paper
// A.J.Buras, M.Munz, Phys.Rev.D52, p.189 (1995)
double c1, c2;
EvtComplex a1, c7gam, c9eff_b2q, c9eff_barb2barq, c10a;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min || ( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ||
( q2 <= mumumass_min * mumumass_min ) ) {
c1 = 0.0;
c2 = 0.0;
a1 = unit1 * 0.0;
c7gam = unit1 * 0.0;
c9eff_b2q = unit1 * 0.0;
c9eff_barb2barq = unit1 * 0.0;
c10a = unit1 * 0.0;
} else {
c1 = WilsCoeff->C1( mu, Mw, Nf, ias );
c2 = WilsCoeff->C2( mu, Mw, Nf, ias );
a1 = unit1 * ( c1 + c2 / 3.0 );
c7gam = WilsCoeff->GetC7Eff( mu, Mw, mt, Nf, ias );
c9eff_b2q = WilsCoeff->GetC9Eff( 0, res_swch, ias, Nf, q2, mb, mq, mc, mu,
mt, Mw, ml, Relambda_qu, Imlambda_qu );
c9eff_barb2barq = WilsCoeff->GetC9Eff( 1, res_swch, ias, Nf, q2, mb, mq,
mc, mu, mt, Mw, ml, Relambda_qu,
Imlambda_qu );
c10a = WilsCoeff->GetC10Eff( mt, Mw );
}
EvtComplex Fv,
Fa; // The change of the sign is included in the amplitudes definition!
EvtComplex Ftv_b2q, Ftv_barb2barq;
EvtComplex Fta_b2q, Fta_barb2barq;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min || ( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ||
( q2 <= mumumass_min * mumumass_min ) ) {
fb = 0.0;
Fa = unit1 * 0.0;
Fv = unit1 * 0.0;
Fta_b2q = unit1 * 0.0;
Fta_barb2barq = unit1 * 0.0;
Ftv_b2q = unit1 * 0.0;
Ftv_barb2barq = unit1 * 0.0;
} else {
if ( fb < 0.01 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function EvtbsTollGammaISRFSRAmp::CalcAmp(...)"
<< "\n Leptonic decay constant fb is not uninitialized in this function!"
<< " fb = " << fb << std::endl;
::abort();
}
// For \bar B^0_q -> l^+ l^- gamma
formFactors->getPhotonFF( 0, fb, parent->getId(), q2, M1, mb, mq, c7gam,
a1, lambda_qu, lambda_qc, Fv, Fa, Ftv_b2q,
Fta_b2q );
// For B^0_q -> l^+ l^- gamma
formFactors->getPhotonFF( 1, fb, parent->getId(), q2, M1, mb, mq, c7gam,
a1, lambda_qu, lambda_qc, Fv, Fa,
Ftv_barb2barq, Fta_barb2barq );
}
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n ============================================================================"
// << "\n ============================================================================"
// << "\n\n The function Evtbs2llGammaISRFSRAmp::CalcAmp(...) passed."
// << "\n Particle masses:"
// << "\n B - meson mass M1 = " << M1
// << "\n photon minimum E = " << Egamma_min
// << "\n q2 = " << q2
// << "\n leptonic mass ml = " << ml
// << "\n light quark mass = " << mq
// << "\n c - quark mass mc = " << mc
// << "\n b - quark mass mb = " << mb
// << "\n t - quark mass mt = " << mt
// << "\n W - boson mass Mw = " << Mw
// << "\n ============================================================================"
// << "\n Input parameters:"
// << "\n scale parameter mu = " << mu
// << "\n number of flavors Nf = " << Nf
// << "\n state radiation switching = " << sr
// << "\n resonant switching = " << res_swch
// << "\n parameter for alpha_s(M_Z) = " << ias
// << "\n photon energy cut (GeV) = " << Egamma_min
// << "\n ============================================================================"
// << "\n Form-factors"
// << "\n Egam = " << Egam
// << "\n Egamma_min = " << Egamma_min
// << "\n Fv = " << Fv
// << "\n Fa = " << Fa
// << "\n Ftv_b2q = " << Ftv_b2q
// << "\n Fta_b2q = " << Fta_b2q
// << "\n Ftv_barb2barq = " << Ftv_barb2barq
// << "\n Fta_barb2barq = " << Fta_barb2barq
// << "\n ============================================================================"
// << "\n Wilson Coefficients:"
// << "\n Egam = " << Egam
// << "\n Egamma_min = " << Egamma_min
// << "\n Re(c7gam) = " << real(c7gam)
// << " Im(c7gam) = " << imag(c7gam)
// << "\n Re(c9eff_b2q) = " << real(c9eff_b2q)
// << " Im(c9eff_b2q) = " << imag(c9eff_b2q)
// << "\n Re(c9eff_barb2barq) = " << real(c9eff_barb2barq)
// << " Im(c9eff_barb2barq) = " << imag(c9eff_barb2barq)
// << "\n Re(c10a) = " << real(c10a)
// << " Im(c10a) = " << imag(c10a)
// << std::endl;
// Hadronic matrix element coefficients
EvtComplex a_b2q, a_barb2barq, b_b2q, b_barb2barq, e_b2q, e_barb2barq,
f_b2q, f_barb2barq;
EvtComplex brammS, brammT;
a_b2q = c9eff_b2q * Fv + 2.0 * c7gam * Ftv_b2q * mb * M1 / q2;
a_barb2barq = c9eff_barb2barq * Fv +
2.0 * c7gam * Ftv_barb2barq * mb * M1 / q2;
b_b2q = ( c9eff_b2q * Fa + 2.0 * c7gam * Fta_b2q * mb * M1 / q2 ) * pk /
( M1 * M1 );
b_barb2barq = ( c9eff_barb2barq * Fa +
2.0 * c7gam * Fta_barb2barq * mb * M1 / q2 ) *
pk / ( M1 * M1 );
e_b2q = c10a * Fv;
e_barb2barq = e_b2q;
f_b2q = c10a * Fa * pk / ( M1 * M1 );
f_barb2barq = f_b2q;
brammS = 0.0; // in the Bq-meson rest frame!
brammT = 0.5 * c10a * ml * fb *
( 1.0 / p2k + 1.0 / p1k ); // for Bramsstrahlung
// The separation of the ISR and FSR contributions
if ( sr == 0 ) { // ISR only
brammS = 0.0;
brammT = 0.0;
}
if ( sr == 1 ) { // FSR only
a_b2q = 0.0;
a_barb2barq = 0.0;
b_b2q = 0.0;
b_barb2barq = 0.0;
e_b2q = 0.0;
e_barb2barq = 0.0;
f_b2q = 0.0;
f_barb2barq = 0.0;
}
EvtTensor4C T1, T2; // hadronic matrix element tensor structures
EvtVector4C E1, E2;
EvtComplex E3;
int i; // photon polarisations counter
EvtVector4C lvc11, lvc12; // spin structures for
EvtVector4C lvc21, lvc22; // the leptonic vector current
EvtVector4C lac11, lac12; // spin structures for
EvtVector4C lac21, lac22; // the leptonic axial current
EvtComplex lsc11, lsc12; // spin structures for
EvtComplex lsc21, lsc22; // the leptonic scalar current
EvtTensor4C ltc11, ltc12; // spin structures for
EvtTensor4C ltc21, ltc22; // the leptonic tensor current
// B - and barB - mesons descriptors
static const EvtIdSet bmesons{ "anti-B0", "anti-B_s0" };
static const EvtIdSet bbarmesons{ "B0", "B_s0" };
EvtId parentID = parent->getId();
if ( bmesons.contains( parentID ) ) {
// The amplitude for the decay barB -> gamma ell^+ ell^- or
// b \bar q -> gamma ell^+ ell^-
T1 = -a_b2q * unit1 * dual( EvtGenFunctions::directProd( hatp, hatk ) ) -
b_b2q * uniti * EvtTensor4C::g();
T2 = -e_b2q * unit1 * dual( EvtGenFunctions::directProd( hatp, hatk ) ) -
f_b2q * uniti * EvtTensor4C::g();
// spin combinations for vector lepton current
lvc11 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lvc21 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lvc12 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lvc22 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lac11 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lac21 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lac12 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lac22 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lsc11 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lsc21 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lsc12 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lsc22 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
// \epsilon^{\alpha\beta\mu\nu}*TCurrent_{\mu\nu}
ltc11 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) ) );
ltc21 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) ) );
ltc12 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) ) );
ltc22 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) ) );
// summing up photon polarisations
for ( i = 0; i < 2; i++ ) {
// conjaction of epsG (photon polarization vector)
EvtVector4C epsG = parent->getDaug( 0 )->epsParentPhoton( i ).conj();
// de-escalation T with epsG
E1 = T1.cont2( epsG );
E2 = T2.cont2( epsG );
E3 = ( epsG * hatp ) * brammS;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min ||
( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ||
( q2 <= mumumass_min * mumumass_min ) ) {
CKM_factor = 0.0 * unit1;
}
// 1
amp.vertex( i, 0, 0,
CKM_factor *
( lvc11 * E1 + lac11 * E2 + uniti * lsc11 * E3 +
uniti * ( ( ltc11.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 1" << CKM_factor*(lvc11*E1+lac11*E2+uniti*lsc11*E3+uniti*((ltc11.cont2(hatp))*epsG)*brammT)
// << std::endl;
// 2
amp.vertex( i, 0, 1,
CKM_factor *
( lvc12 * E1 + lac12 * E2 + uniti * lsc12 * E3 +
uniti * ( ( ltc12.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 2" << CKM_factor*(lvc12*E1+lac12*E2+uniti*lsc12*E3+uniti*((ltc12.cont2(hatp))*epsG)*brammT)
// << std::endl;
// 3
amp.vertex( i, 1, 0,
CKM_factor *
( lvc21 * E1 + lac21 * E2 + uniti * lsc21 * E3 +
uniti * ( ( ltc21.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 3" << CKM_factor*(lvc21*E1+lac21*E2+uniti*lsc21*E3+uniti*((ltc21.cont2(hatp))*epsG)*brammT)
// << std::endl;
// 4
amp.vertex( i, 1, 1,
CKM_factor *
( lvc22 * E1 + lac22 * E2 + uniti * lsc22 * E3 +
uniti * ( ( ltc22.cont2( hatp ) ) * epsG ) *
brammT ) );
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n 4" << CKM_factor*(lvc22*E1+lac22*E2+uniti*lsc22*E3+uniti*((ltc22.cont2(hatp))*epsG)*brammT)
// << std::endl;
}
} else {
if ( bbarmesons.contains( parentID ) ) {
// The amplitude for the decay B -> gamma ell^+ ell^- or
// q bar b -> gamma ell^+ ell^-
T1 = -a_barb2barq * unit1 *
dual( EvtGenFunctions::directProd( hatp, hatk ) ) +
b_barb2barq * uniti * EvtTensor4C::g();
T2 = -e_barb2barq * unit1 *
dual( EvtGenFunctions::directProd( hatp, hatk ) ) +
f_barb2barq * uniti * EvtTensor4C::g();
lvc11 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lvc21 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lvc12 = EvtLeptonVCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lvc22 = EvtLeptonVCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lac11 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lac21 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lac12 = EvtLeptonACurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lac22 = EvtLeptonACurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
lsc11 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) );
lsc21 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) );
lsc12 = EvtLeptonSCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) );
lsc22 = EvtLeptonSCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) );
// \epsilon^{\alpha\beta\mu\nu}*TCurrent_{\mu\nu}
ltc11 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 1 ) ) );
ltc21 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 1 ) ) );
ltc12 = dual( EvtLeptonTCurrent( lepPlus->spParent( 1 ),
lepMinus->spParent( 0 ) ) );
ltc22 = dual( EvtLeptonTCurrent( lepPlus->spParent( 0 ),
lepMinus->spParent( 0 ) ) );
// summing up photon polarisations
for ( i = 0; i < 2; i++ ) {
EvtVector4C barepsG = parent->getDaug( 0 )->epsParentPhoton( i );
E1 = T1.cont2( barepsG );
E2 = T2.cont2( barepsG );
E3 = ( barepsG * hatp ) * brammS;
// foton energy cut and removal of the J/psi amd psi' resonant area
if ( Egam < Egamma_min ||
( res_swch == 1 && q2 >= 9.199 && q2 <= 15.333 ) ||
( q2 <= mumumass_min * mumumass_min ) ) {
CKM_factor = 0.0 * unit1;
}
amp.vertex( i, 1, 1,
conj( CKM_factor ) *
( lvc11 * E1 + lac11 * E2 +
uniti * lsc11 * E3 + // -?
uniti * ( ( ltc11.cont2( hatp ) ) * barepsG ) *
brammT ) );
amp.vertex( i, 1, 0,
conj( CKM_factor ) *
( lvc12 * E1 + lac12 * E2 +
uniti * lsc12 * E3 + // -?
uniti * ( ( ltc12.cont2( hatp ) ) * barepsG ) *
brammT ) );
amp.vertex( i, 0, 1,
conj( CKM_factor ) *
( lvc21 * E1 + lac21 * E2 +
uniti * lsc21 * E3 + // -?
uniti * ( ( ltc21.cont2( hatp ) ) * barepsG ) *
brammT ) );
amp.vertex( i, 0, 0,
conj( CKM_factor ) *
( lvc22 * E1 + lac22 * E2 +
uniti * lsc22 * E3 + // -?
uniti * ( ( ltc22.cont2( hatp ) ) * barepsG ) *
brammT ) );
}
} else {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n The function Evtbs2llGammaISRFSRAmp::CalcAmp(...)"
<< "\n Wrong B-meson number" << std::endl;
::abort();
}
}
}
//
// The decays B -> Gamma ell^+ ell^- maximum probability calculation for the
// d^2\Gamma/dq^2 d\cos\theta distribution.
//
// \theta - the angle between the photon and ell^- directions in the
// B-meson rest frame.
//
// If ias=0 (nonresonant case), the maximum is achieved at q2
// B0s: q2 = 4*ml^2, Mphi^2, q_max^2;
// B0d: q2 = 4*ml^2, Mrho^2, Momega^2, q_max^2;
// If ias=1 (resonant case), the maximum in the same points, because the
// resonat area is remove
//
double Evtbs2llGammaISRFSRAmp::CalcMaxProb(
EvtId parnum, EvtId photnum, EvtId l1num, EvtId l2num,
Evtbs2llGammaFF* formFactors, EvtbTosllWilsCoeffNLO* WilsCoeff, double mu,
int Nf, int sr, int res_swch, int ias, double Egamma_min, double CKM_A,
double CKM_lambda, double CKM_barrho, double CKM_bareta, double mumumass_min )
{
double maxfoundprob = -100.0; // maximum of the probability
double M1 = EvtPDL::getMeanMass( parnum ); // B - meson mass
double ml = EvtPDL::getMeanMass( l1num ); // leptonic mass
double Mrho = EvtPDL::getMeanMass(
EvtPDL::getId( std::string( "rho0" ) ) ); // mass of the rho-meson, MeV
double Momega = EvtPDL::getMeanMass( EvtPDL::getId(
std::string( "omega" ) ) ); // mass of the omega-meson, MeV
double Mphi = EvtPDL::getMeanMass(
EvtPDL::getId( std::string( "phi" ) ) ); // mass of the phi-meson, MeV
// EvtGenReport(EVTGEN_NOTICE,"EvtGen")
// << "\n M1 = " << M1
// << "\n ml = " << ml
// << "\n Mrho = " << Mrho
// << "\n Momega = " << Momega
// << "\n Mphi = " << Mphi
// << "\n Egamma_min = " << Egamma_min
// << std::endl;
double list_of_max_q2_points[5];
list_of_max_q2_points[0] = pow( 2.0 * ml, 2.0 );
list_of_max_q2_points[1] = pow( Mrho, 2.0 );
list_of_max_q2_points[2] = pow( Momega, 2.0 );
list_of_max_q2_points[3] = pow( Mphi, 2.0 );
list_of_max_q2_points[4] =
pow( M1, 2.0 ) - 2.0 * M1 * Egamma_min; // q^2_max at photon energy cut
// if(list_of_max_points[4]<0){
// EvtGenReport(EVTGEN_ERROR,"EvtGen")
// << "\n\n In the function EvtbsTollGammaAmp::CalcScalarMaxProb(...)"
// << "\n Bad photon energy cut: Egamma_min > M1 in the rest frame of B-meson!"
// << "\n q2_max = " << list_of_max_points[4]
// << "\n M1 = " << M1
// << "\n Egamma_min = " << Egamma_min
// << std::endl;
// ::abort();
// }
if ( Egamma_min > Mrho ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function Evtbs2llGammaISRFSRAmp::CalcMaxProb(...)"
<< "\n Bad photon energy cut: Egamma_min > M_rho0 in the rest frame of B-meson."
<< "\n Mrho = " << Mrho << "\n Egamma_min = " << Egamma_min
<< std::endl;
::abort();
}
if ( Egamma_min <= 0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function Evtbs2llGammaISRFSRAmp::CalcMaxProb(...)"
<< "\n Bad photon energy cut: Egamma_min <= 0 in the rest frame of B-meson."
<< "\n Egamma_min = " << Egamma_min << std::endl;
::abort();
}
if ( res_swch == 0 || res_swch == 1 ) {
int i_list;
for ( i_list = 0; i_list <= 4; i_list++ ) {
double s; // mandelstam variable "s";
double t_minus; // minimum and maximum of the mandelstam variable "t"
double t_plus; // as function of the mandelstam variable "s=q2";
double t_for_s;
int ijk; // counter for variable "t";
int max_ijk; // maximal value of this counter;
s = list_of_max_q2_points[i_list];
t_plus = pow( M1, 2.0 ) + 2.0 * pow( ml, 2.0 ) - s;
t_plus = t_plus + sqrt( 1.0 - 4.0 * pow( ml, 2.0 ) / s ) *
( pow( M1, 2.0 ) - s );
t_plus *= 0.5;
t_minus = pow( M1, 2.0 ) + 2.0 * pow( ml, 2.0 ) - s;
t_minus = t_minus - sqrt( 1.0 - 4.0 * pow( ml, 2.0 ) / s ) *
( pow( M1, 2.0 ) - s );
t_minus *= 0.5;
if ( fabs( t_plus - t_minus ) < 0.000001 )
t_minus = t_plus;
max_ijk = 1000;
double dt = ( t_plus - t_minus ) / ( (double)max_ijk );
if ( fabs( dt ) < 0.00001 )
dt = 0.0;
if ( dt < 0.0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollGammaISRFSRAmp::CalcScalarMaxProb(...)"
<< "\n dt = " << dt << " < 0."
<< "\n s = " << s << "\n t_plus = " << t_plus
<< "\n t_minus = " << t_minus << "\n M1 = " << M1
<< "\n ml = " << ml << std::endl;
::abort();
}
for ( ijk = 0; ijk <= max_ijk; ijk++ ) {
t_for_s = t_minus + dt * ( (double)ijk );
// B-meson rest frame particles and they kinematics inicialization
double Eg, El2;
Eg = ( pow( M1, 2.0 ) - s ) / ( 2.0 * M1 ); // photon energy
El2 = ( s + t_for_s - pow( ml, 2.0 ) ) /
( 2.0 * M1 ); // ell^- energy
double modl2;
modl2 = sqrt( pow( El2, 2.0 ) - pow( ml, 2.0 ) );
double cosBellminus; // angle between the B-meson and ell^- directions
cosBellminus = ( pow( ml, 2.0 ) + 2.0 * Eg * El2 - t_for_s ) /
( 2.0 * Eg * modl2 );
if ( ( fabs( cosBellminus ) > 1.0 ) &&
( fabs( cosBellminus ) <= 1.0001 ) ) {
EvtGenReport( EVTGEN_NOTICE, "EvtGen" )
<< "\n Debug in the function EvtbsTollGammaISRFSRAmp::CalcMaxProb(...):"
<< "\n cos(theta) = " << cosBellminus << std::endl;
cosBellminus = cosBellminus / fabs( cosBellminus );
}
if ( fabs( cosBellminus ) > 1.0001 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function EvtbsTollGammaISRFSRAmp::CalcMaxProb(...)"
<< "\n |cos(theta)| = " << fabs( cosBellminus ) << " > 1"
<< "\n s = " << s << "\n t_for_s = " << t_for_s
<< "\n t_plus = " << t_plus << "\n t_minus = " << t_minus
<< "\n dt = " << dt << "\n Eg = " << Eg
<< "\n El2 = " << El2 << "\n modl2 = " << modl2
<< "\n ml = " << ml << std::endl;
::abort();
}
EvtVector4R p, k, p1, p2;
p.set( M1, 0.0, 0.0, 0.0 );
k.set( Eg, Eg, 0.0, 0.0 );
p2.set( El2, modl2 * cosBellminus,
-modl2 * sqrt( 1.0 - pow( cosBellminus, 2.0 ) ), 0.0 );
p1 = p - k - p2;
// B-meson state preparation at the rest frame of B-meson
EvtScalarParticle* scalar_part;
EvtParticle* root_part;
scalar_part = new EvtScalarParticle;
scalar_part->noLifeTime();
scalar_part->init( parnum, p );
root_part = (EvtParticle*)scalar_part;
root_part->setDiagonalSpinDensity();
// Amplitude initialization
EvtId listdaug[3];
listdaug[0] = photnum;
listdaug[1] = l1num;
listdaug[2] = l2num;
EvtAmp amp;
amp.init( parnum, 3, listdaug );
// Daughters states preparation at the rest frame of B-meson
root_part->makeDaughters( 3, listdaug );
EvtParticle *gamm, *lep1, *lep2;
gamm = root_part->getDaug( 0 );
lep1 = root_part->getDaug( 1 );
lep2 = root_part->getDaug( 2 );
gamm->noLifeTime();
lep1->noLifeTime();
lep2->noLifeTime();
gamm->init( photnum, k );
lep1->init( l1num, p1 );
lep2->init( l2num, p2 );
EvtSpinDensity rho;
rho.setDiag( root_part->getSpinStates() );
// The amplitude calculation at the
// "maximum amplitude" kinematical configuration
CalcAmp( root_part, amp, formFactors, WilsCoeff, mu, Nf, sr,
res_swch, ias, Egamma_min, CKM_A, CKM_lambda,
CKM_barrho, CKM_bareta, mumumass_min );
// Now find the probability at this q2 and cos theta lepton point
double nikmax = rho.normalizedProb( amp.getSpinDensity() );
if ( nikmax > maxfoundprob ) {
double maxfoundprob_old;
maxfoundprob_old = maxfoundprob;
maxfoundprob = nikmax;
EvtGenReport( EVTGEN_NOTICE, "EvtGen" )
<< "\n maxfoundprob ( s =" << s << ", t = " << t_for_s
<< " ) = " << maxfoundprob
<< "\n maxfoundprob_old = " << maxfoundprob_old
<< "\n ijk =" << ijk << std::endl;
}
delete scalar_part;
// delete root_part;
delete gamm;
delete lep1;
delete lep2;
} // for(ijk=0; ijk<=max_ijk; ijk++)
} // i_list - variable loop
} // if(res_swch==0||res_swch==1)
else {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function Evtbs2llGammaISRFSRAmp::CalcMaxProb(...)"
<< "\n Unexpected value of the variable res_swch !!!"
<< "\n res_swch = " << res_swch << std::endl;
::abort();
}
if ( maxfoundprob < 0.0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function Evtbs2llGammaISRFSRAmp::CalcMaxProb(...)"
<< "\n maxfoundprob = " << maxfoundprob << " <0 or =0!"
<< "\n mu =" << mu << " Nf =" << Nf << "\n sr =" << sr
<< " res_swch =" << res_swch << " ias =" << ias
<< "\n Egamma_min =" << Egamma_min << "\n CKM_A = " << CKM_A
<< " CKM_lambda = " << CKM_lambda << "\n CKM_barrho = " << CKM_barrho
<< " CKM_bareta = " << CKM_bareta << std::endl;
::abort();
}
if ( maxfoundprob == 0.0 ) {
EvtGenReport( EVTGEN_ERROR, "EvtGen" )
<< "\n\n In the function Evtbs2llGammaISRFSRAmp::CalcMaxProb(...)"
<< "\n maxfoundprob = " << maxfoundprob << " <0 or =0!"
<< "\n mu =" << mu << " Nf =" << Nf << "\n sr =" << sr
<< " res_swch =" << res_swch << " ias =" << ias
<< "\n Egamma_min =" << Egamma_min << "\n CKM_A = " << CKM_A
<< " CKM_lambda = " << CKM_lambda << "\n CKM_barrho = " << CKM_barrho
<< " CKM_bareta = " << CKM_bareta << std::endl;
maxfoundprob = 0.00000001;
}
maxfoundprob *= 1.01;
EvtGenReport( EVTGEN_NOTICE, "EvtGen" )
<< "\n **********************************************************************"
<< "\n The function Evtbs2llGammaISRFSRAmp::CalcMaxProb(...) passed with arguments:"
<< "\n mu =" << mu << " Nf =" << Nf << "\n sr =" << sr
<< " res_swch =" << res_swch << " ias =" << ias
<< "\n CKM_A = " << CKM_A << " CKM_lambda = " << CKM_lambda
<< "\n Egamma_min =" << Egamma_min << "\n CKM_barrho = " << CKM_barrho
<< " CKM_bareta = " << CKM_bareta
<< "\n The distribution maximum maxfoundprob =" << maxfoundprob
<< "\n **********************************************************************"
<< std::endl;
return maxfoundprob;
}
// Triangular function
double Evtbs2llGammaISRFSRAmp::lambda( double a, double b, double c )
{
double l;
l = pow( a, 2.0 ) + pow( b, 2.0 ) + pow( c, 2.0 ) - 2.0 * a * b -
2.0 * a * c - 2.0 * b * c;
return l;
}
diff --git a/test/testDecayModel.cc b/test/testDecayModel.cc
index 933ae7f..bdd4749 100644
--- a/test/testDecayModel.cc
+++ b/test/testDecayModel.cc
@@ -1,1829 +1,1830 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#include "testDecayModel.hh"
#include "EvtGen/EvtGen.hh"
#include "EvtGenBase/EvtAbsRadCorr.hh"
#include "EvtGenBase/EvtConst.hh"
#include "EvtGenBase/EvtDecayBase.hh"
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtKine.hh"
#include "EvtGenBase/EvtMTRandomEngine.hh"
#include "EvtGenBase/EvtPDL.hh"
#include "EvtGenBase/EvtParticle.hh"
#include "EvtGenBase/EvtParticleFactory.hh"
#include "EvtGenBase/EvtRandom.hh"
#include "EvtGenBase/EvtVector4R.hh"
#ifdef EVTGEN_EXTERNAL
#include "EvtGenExternal/EvtExternalGenList.hh"
#endif
#include "TROOT.h"
#include "tbb/tbb.h"
#include <chrono>
#include <fstream>
#include <future>
#include <iostream>
#include <list>
#include <memory>
using nlohmann::json;
std::once_flag TestDecayModel::m_createDecFile_threadlock;
TestHistos::TestHistos( const std::string& parentName, const json& config )
{
// Histogram information
const std::size_t nHistos{ config.size() };
m_1DhistVect.reserve( nHistos );
m_2DhistVect.reserve( nHistos );
for ( const auto& hInfo : config ) {
const auto varTitle{ hInfo.at( "title" ).get<std::string>() };
const auto varName{ hInfo.at( "variable" ).get<std::string>() };
// Integer values that define what particles need to be used
// for invariant mass combinations or helicity angles etc
const auto d1{ hInfo.at( "d1" ).get<int>() };
const auto d2{ hInfo.at( "d2" ).get<int>() };
const auto nBins{ hInfo.at( "nbins" ).get<int>() };
const auto xmin{ hInfo.at( "xmin" ).get<double>() };
const auto xmax{ hInfo.at( "xmax" ).get<double>() };
std::string histName( varName.c_str() );
if ( d1 != 0 ) {
histName += "_";
histName += std::to_string( d1 );
}
if ( d2 != 0 ) {
histName += "_";
histName += std::to_string( d2 );
}
if ( !hInfo.contains( "variableY" ) ) {
auto hist = std::make_unique<TH1D>( histName.c_str(),
varTitle.c_str(), nBins, xmin,
xmax );
m_1DhistVect.emplace_back(
std::make_pair( HistInfo{ varName, d1, d2 }, std::move( hist ) ) );
} else {
const auto varNameY{ hInfo.at( "variableY" ).get<std::string>() };
const auto d1Y{ hInfo.at( "d1Y" ).get<int>() };
const auto d2Y{ hInfo.at( "d2Y" ).get<int>() };
const auto nBinsY{ hInfo.at( "nbinsY" ).get<int>() };
const auto ymin{ hInfo.at( "ymin" ).get<double>() };
const auto ymax{ hInfo.at( "ymax" ).get<double>() };
histName += "_";
histName += varNameY;
if ( d1Y != 0 ) {
histName += "_";
histName += std::to_string( d1Y );
}
if ( d2Y != 0 ) {
histName += "_";
histName += std::to_string( d2Y );
}
auto hist = std::make_unique<TH2D>( histName.c_str(),
varTitle.c_str(), nBins, xmin,
xmax, nBinsY, ymin, ymax );
m_2DhistVect.emplace_back(
std::make_pair( HistInfo{ varName, d1, d2, varNameY, d1Y, d2Y },
std::move( hist ) ) );
}
}
// Add a mixed/unmixed histogram
// Useful for the case where the parent is a neutral K, D or B
const std::array<std::string, 14> parentsThatMix{
"B_s0", "anti-B_s0", "B_s0L", "B_s0H", "B0", "anti-B0", "B0L",
"B0H", "D0", "anti-D0", "K0", "anti-K0", "K_S0", "K_L0" };
if ( std::find( parentsThatMix.begin(), parentsThatMix.end(), parentName ) !=
parentsThatMix.end() ) {
const std::string varTitle{ parentName + " mixed" };
m_mixedHist = std::make_unique<TH1D>( "mixed", varTitle.c_str(), 2, 0.0,
2.0 );
// TODO maybe set bin labels?
}
}
TestHistos::TestHistos( const TestHistos& rhs )
{
m_1DhistVect.reserve( rhs.m_1DhistVect.size() );
for ( auto& [info, hist] : rhs.m_1DhistVect ) {
auto newHist = std::unique_ptr<TH1>{ static_cast<TH1*>( hist->Clone() ) };
m_1DhistVect.push_back( std::make_pair( info, std::move( newHist ) ) );
}
m_2DhistVect.reserve( rhs.m_2DhistVect.size() );
for ( auto& [info, hist] : rhs.m_2DhistVect ) {
auto newHist = std::unique_ptr<TH2>{ static_cast<TH2*>( hist->Clone() ) };
m_2DhistVect.push_back( std::make_pair( info, std::move( newHist ) ) );
}
if ( rhs.m_mixedHist ) {
m_mixedHist.reset( static_cast<TH1*>( rhs.m_mixedHist->Clone() ) );
}
}
TestHistos::TestHistos( TestHistos&& rhs ) noexcept
{
this->swap( rhs );
}
TestHistos& TestHistos::operator=( const TestHistos& rhs )
{
TestHistos tmp{ rhs };
this->swap( tmp );
return *this;
}
TestHistos& TestHistos::operator=( TestHistos&& rhs ) noexcept
{
this->swap( rhs );
return *this;
}
void TestHistos::swap( TestHistos& rhs ) noexcept
{
m_1DhistVect.swap( rhs.m_1DhistVect );
m_2DhistVect.swap( rhs.m_2DhistVect );
std::swap( m_mixedHist, rhs.m_mixedHist );
}
void TestHistos::add( const TestHistos& rhs )
{
// handle the special case where we have been default constructed and the rhs has not
if ( m_1DhistVect.empty() && m_2DhistVect.empty() && !m_mixedHist ) {
( *this ) = rhs;
return;
}
// TODO - should really check that the sets of histograms are the same between left and right
const std::size_t n1DHists{ rhs.m_1DhistVect.size() };
for ( std::size_t i{ 0 }; i < n1DHists; ++i ) {
m_1DhistVect[i].second->Add( rhs.m_1DhistVect[i].second.get() );
}
const std::size_t n2DHists{ rhs.m_2DhistVect.size() };
for ( std::size_t i{ 0 }; i < n2DHists; ++i ) {
m_2DhistVect[i].second->Add( rhs.m_2DhistVect[i].second.get() );
}
if ( m_mixedHist && rhs.m_mixedHist ) {
m_mixedHist->Add( rhs.m_mixedHist.get() );
}
}
void TestHistos::normalise()
{
for ( auto& [_, hist] : m_1DhistVect ) {
const double area{ hist->Integral() };
if ( area > 0.0 ) {
hist->Scale( 1.0 / area );
}
}
for ( auto& [_, hist] : m_2DhistVect ) {
const double area{ hist->Integral() };
if ( area > 0.0 ) {
hist->Scale( 1.0 / area );
}
}
if ( m_mixedHist ) {
const double area{ m_mixedHist->Integral() };
if ( area > 0.0 ) {
m_mixedHist->Scale( 1.0 / area );
}
}
}
void TestHistos::save( TFile* outputFile )
{
outputFile->cd();
for ( auto& [info, hist] : m_1DhistVect ) {
hist->SetDirectory( outputFile );
hist->Write();
hist.release();
}
for ( auto& [info, hist] : m_2DhistVect ) {
hist->SetDirectory( outputFile );
hist->Write();
hist.release();
}
if ( m_mixedHist ) {
m_mixedHist->SetDirectory( outputFile );
m_mixedHist->Write();
m_mixedHist.release();
}
}
TestDecayModel::TestDecayModel( const json& config ) :
m_config{ checkMandatoryFields( config )
? readConfig( config )
: throw std::runtime_error{
"ERROR : json does not contain all required fields" } }
{
}
bool TestDecayModel::checkMandatoryFields( const json& config )
{
const std::array<std::string, 7> mandatoryFields{ "parent", "daughters",
"models", "parameters",
"outfile", "events",
"histograms" };
const std::array<std::string, 7> mandatoryHistoFields{
"title", "variable", "d1", "d2", "nbins", "xmin", "xmax" };
const std::array<std::string, 6> extra2DHistoFields{ "variableY", "d1Y",
"d2Y", "nbinsY",
"ymin", "ymax" };
bool allMandatoryFields{ true };
for ( const auto& field : mandatoryFields ) {
if ( !config.contains( field ) ) {
std::cerr << "ERROR : json does not contain required field: " << field
<< std::endl;
allMandatoryFields = false;
continue;
}
if ( field == "histograms" ) {
const json& jHistos{ config.at( "histograms" ) };
for ( const auto& hInfo : jHistos ) {
for ( const auto& hField : mandatoryHistoFields ) {
if ( !hInfo.contains( hField ) ) {
std::cerr
<< "ERROR : json does not contain required field for histogram definition: "
<< hField << std::endl;
allMandatoryFields = false;
}
}
if ( hInfo.contains( extra2DHistoFields[0] ) ) {
for ( const auto& hField : extra2DHistoFields ) {
if ( !hInfo.contains( hField ) ) {
std::cerr
<< "ERROR : json does not contain required field for 2D histogram definition: "
<< hField << std::endl;
allMandatoryFields = false;
}
}
}
}
}
}
return allMandatoryFields;
}
TestConfig TestDecayModel::readConfig( const json& config )
{
TestConfig cfg;
// Get all the mandatory fields first
cfg.parentName = config.at( "parent" ).get<std::string>();
cfg.daughterNames = config.at( "daughters" ).get<std::vector<std::string>>();
cfg.modelNames = config.at( "models" ).get<std::vector<std::string>>();
cfg.modelParameters =
config.at( "parameters" ).get<std::vector<std::vector<std::string>>>();
cfg.nEvents = config.at( "events" ).get<std::size_t>();
// Histogram information
cfg.testHistograms = TestHistos{ cfg.parentName, config.at( "histograms" ) };
// Then check for optional fields, setting default values if not present
if ( config.contains( "grand_daughters" ) &&
config.at( "grand_daughters" ).is_array() ) {
cfg.grandDaughterNames = config.at( "grand_daughters" )
.get<std::vector<std::vector<std::string>>>();
}
if ( config.contains( "extras" ) && config.at( "extras" ).is_array() ) {
cfg.extraCommands = config.at( "extras" ).get<std::vector<std::string>>();
}
// Set the number of threads to use, 1 by default
cfg.nThreads = 1;
if ( config.contains( "threads" ) ) {
cfg.nThreads = config.at( "threads" ).get<std::size_t>();
}
// Set the FSR generator. Use PHOTOS by default.
cfg.fsrGenerator = FSRGenerator::PHOTOS;
if ( config.contains( "fsr_generator" ) ) {
cfg.fsrGenerator = config.at( "fsr_generator" ).get<FSRGenerator>();
}
// Set the type of threading to use, stdlib by default
cfg.threadModel = ThreadModel::StdLib;
if ( config.contains( "thread_model" ) ) {
cfg.threadModel = config.at( "thread_model" ).get<ThreadModel>();
}
// Set the RNG seed base (defaults to zero), to which the event number is added
cfg.rngSeed = 0;
if ( config.contains( "rng_seed" ) ) {
cfg.rngSeed = config.at( "rng_seed" ).get<std::size_t>();
}
// Set reference and output file names
// Insert fsrGenerator name if FSR simulation is not deactivated
const bool noFSR = std::find( cfg.extraCommands.begin(),
cfg.extraCommands.end(),
"noFSR" ) != cfg.extraCommands.end();
const std::string fileNameEnd =
noFSR ? ".root" : "_" + to_string( cfg.fsrGenerator ) + ".root";
const auto outFileStrSize = config.at( "outfile" ).get<std::string>().size() -
5;
cfg.outFileName =
config.at( "outfile" ).get<std::string>().substr( 0, outFileStrSize ) +
fileNameEnd;
cfg.refFileName = "Ref/" + cfg.outFileName;
cfg.decFileName = cfg.outFileName.substr( 0, cfg.outFileName.size() - 5 ) +
".dec";
cfg.debugFlag = ( config.contains( "debug_flag" ) &&
config.at( "debug_flag" ).is_boolean() )
- ? config.at( "debug_flag" ).get<bool>()
- : false;
+ ? config.at( "debug_flag" ).get<bool>()
+ : false;
if ( config.contains( "do_conjugate_decay" ) &&
config.at( "do_conjugate_decay" ).is_array() ) {
cfg.doConjDecay =
config.at( "do_conjugate_decay" ).get<std::vector<bool>>();
}
if ( cfg.doConjDecay.size() != cfg.modelNames.size() ) {
cfg.doConjDecay.resize( cfg.modelNames.size(), false );
}
return cfg;
}
void TestDecayModel::run()
{
TestHistos theHistos;
const auto start{ std::chrono::steady_clock::now() };
if ( m_config.nThreads > 1 ) {
// Run multi-threaded using the specified thread model
switch ( m_config.threadModel ) {
case ThreadModel::StdLib:
theHistos = runStdThreads();
break;
case ThreadModel::TBB:
theHistos = runTBBThreads();
break;
}
} else {
// Run in the main thread
theHistos = runDecayBody( 0, m_config.nEvents );
}
const auto end{ std::chrono::steady_clock::now() };
const std::chrono::duration<double, std::milli> elapsed_ms{ ( end - start ) };
const std::chrono::duration<double, std::milli> elapsed_ms_per_event{
elapsed_ms / m_config.nEvents };
std::cout << "Took " << elapsed_ms.count() << " ms to generate "
<< m_config.nEvents << " events using " << m_config.nThreads
<< " " << to_string( m_config.threadModel ) << " threads ("
<< elapsed_ms_per_event.count() << " ms per event)" << std::endl;
// Normalise histograms.
theHistos.normalise();
// Compare with reference histograms
compareHistos( theHistos, m_config.refFileName );
// Create the root output file and write the histograms to it
// Only save the mixed/unmixed histogram for neutral K, D, B
std::unique_ptr<TFile> outFile{
TFile::Open( m_config.outFileName.c_str(), "recreate" ) };
theHistos.save( outFile.get() );
outFile->Close();
std::cout << "Created output file: " << m_config.outFileName.c_str()
<< std::endl;
}
TestHistos TestDecayModel::runStdThreads() const
{
// Determine the number of threads and the number of events per thread
const std::size_t nThreads{ std::min( m_config.nThreads, m_config.nEvents ) };
const std::size_t nEventsPerThread{ ( m_config.nEvents % nThreads )
? m_config.nEvents / nThreads + 1
: m_config.nEvents / nThreads };
// Create the store for the results from each thread
std::vector<std::future<TestHistos>> allHistos;
allHistos.reserve( nThreads );
// Launch the threads
std::size_t firstEvent{ 0 };
std::size_t nEvents{ nEventsPerThread };
for ( std::size_t iThread{ 0 }; iThread < nThreads; ++iThread ) {
// The last thread may need to generate slightly fewer events to get the required total
if ( ( firstEvent + nEvents ) >= m_config.nEvents ) {
nEvents = m_config.nEvents - firstEvent;
}
std::cout << "Thread " << iThread << " will generate " << nEvents
<< " events" << std::endl;
allHistos.emplace_back(
- std::async( std::launch::async, [this, firstEvent, nEvents]() {
- return runDecayBody( firstEvent, nEvents );
- } ) );
+ std::async( std::launch::async, [this, firstEvent, nEvents]()
+ { return runDecayBody( firstEvent, nEvents ); } ) );
firstEvent += nEvents;
}
// Now wait for each thread to finish
bool complete{ false };
do {
// Set the flag to completed and set it back if we find incomplete threads
complete = true;
for ( auto& future : allHistos ) {
auto status = future.wait_for( std::chrono::seconds( 10 ) );
if ( status != std::future_status::ready ) {
complete = false;
}
}
} while ( !complete );
// Accumulate the histograms from all threads
TestHistos theHistos{ allHistos[0].get() };
for ( std::size_t iThread{ 1 }; iThread < nThreads; ++iThread ) {
theHistos.add( allHistos[iThread].get() );
}
return theHistos;
}
TestHistos TestDecayModel::runTBBThreads() const
{
tbb::global_control gc{ tbb::global_control::parameter::max_allowed_parallelism,
m_config.nThreads };
TestHistos init;
return tbb::parallel_reduce(
tbb::blocked_range<std::size_t>( 0, m_config.nEvents ), init,
[this]( const tbb::blocked_range<std::size_t>& range,
- const TestHistos& init ) -> TestHistos {
+ const TestHistos& init ) -> TestHistos
+ {
std::cout << "Thread "
<< tbb::this_task_arena::current_thread_index()
<< " will generate " << range.size()
<< " events: " << range.begin() << " - " << range.end()
<< std::endl;
TestHistos tmp{ init };
tmp.add( runDecayBody( range.begin(), range.size() ) );
return tmp;
},
- []( const TestHistos& lhs, const TestHistos& rhs ) -> TestHistos {
+ []( const TestHistos& lhs, const TestHistos& rhs ) -> TestHistos
+ {
TestHistos tmp{ lhs };
tmp.add( rhs );
return tmp;
} );
}
TestHistos TestDecayModel::runDecayBody( const std::size_t firstEvent,
const std::size_t nEvents ) const
{
// Initialise the EvtGen object and hence the EvtPDL tables
// The EvtGen object is used by generateEvents, while the
// latter are also used within createDecFile
// Define the random number generator
static thread_local auto randomEngine{ std::make_unique<EvtMTRandomEngine>() };
// TODO - need to streamline the extra models stuff
static thread_local EvtAbsRadCorr* radCorrEngine{ nullptr };
std::list<EvtDecayBase*> extraModels;
static thread_local bool initialised{ false };
#ifdef EVTGEN_EXTERNAL
if ( !initialised ) {
bool convertPythiaCodes( false );
bool useEvtGenRandom( true );
bool seedTauolaFortran( true );
EvtExternalGenList genList( convertPythiaCodes, "", "gamma",
useEvtGenRandom, seedTauolaFortran );
switch ( m_config.fsrGenerator ) {
case FSRGenerator::PHOTOS:
radCorrEngine = genList.getPhotosModel();
break;
case FSRGenerator::SherpaPhotons1:
radCorrEngine = genList.getSherpaPhotonsModel( 1e-7, 1, 0 );
break;
case FSRGenerator::SherpaPhotons20:
radCorrEngine = genList.getSherpaPhotonsModel( 1e-7, 2, 0 );
break;
case FSRGenerator::SherpaPhotons21:
radCorrEngine = genList.getSherpaPhotonsModel( 1e-7, 2, 1 );
break;
}
extraModels = genList.getListOfModels();
}
#endif
static thread_local EvtGen theGen{ "../DECAY.DEC", "../evt.pdl",
randomEngine.get(), radCorrEngine,
&extraModels };
// Creates a decay file based on json file input
// We don't want this to be called by every thread!
std::call_once( m_createDecFile_threadlock, [this]() { createDecFile(); } );
// Read the decay file
if ( !initialised ) {
theGen.readUDecay( m_config.decFileName.c_str() );
initialised = true;
}
// Define the histograms to be saved
TestHistos theHistos{ m_config.testHistograms };
// Generate events and fill histograms
generateEvents( theGen, theHistos, firstEvent, nEvents );
return theHistos;
}
void TestDecayModel::createDecFile() const
{
// Create (or overwrite) the decay file
std::ofstream decFile{ m_config.decFileName };
// Create daughter aliases if needed
std::vector<std::string> aliasPrefix;
for ( std::size_t daughter_index{ 0 };
daughter_index < m_config.daughterNames.size(); daughter_index++ ) {
if ( !m_config.grandDaughterNames.empty() &&
!m_config.grandDaughterNames[daughter_index].empty() ) {
decFile << "Alias My" << m_config.daughterNames[daughter_index] << " "
<< m_config.daughterNames[daughter_index] << std::endl;
if ( m_config.doConjDecay[daughter_index + 1] ) {
const EvtId daugID{
EvtPDL::getId( m_config.daughterNames[daughter_index] ) };
const EvtId daugConjID{ EvtPDL::chargeConj( daugID ) };
const std::string conjName{ daugConjID.getName() };
std::string conjName_Alias{ daugConjID.getName() };
if ( std::find( std::begin( m_config.daughterNames ),
std::end( m_config.daughterNames ),
daugConjID.getName() ) !=
std::end( m_config.daughterNames ) ) {
conjName_Alias = conjName_Alias + "_" + daughter_index;
}
decFile << "Alias My" << conjName_Alias << " " << conjName
<< std::endl;
decFile << "ChargeConj My"
<< m_config.daughterNames[daughter_index] << " My"
<< conjName_Alias << std::endl;
} else if ( m_config.doConjDecay[0] ) {
decFile << "ChargeConj My"
<< m_config.daughterNames[daughter_index] << " My"
<< m_config.daughterNames[daughter_index] << std::endl;
}
aliasPrefix.push_back( "My" );
} else {
aliasPrefix.push_back( "" );
}
}
for ( const auto& iExtra : m_config.extraCommands ) {
decFile << iExtra << std::endl;
}
// Parent decay
decFile << "Decay " << m_config.parentName << std::endl;
decFile << "1.0";
for ( std::size_t daughter_index{ 0 };
daughter_index < m_config.daughterNames.size(); daughter_index++ ) {
decFile << " " << aliasPrefix[daughter_index]
<< m_config.daughterNames[daughter_index];
}
decFile << " " << m_config.modelNames[0];
for ( const auto& par : m_config.modelParameters[0] ) {
decFile << " " << par;
}
decFile << ";" << std::endl;
decFile << "Enddecay" << std::endl;
if ( m_config.doConjDecay[0] ) {
EvtId parID{ EvtPDL::getId( m_config.parentName ) };
EvtId parConjID{ EvtPDL::chargeConj( parID ) };
decFile << "CDecay " << parConjID.getName() << std::endl;
}
// Daughter decays into granddaughters
for ( std::size_t daughter_index{ 0 };
daughter_index < m_config.grandDaughterNames.size(); daughter_index++ ) {
if ( m_config.grandDaughterNames[daughter_index].empty() )
continue;
decFile << "Decay " << aliasPrefix[daughter_index]
<< m_config.daughterNames[daughter_index] << std::endl;
decFile << "1.0";
for ( std::size_t grandDaughter_index{ 0 };
grandDaughter_index <
m_config.grandDaughterNames[daughter_index].size();
grandDaughter_index++ ) {
decFile << " "
<< m_config.grandDaughterNames[daughter_index][grandDaughter_index];
}
decFile << " " << m_config.modelNames[daughter_index + 1];
for ( const auto& par : m_config.modelParameters[daughter_index + 1] ) {
decFile << " " << par;
}
decFile << ";" << std::endl;
decFile << "Enddecay" << std::endl;
if ( m_config.doConjDecay[daughter_index + 1] ) {
EvtId daugID{
EvtPDL::getId( m_config.daughterNames[daughter_index] ) };
EvtId daugConjID{ EvtPDL::chargeConj( daugID ) };
std::string conjName_Alias{ daugConjID.getName() };
if ( std::find( std::begin( m_config.daughterNames ),
std::end( m_config.daughterNames ),
daugConjID.getName() ) !=
std::end( m_config.daughterNames ) ) {
conjName_Alias = conjName_Alias + "_" + daughter_index;
}
decFile << "CDecay " << aliasPrefix[daughter_index]
<< conjName_Alias << std::endl;
}
}
decFile << "End" << std::endl;
decFile.close();
}
void TestDecayModel::generateEvents( EvtGen& theGen, TestHistos& theHistos,
const std::size_t firstEvent,
const std::size_t nEvents ) const
{
// Generate the decays
const EvtId parId{ EvtPDL::getId( m_config.parentName.c_str() ) };
const EvtId conjId{ m_config.doConjDecay[0] ? EvtPDL::chargeConj( parId )
: parId };
for ( std::size_t i{ firstEvent }; i < ( firstEvent + nEvents ); i++ ) {
if ( i % 1000 == 0 ) {
std::cout << "Event " << firstEvent + nEvents - i << std::endl;
}
// seed the RNG based on the event number
EvtRandom::setSeed( m_config.rngSeed + i );
// Initial 4-momentum and particle
EvtVector4R pInit( EvtPDL::getMass( parId ), 0.0, 0.0, 0.0 );
EvtParticle* parent{ nullptr };
if ( EvtRandom::Flat() < 0.5 ) {
parent = EvtParticleFactory::particleFactory( parId, pInit );
} else {
parent = EvtParticleFactory::particleFactory( conjId, pInit );
}
theGen.generateDecay( parent );
// Check for mixing (and fill histogram)
EvtParticle* prodParent{ nullptr };
TH1* mixedHist{ theHistos.getMixedHist() };
if ( mixedHist ) {
if ( parent->getNDaug() == 1 ) {
prodParent = parent;
parent = prodParent->getDaug( 0 );
mixedHist->Fill( 1 );
} else {
mixedHist->Fill( 0 );
}
}
// To debug
if ( m_config.debugFlag ) {
std::cout << "Parent PDG code: " << parent->getPDGId()
<< " has daughters " << parent->getNDaug() << std::endl;
for ( std::size_t iDaughter{ 0 }; iDaughter < parent->getNDaug();
iDaughter++ ) {
std::cout << "Parent PDG code of daughter " << iDaughter
<< " : " << parent->getDaug( iDaughter )->getPDGId()
<< " has daughters "
<< parent->getDaug( iDaughter )->getNDaug()
<< std::endl;
for ( std::size_t iGrandDaughter{ 0 };
iGrandDaughter < parent->getDaug( iDaughter )->getNDaug();
iGrandDaughter++ ) {
std::cout << "Parent PDG code of grand daughter "
<< iGrandDaughter << " : "
<< parent->getDaug( iDaughter )
->getDaug( iGrandDaughter )
->getPDGId()
<< " has daughters "
<< parent->getDaug( iDaughter )
->getDaug( iGrandDaughter )
->getNDaug()
<< std::endl;
}
}
}
int leadingChargedDaughter = -1;
const std::string fsrStr = "_FSRPhotons";
const std::string ewStr = "_EnergyWeight";
const std::string perDaughter = "_perDaughter";
// Store information
for ( auto& [info, hist] : theHistos.get1DHistos() ) {
if ( !hist ) {
continue;
}
const std::string varName = info.getName();
std::string reducedVarName = varName;
const std::string::size_type findFSRstr = varName.find( fsrStr );
const std::string::size_type findPerDaugStr = varName.find(
perDaughter );
// If the variable name does not have the substrings '_perDaughter' and '_FSRPhotons', then add an entry per event and continue
if ( findFSRstr == std::string::npos &&
findPerDaugStr == std::string::npos ) {
const double value{
getValue( parent, varName, info.getd1(), info.getd2() ) };
hist->Fill( value );
continue;
}
// If the variable name has the substring '_perDaughter' and does not have the substring '_FSRPhotons', then add an entry per daughter and continue
else if ( findFSRstr == std::string::npos ) {
reducedVarName.erase( findPerDaugStr, perDaughter.length() );
// Figure out whether the variable indicates to be saved for a requested particle type
const std::string::size_type findIsStr = reducedVarName.find(
"_is" );
const std::string requestedType = findIsStr == std::string::npos
- ? ""
- : reducedVarName.substr(
- findIsStr + 3 );
+ ? ""
+ : reducedVarName.substr(
+ findIsStr + 3 );
if ( !requestedType.empty() ) {
reducedVarName.erase( findIsStr,
reducedVarName.length() - findIsStr );
}
for ( int iDaug{ 0 }; iDaug < (int)parent->getNDaug(); iDaug++ ) {
const double value{
getValue( parent, reducedVarName, iDaug + 1, 0 ) };
const int partGroup = getPartGroup(
parent->getDaug( iDaug )->getPDGId() );
if ( requestedType.empty() ||
isPartType( partGroup, requestedType ) ) {
hist->Fill( value );
}
}
continue;
}
// If otherwise the variable contains the substring '_FSRPhotons', then add an entry per photon
if ( leadingChargedDaughter == -1 ) {
leadingChargedDaughter = findChargedDaughterWithMaxE( parent );
}
reducedVarName.erase( findFSRstr, fsrStr.length() );
const std::string::size_type findEwStr = reducedVarName.find( ewStr );
// If variable name has substring '_EnergyWeight' then add an entry weighted by the photon energy
bool energyWeight = false;
if ( findEwStr != std::string::npos ) {
reducedVarName.erase( findEwStr, ewStr.length() );
energyWeight = true;
}
for ( int iDaug{ 0 }; iDaug < (int)parent->getNDaug(); iDaug++ ) {
const EvtParticle* iDaughter = parent->getDaug( iDaug );
if ( iDaughter->getAttribute( "FSR" ) == 1 ) {
const double value{ getValue( parent, reducedVarName,
iDaug + 1,
leadingChargedDaughter + 1 ) };
if ( energyWeight ) {
const double photonEnergy = iDaughter->getP4().get( 0 );
hist->Fill( value, photonEnergy );
} else {
hist->Fill( value );
}
}
}
}
for ( auto& [info, hist] : theHistos.get2DHistos() ) {
if ( !hist ) {
continue;
}
const double valueX{ getValue( parent,
info.getName( HistInfo::Axis::X ),
info.getd1( HistInfo::Axis::X ),
info.getd2( HistInfo::Axis::X ) ) };
const double valueY{ getValue( parent,
info.getName( HistInfo::Axis::Y ),
info.getd1( HistInfo::Axis::Y ),
info.getd2( HistInfo::Axis::Y ) ) };
hist->Fill( valueX, valueY );
}
if ( m_config.debugFlag ) {
if ( prodParent ) {
prodParent->printTree();
} else {
parent->printTree();
}
}
// Cleanup
if ( prodParent ) {
prodParent->deleteTree();
} else {
parent->deleteTree();
}
}
}
int TestDecayModel::findChargedDaughterWithMaxE( const EvtParticle* parent ) const
{
/* This function returns the index of the charged daughter with the highest energy
* following the sign convention below. */
double max_E = 0;
double max_index = 0;
const int parentCh3 = EvtPDL::chg3( parent->getId() );
for ( int iDaug{ 0 }; iDaug < (int)parent->getNDaug(); iDaug++ ) {
const EvtParticle* iDaughter = parent->getDaug( iDaug );
const int dauCh3 = EvtPDL::chg3( iDaughter->getId() );
const double daugE = iDaughter->getP4LabBeforeFSR().get( 0 );
// Sign convention: take negative daughter if mother is neutral,
// otherwise the one with the same sign as the mother.
if ( ( ( parentCh3 == 0 && dauCh3 < 0 ) || ( parentCh3 * dauCh3 > 0 ) ) &&
daugE > max_E ) {
max_E = daugE;
max_index = iDaug;
}
}
return max_index;
}
double TestDecayModel::getValue( const EvtParticle* parent,
const std::string& varName, const int d1,
const int d2 ) const
{
double value{ std::numeric_limits<double>::quiet_NaN() };
if ( !parent ) {
return value;
}
const int NDaugMax( parent->getNDaug() );
// If variable name contains "_daugX", we are interested in daughters of daughter X
// Else we are interested in daughters
const EvtParticle* selectedParent{ parent };
std::string selectedVarName{ varName };
if ( varName.find( "_daug" ) != std::string::npos ) {
// Get daughter index from last character in string
const int iDaughter{ varName.back() - '0' };
selectedVarName = varName.substr( 0, varName.size() - 6 );
if ( iDaughter > 0 && iDaughter <= NDaugMax ) {
selectedParent = parent->getDaug( iDaughter - 1 );
} else {
return value;
}
}
const int sel_NDaugMax( selectedParent->getNDaug() );
const EvtParticle* par1{ d1 > 0 && d1 <= sel_NDaugMax
? selectedParent->getDaug( d1 - 1 )
: nullptr };
const EvtParticle* par2{ d2 > 0 && d2 <= sel_NDaugMax
? selectedParent->getDaug( d2 - 1 )
: nullptr };
const EvtParticle* par3{ sel_NDaugMax > 0
? selectedParent->getDaug( sel_NDaugMax - 1 )
: nullptr };
// 4-momenta in parent rest frame
const EvtVector4R p1{ par1 != nullptr ? par1->getP4() : EvtVector4R() };
const EvtVector4R p2{ par2 != nullptr ? par2->getP4() : EvtVector4R() };
const EvtVector4R p3{ par3 != nullptr ? par3->getP4() : EvtVector4R() };
// 4-momenta in lab frame (1st parent in decay tree)
const EvtVector4R p1_lab{ par1 != nullptr ? par1->getP4Lab() : EvtVector4R() };
const EvtVector4R p2_lab{ par2 != nullptr ? par2->getP4Lab() : EvtVector4R() };
const EvtVector4R p3_lab{ par3 != nullptr ? par3->getP4Lab() : EvtVector4R() };
if ( !selectedVarName.compare( "id" ) ) {
// StdHep ID of one of the daughters (controlled by d1) or the parent
if ( par1 ) {
value = par1->getPDGId();
} else {
value = selectedParent->getPDGId();
}
} else if ( !selectedVarName.compare( "particleType" ) ) {
if ( par1 ) {
value = getPartGroup( par1->getPDGId() );
} else {
value = getPartGroup( selectedParent->getPDGId() );
}
} else if ( !selectedVarName.compare( "nDaug" ) ) {
// Number of daughters
value = sel_NDaugMax;
} else if ( !selectedVarName.compare( "parMass" ) ) {
// Parent invariant mass
value = selectedParent->mass();
} else if ( !selectedVarName.compare( "mass" ) ) {
// Invariant mass
if ( d2 != 0 ) {
// Invariant 4-mass combination of particles d1 and d2
value = ( p1 + p2 ).mass();
} else {
// Invariant mass of particle d1 only
value = p1.mass();
}
} else if ( !selectedVarName.compare( "massSq" ) ) {
// Invariant mass
if ( d2 != 0 ) {
// Invariant 4-mass combination of particles d1 and d2
value = ( p1 + p2 ).mass2();
} else {
// Invariant mass of particle d1 only
value = p1.mass2();
}
} else if ( !selectedVarName.compare( "mPrime" ) ) {
// pick up first unused particle rather than last one
if ( sel_NDaugMax != 3 ) {
return -1;
}
int unused{ 0 };
for ( int ii{ 1 }; ii <= sel_NDaugMax; ++ii ) {
if ( ii != d1 && ii != d2 ) {
unused = ii;
break;
}
}
if ( unused == 0 ) {
unused = sel_NDaugMax;
}
const auto parL{ selectedParent->getDaug( unused - 1 ) };
// const auto& pL = parL->getP4();
const double mB{ selectedParent->mass() };
const double m1{ par1->mass() };
const double m2{ par2->mass() };
const double m3{ parL->mass() };
const double m12{ ( p1 + p2 ).mass() };
const double m12norm{
2 * ( ( m12 - ( m1 + m2 ) ) / ( mB - ( m1 + m2 + m3 ) ) ) - 1 };
value = acos( m12norm ) / EvtConst::pi;
} else if ( !selectedVarName.compare( "thetaPrime" ) ) {
// pick up first unused particle rather than last one
if ( sel_NDaugMax != 3 ) {
return -1;
}
int unused{ 0 };
for ( int ii{ 1 }; ii <= sel_NDaugMax; ++ii ) {
if ( ii != d1 && ii != d2 ) {
unused = ii;
break;
}
}
if ( unused == 0 ) {
unused = sel_NDaugMax;
}
const auto parL{ selectedParent->getDaug( unused - 1 ) };
const auto& pL{ parL->getP4() };
const double mB{ selectedParent->mass() };
const double m1{ p1.mass() };
const double m2{ p2.mass() };
const double m3{ pL.mass() };
double mBSq{ mB * mB };
double m1Sq{ m1 * m1 };
double m2Sq{ m2 * m2 };
double m3Sq{ m3 * m3 };
const double m12{ ( p1 + p2 ).mass() };
const double m13{ ( p1 + p3 ).mass() };
const double m12Sq{ m12 * m12 };
const double m13Sq{ m13 * m13 };
double en1{ ( m12Sq - m2Sq + m1Sq ) / ( 2.0 * m12 ) };
double en3{ ( mBSq - m12Sq - m3Sq ) / ( 2.0 * m12 ) };
double p1_12{ std::sqrt( en1 * en1 - m1Sq ) };
double p3_12{ std::sqrt( en3 * en3 - m3Sq ) };
double cosTheta{ ( -m13Sq + m1Sq + m3Sq + 2. * en1 * en3 ) /
( 2. * p1_12 * p3_12 ) };
value = acos( cosTheta ) / EvtConst::pi;
} else if ( !selectedVarName.compare( "pSumSq" ) ) {
// Invariant momentum sum squared
value = ( p1 + p2 ).mass2();
} else if ( !selectedVarName.compare( "pDiffSq" ) ) {
// Invariant momentum difference squared
value = ( p1 - p2 ).mass2();
} else if ( !selectedVarName.compare( "mass3" ) ) {
// Invariant mass of 3 daughters
value = ( p1 + p2 + p3 ).mass();
} else if ( !selectedVarName.compare( "mass3_specified" ) ) {
// Invariant mass of 3 daughters, d1 is first daughter
// second daughter is d1 + 1, d2 is last daughter
const EvtParticle* daug2{ selectedParent->getDaug( d1 ) };
const EvtParticle* daug3{ selectedParent->getDaug( d2 - 1 ) };
const EvtVector4R p2_specified{ daug2 != nullptr ? daug2->getP4Lab()
: EvtVector4R() };
const EvtVector4R p3_specified{ daug3 != nullptr ? daug3->getP4Lab()
: EvtVector4R() };
value = ( p1 + p2_specified + p3_specified ).mass();
} else if ( !selectedVarName.compare( "cosTheta3" ) ) {
// Cosine of the polar angle of the momentum of d1 + d2 + d3
const EvtVector4R p123{ p1 + p2 + p3 };
if ( p123.d3mag() > 0.0 ) {
value = p123.get( 3 ) / p123.d3mag();
}
} else if ( !selectedVarName.compare( "pLab" ) ) {
// Momentum of particle d1 in lab frame
value = p1_lab.d3mag();
} else if ( !selectedVarName.compare( "p" ) ) {
// Momentum of particle d1 in parent rest frame
value = p1.d3mag();
} else if ( !selectedVarName.compare( "pLabSq" ) ) {
// Momentum squared of particle d1 (in lab frame)
const double p1_lab_x{ p1_lab.get( 1 ) };
const double p1_lab_y{ p1_lab.get( 2 ) };
const double p1_lab_z{ p1_lab.get( 3 ) };
value = p1_lab_x * p1_lab_x + p1_lab_y * p1_lab_y + p1_lab_z * p1_lab_z;
} else if ( !selectedVarName.compare( "pSq" ) ) {
// Momentum squared of particle d1 (in lab frame)
const double p1_x{ p1.get( 1 ) };
const double p1_y{ p1.get( 2 ) };
const double p1_z{ p1.get( 3 ) };
value = p1_x * p1_x + p1_y * p1_y + p1_z * p1_z;
} else if ( !selectedVarName.compare( "pxLab" ) ) {
// x momentum of particle d1 in lab frame
value = p1_lab.get( 1 );
} else if ( !selectedVarName.compare( "px" ) ) {
// x momentum of particle d1 in parent frame
value = p1.get( 1 );
} else if ( !selectedVarName.compare( "pyLab" ) ) {
// y momentum of particle d1 in lab frame
value = p1_lab.get( 2 );
} else if ( !selectedVarName.compare( "py" ) ) {
// y momentum of particle d1 in parent frame
value = p1.get( 2 );
} else if ( !selectedVarName.compare( "pzLab" ) ) {
// z momentum of particle d1 in lab frame
value = p1_lab.get( 3 );
} else if ( !selectedVarName.compare( "pz" ) ) {
// z momentum of particle d1 in parent frame
value = p1.get( 3 );
} else if ( !selectedVarName.compare( "cosHel" ) ||
!selectedVarName.compare( "absCosHel" ) ||
!selectedVarName.compare( "cosHelParent" ) ) {
// Cosine of helicity angle
EvtVector4R p12;
EvtVector4R p1Res;
if ( !selectedVarName.compare( "cosHelParent" ) ) {
p12 = selectedParent->getP4Lab();
const EvtVector4R boost{ p12.get( 0 ), -p12.get( 1 ), -p12.get( 2 ),
-p12.get( 3 ) };
// Momentum of particle d1 in resonance frame, p1Res
p1Res = boostTo( p1_lab, boost );
} else if ( d2 != 0 ) {
// Resonance center-of-mass system (d1 and d2)
p12 = p1_lab + p2_lab;
// Boost vector
const EvtVector4R boost{ p12.get( 0 ), -p12.get( 1 ), -p12.get( 2 ),
-p12.get( 3 ) };
// Momentum of particle d1 in resonance frame, p1Res
p1Res = boostTo( p1_lab, boost );
} else {
// The resonance is d1
p12 = p1;
// Find its first daughter
const EvtParticle* gpar{ par1 != nullptr ? par1->getDaug( 0 )
: nullptr };
p1Res = gpar != nullptr ? gpar->getP4() : EvtVector4R();
}
// Cosine of angle between p1Res and momentum of resonance in parent frame
const double p1ResMag{ p1Res.d3mag() };
const double p12Mag{ p12.d3mag() };
if ( p1ResMag > 0.0 && p12Mag > 0.0 ) {
value = -p1Res.dot( p12 ) / ( p1ResMag * p12Mag );
}
if ( !selectedVarName.compare( "absCosHel" ) ) {
value = std::abs( value );
}
} else if ( !selectedVarName.compare( "cosHelTau" ) ) {
// Works only for B -> X nu_1 tau -> pi nu_2.
// Cosine of helicity angle between pi momentum and opposite W momentum -(nu_1 + tau)
// in the tau rest frame. Index d1 must match with tau.
// p3 (momentum of last daughter) is taken as the neutrino momentum
// W momentum
const EvtVector4R p_W{ p1_lab + p3_lab };
// Index d2 must match the index of the pion (daughter of tau)
const EvtParticle* pion{
selectedParent->getDaug( d1 - 1 )->getDaug( d2 - 1 ) };
const EvtVector4R p_pion{ pion != nullptr ? pion->getP4Lab()
: EvtVector4R() };
// Boost vector to tau frame
const EvtVector4R boost{ p1_lab.get( 0 ), -p1_lab.get( 1 ),
-p1_lab.get( 2 ), -p1_lab.get( 3 ) };
// Boost both momenta to tau frame
const EvtVector4R p_W_boosted{ boostTo( p_W, boost ) };
const EvtVector4R p_pion_boosted{ boostTo( p_pion, boost ) };
// Cosine of angle between opposite W momentum and pion momentum in tau frame
const double p_W_boostedMag{ p_W_boosted.d3mag() };
const double p_pion_boostedMag{ p_pion_boosted.d3mag() };
if ( p_W_boostedMag > 0.0 && p_pion_boostedMag > 0.0 ) {
value = -p_W_boosted.dot( p_pion_boosted ) /
( p_W_boostedMag * p_pion_boostedMag );
}
} else if ( !selectedVarName.compare( "cosHelDiTau" ) ||
!selectedVarName.compare( "cosHelDiTau_over05" ) ||
!selectedVarName.compare( "cosHelDiTau_under05" ) ) {
// Works for B -> tau (pi nu) tau -> (pi nu), B -> phi (-> KK) l l decays,
// B -> 4 pions, or similar decays..
// Cosine of helicity angle between pi momentum and opposite B momentum in tau rest frame.
// Index d1 must match with tau
if ( sel_NDaugMax < 2 || sel_NDaugMax > 4 ) {
return value;
}
// B momentum
const EvtVector4R p_B{ selectedParent->getP4Lab() };
// Index d2 must match the index of the pion (daughter of tau)
const EvtParticle* pion_1{
sel_NDaugMax <= 3
? selectedParent->getDaug( d1 - 1 )->getDaug( d2 - 1 )
: selectedParent->getDaug( d1 - 1 ) };
const EvtVector4R p_pion_1{ pion_1 != nullptr ? pion_1->getP4Lab()
: EvtVector4R() };
const EvtVector4R p_first_daughter{
sel_NDaugMax <= 3 ? selectedParent->getDaug( d1 - 1 )->getP4Lab()
: selectedParent->getDaug( d1 - 1 )->getP4Lab() +
selectedParent->getDaug( d1 )->getP4Lab() };
// Boost vector to tau frame
const EvtVector4R boost_1{ p_first_daughter.get( 0 ),
-p_first_daughter.get( 1 ),
-p_first_daughter.get( 2 ),
-p_first_daughter.get( 3 ) };
// Boost both momenta to tau frame
const EvtVector4R p_B_boosted_1{ boostTo( p_B, boost_1 ) };
const EvtVector4R p_pion_boosted_1{ boostTo( p_pion_1, boost_1 ) };
// Cosine of angle between opposite W momentum and pion momentum in tau frame
const double p_B_boosted_1_Mag{ p_B_boosted_1.d3mag() };
const double p_pion_boosted_1_Mag{ p_pion_boosted_1.d3mag() };
double hel1{ std::numeric_limits<double>::quiet_NaN() };
double hel{ std::numeric_limits<double>::quiet_NaN() };
if ( p_B_boosted_1_Mag > 0.0 && p_pion_boosted_1_Mag > 0.0 ) {
hel1 = -p_B_boosted_1.dot( p_pion_boosted_1 ) /
( p_B_boosted_1_Mag * p_pion_boosted_1_Mag );
}
if ( ( !selectedVarName.compare( "cosHelDiTau_over05" ) ) ||
( !selectedVarName.compare( "cosHelDiTau_under05" ) ) ) {
// Works for B -> tau (pi nu) tau -> (pi nu) or similar decays.
// Cosine of helicity angle between pi momentum and opposite B momentum in tau rest frame
// Index d1 must match with tau; cosHelicity above +0.5 or below -0.5
// Index d2 must match the index of the pion (daughter of tau)
const EvtParticle* pion{
sel_NDaugMax <= 3 ? selectedParent->getDaug( 0 )->getDaug( d2 - 1 )
: selectedParent->getDaug( 0 ) };
const EvtVector4R p_pion{ pion != nullptr ? pion->getP4Lab()
: EvtVector4R() };
// Boost vector to tau frame
const EvtVector4R p_second_daughter{
sel_NDaugMax == 2
? selectedParent->getDaug( 0 )->getP4Lab()
: selectedParent->getDaug( 0 )->getP4Lab() +
selectedParent->getDaug( 1 )->getP4Lab() };
const EvtVector4R boost{ p_second_daughter.get( 0 ),
-p_second_daughter.get( 1 ),
-p_second_daughter.get( 2 ),
-p_second_daughter.get( 3 ) };
// Boost both momenta to tau frame
const EvtVector4R p_B_boosted{ boostTo( p_B, boost ) };
const EvtVector4R p_pion_boosted{ boostTo( p_pion, boost ) };
// Cosine of angle between opposite W momentum and pion momentum in tau frame
const double p_B_boostedMag{ p_B_boosted.d3mag() };
const double p_pion_boostedMag{ p_pion_boosted.d3mag() };
if ( p_B_boostedMag > 0.0 && p_pion_boostedMag > 0.0 ) {
hel = -p_B_boosted.dot( p_pion_boosted ) /
( p_B_boostedMag * p_pion_boostedMag );
}
}
if ( !selectedVarName.compare( "cosHelDiTau" ) ||
( hel > 0.5 && !selectedVarName.compare( "cosHelDiTau_over05" ) ) ||
( hel < -0.5 && !selectedVarName.compare( "cosHelDiTau_under05" ) ) ) {
value = hel1;
}
} else if ( !selectedVarName.compare( "cosAcoplanarityAngle" ) ||
!selectedVarName.compare( "acoplanarityAngle" ) ) {
// Acoplanarity angle or cosine for B -> tau (pi nu) tau -> (pi nu),
// B -> phi (-> KK) l l decays, B -> 4 pions, or similar decays
value = getCosAcoplanarityAngle( selectedParent, sel_NDaugMax, d1, d2 );
if ( !selectedVarName.compare( "acoplanarityAngle" ) ) {
value = std::acos( value ) * 180.0 / EvtConst::pi; // degrees
}
} else if ( !selectedVarName.compare( "cosTheta" ) ) {
// Cosine of polar angle of first daughter in lab frame
const double p1_lab_mag{ p1_lab.d3mag() };
if ( p1_lab_mag > 0.0 ) {
value = p1_lab.get( 3 ) / p1_lab_mag;
}
} else if ( !selectedVarName.compare( "phi" ) ) {
// Azimuthal angle of first daughter in lab frame (degrees)
const double p1_lab_mag{ p1_lab.d3mag() };
if ( p1_lab_mag > 0.0 ) {
value = atan2( p1_lab.get( 1 ), p1_lab.get( 2 ) ) * 180.0 /
EvtConst::pi;
}
} else if ( !selectedVarName.compare( "openingAngle" ) ) {
// Polar angle between first and second daughters in parent's frame
const double cost{ p1.dot( p2 ) / ( p1.d3mag() * p2.d3mag() ) };
value = acos( cost ) * 180.0 / EvtConst::pi;
} else if ( !selectedVarName.compare( "decayangle" ) ) {
// Polar angle between first and second daughters in lab frame
const EvtVector4R p{ selectedParent->getP4() };
const EvtVector4R q{ p1 + p2 };
const EvtVector4R d{ p1 };
const double cost{ EvtDecayAngle( p, q, d ) };
value = acos( cost ) * 180.0 / EvtConst::pi;
} else if ( !selectedVarName.compare( "decayangle3" ) ) {
// Polar angle between combined first and second daughters
// with the third daughter in lab frame
const EvtVector4R p{ selectedParent->getP4() };
const EvtVector4R q{ p1 + p2 + p3 };
const EvtVector4R d{ p1 + p2 };
const double cost{ EvtDecayAngle( p, q, d ) };
value = acos( cost ) * 180.0 / EvtConst::pi;
} else if ( !selectedVarName.compare( "decayangle_BTO4PI" ) ) {
// Polar angle between first and second daughters in lab frame.
// Used in PIPIPI (BTO4PI_CP) model
const EvtVector4R p{ p1 + p2 + p3 };
const EvtVector4R q{ p1 + p2 };
const EvtVector4R d{ p1 };
const double cost{ EvtDecayAngle( p, q, d ) };
value = acos( cost ) * 180.0 / EvtConst::pi;
} else if ( !selectedVarName.compare( "chi" ) ) {
// Chi angle (degrees) using all 4 daughters and parent 4 mom
const EvtParticle* daug1{ selectedParent->getDaug( d1 - 1 ) };
const EvtParticle* daug2{ selectedParent->getDaug( d1 ) };
const EvtParticle* daug3{ selectedParent->getDaug( d1 + 1 ) };
const EvtParticle* daug4{ selectedParent->getDaug( d1 + 2 ) };
const EvtVector4R p_parent{ selectedParent->getP4() };
const EvtVector4R p_daug1{ daug1 != nullptr ? daug1->getP4()
: EvtVector4R() };
const EvtVector4R p_daug2{ daug2 != nullptr ? daug2->getP4()
: EvtVector4R() };
const EvtVector4R p_daug3{ daug3 != nullptr ? daug3->getP4()
: EvtVector4R() };
const EvtVector4R p_daug4{ daug4 != nullptr ? daug4->getP4()
: EvtVector4R() };
const double chi{
EvtDecayAngleChi( p_parent, p_daug1, p_daug2, p_daug3, p_daug4 ) };
value = chi * 180.0 / EvtConst::pi;
} else if ( !selectedVarName.compare( "cosThetaResNorm" ) ) {
// P -> R p4 -> (p1 p2 p3) p4, where the resonance R decays to p1 p2 p3.
// Theta is the angle between the normal of the plane containing p1, p2 & p3
// and the bachelor particle p4 in the rest frame of resonance R.
// The normal vector is given by the cross product p3 x p1
if ( sel_NDaugMax > 1 ) {
const EvtParticle* res{ selectedParent->getDaug( 0 ) };
const EvtParticle* bac{ selectedParent->getDaug( 1 ) };
// Check resonance has 3 daughters
if ( res != nullptr && res->getNDaug() == 3 ) {
const EvtParticle* daug1 = res->getDaug( 0 );
const EvtParticle* daug3 = res->getDaug( 2 );
// 4-momenta in base parent P lab frame
const EvtVector4R p4_Res{ res->getP4Lab() };
const EvtVector4R p4_p4{ bac != nullptr ? bac->getP4Lab()
: EvtVector4R() };
const EvtVector4R p4_p1{ daug1 != nullptr ? daug1->getP4Lab()
: EvtVector4R() };
const EvtVector4R p4_p3{ daug3 != nullptr ? daug3->getP4Lab()
: EvtVector4R() };
// Boost 4-vector for resonance frame
const EvtVector4R boost{ p4_Res.get( 0 ), -p4_Res.get( 1 ),
-p4_Res.get( 2 ), -p4_Res.get( 3 ) };
// Momentum of p1 and p3 in resonance frame
const EvtVector4R p1Res{ boostTo( p4_p1, boost ) };
const EvtVector4R p3Res{ boostTo( p4_p3, boost ) };
// Plane normal vector (just uses 3-momentum components)
const EvtVector4R norm{ p3Res.cross( p1Res ) };
// Momentum of p4 in resonance frame
const EvtVector4R p4Res{ boostTo( p4_p4, boost ) };
// Cosine of the angle between the normal and p4 in the resonance frame
const double normMag{ norm.d3mag() };
const double p4ResMag{ p4Res.d3mag() };
if ( normMag > 0.0 && p4ResMag > 0.0 ) {
value = norm.dot( p4Res ) / ( normMag * p4ResMag );
}
}
}
} else if ( !selectedVarName.compare( "cosBetaRes" ) ) {
// For resonance P (parent) -> p1 p2 p3, beta is the
// angle between p1 & p3 in the (p1 + p2) rest frame
if ( sel_NDaugMax > 2 ) {
const EvtParticle* daug1 = selectedParent->getDaug( 0 );
const EvtParticle* daug2 = selectedParent->getDaug( 1 );
const EvtParticle* daug3 = selectedParent->getDaug( 2 );
// 4-momenta in base parent frame
const EvtVector4R p4_p1{ daug1 != nullptr ? daug1->getP4Lab()
: EvtVector4R() };
const EvtVector4R p4_p2{ daug2 != nullptr ? daug2->getP4Lab()
: EvtVector4R() };
const EvtVector4R p4_p3{ daug3 != nullptr ? daug3->getP4Lab()
: EvtVector4R() };
// p1 + p2
const EvtVector4R p12{ p4_p1 + p4_p2 };
// Boost 4-vector for p12 frame
const EvtVector4R boost{ p12.get( 0 ), -p12.get( 1 ), -p12.get( 2 ),
-p12.get( 3 ) };
// Momentum of p1 & p3 in p12 frame
const EvtVector4R p1_12{ boostTo( p4_p1, boost ) };
const EvtVector4R p3_12{ boostTo( p4_p3, boost ) };
// Cosine of angle between p1 & p3 in p12 frame
const double p1_12Mag{ p1_12.d3mag() };
const double p3_12Mag{ p3_12.d3mag() };
if ( p1_12Mag > 0.0 && p3_12Mag > 0.0 ) {
value = p1_12.dot( p3_12 ) / ( p1_12Mag * p3_12Mag );
}
}
} else if ( !selectedVarName.compare( "E" ) ) {
// Energy of first daughter in lab frame
value = p1_lab.get( 0 );
} else if ( !selectedVarName.compare( "E_over_Eparent" ) ) {
// Energy of first daughter w.r.t parent energy (lab frame)
value = p1_lab.get( 0 ) / selectedParent->getP4Lab().get( 0 );
} else if ( !selectedVarName.compare( "E_over_Eparent_over05" ) ) {
// First daughter E_over_Eparent (lab frame) if d2 granddaughter E ratio > 0.5
const double E_over_Eparent_2{
parent->getDaug( 0 )->getDaug( d2 - 1 )->getP4Lab().get( 0 ) /
parent->getDaug( 0 )->getP4Lab().get( 0 ) };
if ( E_over_Eparent_2 > 0.5 ) {
value = p1_lab.get( 0 ) / selectedParent->getP4Lab().get( 0 );
}
} else if ( !selectedVarName.compare( "totE_over_Mparent" ) ) {
// Energy of given daughters w.r.t parent mass (lab frame)
value = ( p1_lab.get( 0 ) + p2_lab.get( 0 ) ) / selectedParent->mass();
} else if ( !selectedVarName.compare( "prob" ) ) {
// Decay probability
const double* dProb{ selectedParent->decayProb() };
if ( dProb ) {
value = *dProb;
}
} else if ( !selectedVarName.compare( "lifetime" ) ) {
// Lifetime of particle d1 (ps)
if ( d1 ) {
value = par1 != nullptr ? par1->getLifetime() * 1e12 / EvtConst::c
: 0.0;
} else {
value = parent != nullptr
- ? parent->getLifetime() * 1e12 / EvtConst::c
- : 0.0;
+ ? parent->getLifetime() * 1e12 / EvtConst::c
+ : 0.0;
}
} else if ( !selectedVarName.compare( "deltaT" ) ) {
// Lifetime difference between particles d1 and d2
const double t1{
par1 != nullptr ? par1->getLifetime() * 1e12 / EvtConst::c : 0.0 };
const double t2{
par2 != nullptr ? par2->getLifetime() * 1e12 / EvtConst::c : 0.0 };
value = t1 - t2;
} else if ( !selectedVarName.compare( "decTime" ) ) {
// Decay flight time of particle d1 in picoseconds.
// Decay vertex = position of (1st) decay particle of d1
const EvtParticle* gpar{ par1 != nullptr ? par1->getDaug( 0 ) : nullptr };
const EvtVector4R vtxPos{ gpar != nullptr ? gpar->get4Pos()
: EvtVector4R() };
const double p{ p1_lab.d3mag() };
value = p > 0.0
- ? 1e12 * vtxPos.d3mag() * p1_lab.mass() / ( p * EvtConst::c )
- : 0.0;
+ ? 1e12 * vtxPos.d3mag() * p1_lab.mass() / ( p * EvtConst::c )
+ : 0.0;
} else if ( !selectedVarName.compare( "nFSRPhotons" ) ) {
// Loop over all daughters and get number of FSR photons
double nFSRPhotons{ 0 };
for ( std::size_t iDaughter{ 0 };
iDaughter < selectedParent->getNDaug(); iDaughter++ ) {
const EvtParticle* iDaug = selectedParent->getDaug( iDaughter );
if ( iDaug->getAttribute( "FSR" ) == 1 )
nFSRPhotons += 1.0;
}
value = nFSRPhotons;
} else if ( !selectedVarName.compare( "totalFSREnergy" ) ) {
// Loop over all daughters and get number of FSR photons
double totalFSREnergy{ 0 };
for ( std::size_t iDaughter{ 0 };
iDaughter < selectedParent->getNDaug(); iDaughter++ ) {
const EvtParticle* iDaug = selectedParent->getDaug( iDaughter );
if ( iDaug->getAttribute( "FSR" ) == 1 )
totalFSREnergy += iDaug->getP4Lab().get( 0 );
}
value = totalFSREnergy;
} else {
std::cerr << "Warning: Did not recognise variable name "
<< selectedVarName << std::endl;
}
return value;
}
void TestDecayModel::compareHistos( const TestHistos& theHistos,
const std::string& refFileName ) const
{
// Compare histograms with the same name, calculating the chi-squared
std::unique_ptr<TFile> refFile{ TFile::Open( refFileName.c_str(), "read" ) };
if ( !refFile ) {
std::cerr << "Could not open reference file " << refFileName << std::endl;
return;
}
// TODO - should we plot the (signed) chisq histogram? and save it as pdf/png?
// TODO - add comparison of mixedHist
for ( auto& [_, hist] : theHistos.get1DHistos() ) {
const std::string histName{ hist->GetName() };
// Get equivalent reference histogram
const TH1* refHist{
dynamic_cast<TH1*>( refFile->Get( histName.c_str() ) ) };
if ( refHist ) {
double chiSq{ 0.0 };
int nDof{ 0 };
int iGood{ 0 };
const double pValue{
refHist->Chi2TestX( hist.get(), chiSq, nDof, iGood, "WW" ) };
const double integral{ refHist->Integral() };
std::cout << "Histogram " << histName << " chiSq/nDof = " << chiSq
<< "/" << nDof << ", pValue = " << pValue
<< ", integral = " << integral << std::endl;
} else {
std::cerr << "Could not find reference histogram " << histName
<< std::endl;
}
}
for ( auto& [_, hist] : theHistos.get2DHistos() ) {
const std::string histName{ hist->GetName() };
// Get equivalent reference histogram
const TH2* refHist{
dynamic_cast<TH2*>( refFile->Get( histName.c_str() ) ) };
if ( refHist ) {
double chiSq{ 0.0 };
int nDof{ 0 };
int iGood{ 0 };
const double pValue{
refHist->Chi2TestX( hist.get(), chiSq, nDof, iGood, "WW" ) };
const double integral{ refHist->Integral() };
std::cout << "Histogram " << histName << " chiSq/nDof = " << chiSq
<< "/" << nDof << ", pValue = " << pValue
<< ", integral = " << integral << std::endl;
} else {
std::cerr << "Could not find reference histogram " << histName
<< std::endl;
}
}
refFile->Close();
}
int TestDecayModel::getPartGroup( const int PDGId ) const
{
int group( -1 );
const int absPDGId = std::abs( PDGId );
if ( absPDGId >= 11 && absPDGId <= 16 ) {
group = 0; // leptons
} else if ( absPDGId == 22 ) {
group = 1; // photon
} else if ( absPDGId == 211 ) {
group = 2; // pi+-
} else if ( absPDGId == 111 ) {
group = 3; // pi0
} else if ( absPDGId == 321 ) {
group = 4; // K+-
} else if ( absPDGId == 311 || absPDGId == 130 || absPDGId == 310 ) {
group = 5; // K0
} else if ( absPDGId == 411 ) {
group = 6; // D+-
} else if ( absPDGId == 421 ) {
group = 7; // D0
} else if ( absPDGId == 2212 || absPDGId == 2112 || absPDGId == 2224 ||
absPDGId == 2214 || absPDGId == 2114 || absPDGId == 1114 ) {
group = 8; // light baryons
} else if ( absPDGId >= 3112 && absPDGId <= 3334 ) {
group = 9; // strange baryons
} else if ( absPDGId != 0 ) {
group = 10; // other particles
}
return group;
}
bool TestDecayModel::isPartType( const int group,
const std::string& particleType ) const
{
if ( ( !particleType.compare( "LeptonOrPhoton" ) &&
( group == 0 || group == 1 ) ) ||
( !particleType.compare( "Pion" ) && ( group == 2 || group == 3 ) ) ||
( !particleType.compare( "Kaon" ) && ( group == 4 || group == 5 ) ) ||
( !particleType.compare( "Dmeson" ) && ( group == 6 || group == 7 ) ) ||
( !particleType.compare( "Baryon" ) && ( group == 8 || group == 9 ) ) ||
( !particleType.compare( "Other" ) && group == 10 ) ) {
return true;
} else {
return false;
}
}
double TestDecayModel::getCosAcoplanarityAngle( const EvtParticle* selectedParent,
const int sel_NDaugMax,
const int d1, const int d2 ) const
{
// Given a two-body decay, the acoplanarity angle is defined as the angle between the
// two decay planes (normal vectors) in the reference frame of the mother.
// Each normal vector is the cross product of the momentum of one daughter (in the frame of the mother)
// and the momentum of one of the granddaughters (in the reference frame of the daughter).
// In case of 3 daughters, we build an intermediate daughter (2+3) from the last 2 daughters
// (which are then treated as grand daughters), and in case of 4 daughters, we build
// 2 intermediate daughters (1+2) and (3+4)
double cosAco{ 0.0 };
if ( sel_NDaugMax < 2 || sel_NDaugMax > 4 ) {
return cosAco;
}
const EvtParticle* daughter1{ selectedParent->getDaug( 0 ) };
const EvtParticle* daughter2{ selectedParent->getDaug( 1 ) };
const EvtParticle* daughter3{ selectedParent->getDaug( 2 ) };
const EvtParticle* daughter4{ selectedParent->getDaug( 3 ) };
const EvtParticle* grandDaughter1{ daughter1->getDaug( d1 - 1 ) };
const EvtParticle* grandDaughter2{ daughter2->getDaug( d2 - 1 ) };
const EvtVector4R parent4Vector{ selectedParent->getP4Lab() };
const EvtVector4R daughter4Vector1{
sel_NDaugMax <= 3 ? daughter1->getP4Lab()
: daughter1->getP4Lab() + daughter2->getP4Lab() };
const EvtVector4R daughter4Vector2{
sel_NDaugMax == 2 ? daughter2->getP4Lab()
: sel_NDaugMax == 3 ? daughter2->getP4Lab() + daughter3->getP4Lab()
: daughter3->getP4Lab() + daughter4->getP4Lab() };
const EvtVector4R grandDaughter4Vector1{
sel_NDaugMax <= 3 ? grandDaughter1->getP4Lab() : daughter1->getP4Lab() };
const EvtVector4R grandDaughter4Vector2{
sel_NDaugMax == 2 ? grandDaughter2->getP4Lab()
: sel_NDaugMax == 3 ? daughter2->getP4Lab()
: daughter3->getP4Lab() };
const EvtVector4R parentBoost{ parent4Vector.get( 0 ),
-parent4Vector.get( 1 ),
-parent4Vector.get( 2 ),
-parent4Vector.get( 3 ) };
const EvtVector4R daughter1Boost{ daughter4Vector1.get( 0 ),
-daughter4Vector1.get( 1 ),
-daughter4Vector1.get( 2 ),
-daughter4Vector1.get( 3 ) };
const EvtVector4R daughter2Boost{ daughter4Vector2.get( 0 ),
-daughter4Vector2.get( 1 ),
-daughter4Vector2.get( 2 ),
-daughter4Vector2.get( 3 ) };
// Boosting daughters to reference frame of the mother
const EvtVector4R daughter4Vector1_boosted{
boostTo( daughter4Vector1, parentBoost ) };
const EvtVector4R daughter4Vector2_boosted{
boostTo( daughter4Vector2, parentBoost ) };
// Boosting each granddaughter to reference frame of its mother
const EvtVector4R grandDaughter4Vector1_boosted{
boostTo( grandDaughter4Vector1, daughter1Boost ) };
const EvtVector4R grandDaughter4Vector2_boosted{
boostTo( grandDaughter4Vector2, daughter2Boost ) };
// We calculate the normal vectors of the decay two planes
const EvtVector4R normalVector1{
daughter4Vector1_boosted.cross( grandDaughter4Vector1_boosted ) };
const EvtVector4R normalVector2{
daughter4Vector2_boosted.cross( grandDaughter4Vector2_boosted ) };
const double normalVector1Mag{ normalVector1.d3mag() };
const double normalVector2Mag{ normalVector2.d3mag() };
if ( normalVector1Mag > 0.0 && normalVector2Mag > 0.0 ) {
cosAco = normalVector1.dot( normalVector2 ) /
( normalVector1Mag * normalVector2Mag );
}
return cosAco;
}
int main( int argc, char* argv[] )
{
if ( argc < 2 || argc > 3 ) {
std::cerr << "Expecting at least one argument: test configuration json file"
<< "\nAdditional argument supported for: general configuration json file"
<< std::endl;
return 1;
}
// Tweak ROOT behaviour
ROOT::EnableThreadSafety();
TH1::AddDirectory( kFALSE );
// Load input file in json format
const std::string testConfigFileName{ argv[1] };
const std::string generalConfigFileName{
( argc > 2 ) ? argv[2] : "jsonFiles/config/default.json" };
json generalConfig;
json testConfig;
{
std::ifstream inputStr{ generalConfigFileName };
inputStr >> generalConfig;
}
{
std::ifstream inputStr{ testConfigFileName };
inputStr >> testConfig;
}
if ( testConfig.is_array() ) {
for ( auto& cc : testConfig ) {
cc.merge_patch( generalConfig );
TestDecayModel test{ cc };
test.run();
}
} else {
testConfig.merge_patch( generalConfig );
TestDecayModel test{ testConfig };
test.run();
}
return 0;
}
diff --git a/test/testDecayModel.hh b/test/testDecayModel.hh
index 7d55833..2e597d7 100644
--- a/test/testDecayModel.hh
+++ b/test/testDecayModel.hh
@@ -1,392 +1,395 @@
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors *
* *
* This file is part of EvtGen. *
* *
* EvtGen is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* EvtGen is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with EvtGen. If not, see <https://www.gnu.org/licenses/>. *
***********************************************************************/
#ifndef TEST_DECAY_MODEL_HH
#define TEST_DECAY_MODEL_HH
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
#include "nlohmann/json.hpp"
#include <array>
#include <cmath>
#include <mutex>
#include <string>
#include <utility>
#include <vector>
class EvtGen;
class EvtParticle;
/**
\enum FSRGenerator
Enumeration of possible FSR generators and their settings
*/
enum class FSRGenerator
{
PHOTOS, ///< PHOTOS generator
SherpaPhotons1, ///< Sherpa Photons generator, mode 1
SherpaPhotons20, ///< Sherpa Photons generator, mode 2, exact ME calculations off
SherpaPhotons21 ///< Sherpa Photons generator, mode 2, exact ME calculations on
};
/**
\enum ThreadModel
Enumeration of possible models for multi-threading
*/
enum class ThreadModel
{
StdLib, ///< C++ standard library model
TBB ///< Intel Thread Building Blocks model
};
//! \cond DOXYGEN_IGNORE
/*
Here we define a custom version of the NLOHMANN_JSON_SERIALIZE_ENUM macro.
The macro supplied by the nlohmann_json package will convert any
unrecognised string to the first enum state, which here we throw an
exception in such cases.
In addition, we define the to_string utility function.
*/
#define CUSTOM_NLOHMANN_JSON_SERIALIZE_ENUM( ENUM_TYPE, ... ) \
template <typename BasicJsonType> \
inline void to_json( BasicJsonType& j, const ENUM_TYPE& e ) \
{ \
static_assert( std::is_enum<ENUM_TYPE>::value, \
#ENUM_TYPE " must be an enum!" ); \
static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
auto it = std::find_if( \
std::begin( m ), std::end( m ), \
- [e]( const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair ) -> bool { \
- return ej_pair.first == e; \
- } ); \
+ [e]( const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair ) -> bool \
+ { return ej_pair.first == e; } ); \
if ( it == std::end( m ) ) { \
throw std::runtime_error{ \
"ERROR in conversion to JSON, invalid state for " #ENUM_TYPE }; \
} \
j = it->second; \
} \
template <typename BasicJsonType> \
inline void from_json( const BasicJsonType& j, ENUM_TYPE& e ) \
{ \
static_assert( std::is_enum<ENUM_TYPE>::value, \
#ENUM_TYPE " must be an enum!" ); \
static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
auto it = std::find_if( \
std::begin( m ), std::end( m ), \
- [&j]( const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair ) -> bool { \
- return ej_pair.second == j; \
- } ); \
+ [&j]( const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair ) -> bool \
+ { return ej_pair.second == j; } ); \
if ( it == std::end( m ) ) { \
throw std::runtime_error{ \
"ERROR in conversion from JSON, invalid state for " #ENUM_TYPE }; \
} \
e = it->first; \
} \
inline std::string to_string( const ENUM_TYPE& e ) \
{ \
static_assert( std::is_enum<ENUM_TYPE>::value, \
#ENUM_TYPE " must be an enum!" ); \
nlohmann::json j; \
to_json( j, e ); \
return j.get<std::string>(); \
}
// Generate functions for serialisation of the FSRGenerator and ThreadModel enums
CUSTOM_NLOHMANN_JSON_SERIALIZE_ENUM(
FSRGenerator, {
- { FSRGenerator::PHOTOS, "PHOTOS" },
- { FSRGenerator::SherpaPhotons1, "SherpaPhotons1" },
- { FSRGenerator::SherpaPhotons20, "SherpaPhotons20" },
- { FSRGenerator::SherpaPhotons21, "SherpaPhotons21" },
- } )
+ { FSRGenerator::PHOTOS, "PHOTOS"},
+ { FSRGenerator::SherpaPhotons1, "SherpaPhotons1"},
+ {FSRGenerator::SherpaPhotons20, "SherpaPhotons20"},
+ {FSRGenerator::SherpaPhotons21, "SherpaPhotons21"},
+} )
CUSTOM_NLOHMANN_JSON_SERIALIZE_ENUM( ThreadModel,
{
- { ThreadModel::StdLib, "StdLib" },
- { ThreadModel::TBB, "TBB" },
- } )
+ {ThreadModel::StdLib, "StdLib"},
+ { ThreadModel::TBB, "TBB"},
+} )
//! \endcond
/**
\class HistInfo
Information about a given histogram: variable name(s), daughter indices
*/
class HistInfo {
public:
/**
\enum Axis
Enumeration of histogram axes
*/
enum class Axis
{
X,
Y
};
/// Constructor for 1D histogram
HistInfo( const std::string& name, const int d1, const int d2 ) :
m_nameX{ name }, m_d1X{ d1 }, m_d2X{ d2 }
{
}
/// Constructor for 2D histogram
HistInfo( const std::string& nameX, const int d1X, const int d2X,
const std::string& nameY, const int d1Y, const int d2Y ) :
- m_nameX{ nameX }, m_nameY{ nameY }, m_d1X{ d1X }, m_d2X{ d2X }, m_d1Y{ d1Y }, m_d2Y{ d2Y }
+ m_nameX{ nameX },
+ m_nameY{ nameY },
+ m_d1X{ d1X },
+ m_d2X{ d2X },
+ m_d1Y{ d1Y },
+ m_d2Y{ d2Y }
{
}
/// Retrieve variable name for given axis
const std::string getName( const Axis var = Axis::X ) const
{
return var == Axis::Y ? m_nameY : m_nameX;
}
/// Retrieve daughter 1 index for given axis
int getd1( const Axis var = Axis::X ) const
{
return var == Axis::Y ? m_d1Y : m_d1X;
}
/// Retrieve daughter 2 index for given axis
int getd2( const Axis var = Axis::X ) const
{
return var == Axis::Y ? m_d2Y : m_d2X;
}
private:
/// x-axis variable name
std::string m_nameX;
/// y-axis variable name
std::string m_nameY;
/// x-axis daughter 1 index
int m_d1X{ 0 };
/// x-axis daughter 2 index
int m_d2X{ 0 };
/// y-axis daughter 1 index
int m_d1Y{ 0 };
/// y-axis daughter 2 index
int m_d2Y{ 0 };
};
/**
\class TestHistos
\brief The set of histograms to be populated for a given test
Defined such that each thread can have its own set of histograms, which can
then be combined by the main thread after synchronisation and saved to the
output file.
To work properly with tbb::parallel_reduce, a default-constructed TestHistos
instance must act like a zero in a summation operation.
*/
class TestHistos {
public:
/// Default constructor
TestHistos() = default;
/// Constructor - creates the histograms specified in the JSON configuration
TestHistos( const std::string& parentName, const nlohmann::json& config );
/// Copy constructor
TestHistos( const TestHistos& rhs );
/// Move constructor
TestHistos( TestHistos&& rhs ) noexcept;
/// Copy asignment operator
TestHistos& operator=( const TestHistos& rhs );
/// Move asignment operator
TestHistos& operator=( TestHistos&& rhs ) noexcept;
/// Destructor
~TestHistos() = default;
/// Add the rhs histograms to our own
void add( const TestHistos& rhs );
/// Normalise all histograms
void normalise();
/// Write all histograms to the supplied ROOT file
void save( TFile* outputFile );
/// typedef for 1D histogram store
using HistStore1D = std::vector<std::pair<HistInfo, std::unique_ptr<TH1>>>;
/// typedef for 2D histogram store
using HistStore2D = std::vector<std::pair<HistInfo, std::unique_ptr<TH2>>>;
/// Retrieve a const reference to the 1D histogram store
const HistStore1D& get1DHistos() const { return m_1DhistVect; }
/// Retrieve a reference to the 1D histogram store
HistStore1D& get1DHistos() { return m_1DhistVect; }
/// Retrieve a const reference to the 2D histogram store
const HistStore2D& get2DHistos() const { return m_2DhistVect; }
/// Retrieve a reference to the 2D histogram store
HistStore2D& get2DHistos() { return m_2DhistVect; }
/// Retrieve a const pointer to the mixed histogram
const TH1* getMixedHist() const { return m_mixedHist.get(); }
/// Retrieve a pointer to the mixed histogram
TH1* getMixedHist() { return m_mixedHist.get(); }
private:
/// Swap the histogram stores between two instances
void swap( TestHistos& rhs ) noexcept;
/// The store of 1D histograms
HistStore1D m_1DhistVect;
/// The store of 2D histograms
HistStore2D m_2DhistVect;
/// The mixed histogram
std::unique_ptr<TH1> m_mixedHist;
};
/**
\struct TestConfig
The settings for the test, as read from the JSON file
*/
struct TestConfig {
/// Name of the parent particle
std::string parentName;
/// Names of all first-generation decay products
std::vector<std::string> daughterNames;
/// Names of all second-generation decay products
std::vector<std::vector<std::string>> grandDaughterNames;
/// Names of the decay models
std::vector<std::string> modelNames;
/// Parameters of the decay models
std::vector<std::vector<std::string>> modelParameters;
/// Flag to control whether the charge-conjugate decay shoudl be generated
std::vector<bool> doConjDecay;
/// Extra global commands, e.g. noFSR
std::vector<std::string> extraCommands;
/// The FSR generator to use
FSRGenerator fsrGenerator;
/// The threading model to use
ThreadModel threadModel;
/// The name of the output ROOT file
std::string outFileName;
/// The name of the reference ROOT file
std::string refFileName;
/// The name of the decay file
std::string decFileName;
/// The number of events to generate
std::size_t nEvents;
/// The number of threads to use
std::size_t nThreads;
/// The base of the random number seed
std::size_t rngSeed;
/// Flag to control printing of debug output
bool debugFlag;
/// The set of histograms to be filled
TestHistos testHistograms;
};
/**
\class TestDecayModel
\brief Setup and run a test of a particular decay chain
The test configuration is loaded from a JSON object.
This contains the configuration of the model to test and the histograms to
fill, plus the configuration of how to run the test (FSR settings, thread
model, number of threads).
*/
class TestDecayModel {
public:
/// Constructor
explicit TestDecayModel( const nlohmann::json& config );
/// Run the test
void run();
private:
/// Check that all mandatory fields are present in the JSON record
static bool checkMandatoryFields( const nlohmann::json& config );
/// Populate the test configuration from the JSON record
static TestConfig readConfig( const nlohmann::json& config );
/// Run multi-threaded with standard library threading model
TestHistos runStdThreads() const;
/// Run multi-threaded with Intel Thread Building Blocks threading model
TestHistos runTBBThreads() const;
/**
For the specified range of events, run the main body: initialise,
create and read the decay file, generate events
*/
TestHistos runDecayBody( const std::size_t firstEvent,
const std::size_t nEvents ) const;
/// Create the decay file for the decay chain under test
void createDecFile() const;
/// Generate the specified range of events and fill the histograms
void generateEvents( EvtGen& theGen, TestHistos& theHistos,
const std::size_t firstEvent,
const std::size_t nEvents ) const;
/// Calculate the value of the given variable for the generated decay
double getValue( const EvtParticle* rootPart, const std::string& varName,
const int d1, const int d2 ) const;
/// Compare generated histograms with those from a reference file
void compareHistos( const TestHistos& theHistos,
const std::string& refFileName ) const;
/**
\brief Find the index of the daughter with the largest energy
Sign convention: take negative daughter if mother is neutral,
otherwise the one with the same sign as the mother.
*/
int findChargedDaughterWithMaxE( const EvtParticle* parent ) const;
/// Find the particle group for the given particle ID
int getPartGroup( const int PDGId ) const;
/// Check whether the given particle group is of the requested type
bool isPartType( const int group, const std::string& particleType ) const;
/// Calculate the cosine of the acoplanarity angle
double getCosAcoplanarityAngle( const EvtParticle* selectedParent,
const int sel_NDaugMax, const int d1,
const int d2 ) const;
/// The test configuration
const TestConfig m_config;
/// Thread safety mutex
static std::once_flag m_createDecFile_threadlock;
};
#endif