diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml new file mode 100644 index 0000000..57c4e14 --- /dev/null +++ b/.gitlab-ci.yml @@ -0,0 +1,113 @@ +stages: + - build + - test + +variables: + LCG_VERSION: "LCG_98python3" + GCC_VERSION: "10" + CLANG_VERSION: "10" + BUILD_TYPE: "Release" + BUILD_TESTS: "OFF" + BUILD_DOXYGEN: "OFF" + USE_HEPMC3: "ON" + +.production_image: + variables: + LCG_OS: x86_64-centos7 + image: gitlab-registry.cern.ch/ci-tools/ci-worker:cc7 + tags: + - cvmfs + +.lcg_setup: + before_script: + - set +e && source /cvmfs/sft.cern.ch/lcg/views/setupViews.sh $LCG_VERSION $LCG_OS-$LCG_COMPILER; set -e + +.build_template: + stage: build + extends: + - .lcg_setup + script: + - mkdir install + - mkdir build && cd build + - cmake -DCMAKE_BUILD_TYPE:STRING=$BUILD_TYPE -DCMAKE_INSTALL_PREFIX:PATH=$CI_PROJECT_DIR/install -DEVTGEN_HEPMC3:BOOL=$USE_HEPMC3 -DEVTGEN_PYTHIA:BOOL=ON -DEVTGEN_PHOTOS:BOOL=ON -DEVTGEN_TAUOLA:BOOL=ON -DEVTGEN_BUILD_TESTS:BOOL=$BUILD_TESTS -DEVTGEN_BUILD_VALIDATIONS:BOOL=$BUILD_TESTS -DEVTGEN_BUILD_DOXYGEN:BOOL=$BUILD_DOXYGEN $CI_PROJECT_DIR + - cmake --build . + - cmake --build . --target install + +build_clang_opt: + variables: + LCG_COMPILER: "clang$CLANG_VERSION-opt" + extends: + - .production_image + - .build_template + +build_gcc_opt: + variables: + LCG_COMPILER: "gcc$GCC_VERSION-opt" + extends: + - .production_image + - .build_template + +build_hepmc2_gcc_opt: + variables: + LCG_COMPILER: "gcc$GCC_VERSION-opt" + USE_HEPMC3: "OFF" + extends: + - .production_image + - .build_template + +build_gcc_dbg: + variables: + LCG_COMPILER: "gcc$GCC_VERSION-dbg" + BUILD_TYPE: "Debug" + BUILD_TESTS: "ON" + BUILD_DOXYGEN: "ON" + extends: + - .production_image + - .build_template + after_script: + - cd install/share/EvtGen/test + - ./makeModelsJson $CI_PROJECT_DIR > Models.json + - ./makeSrcDepsJson $CI_PROJECT_DIR $CI_PROJECT_DIR/build > SrcDeps.json + artifacts: + paths: + - install + expire_in: 1 day + when: always + +.test_template: + stage: test + variables: + LCG_COMPILER: "gcc$GCC_VERSION-dbg" + extends: + - .production_image + - .lcg_setup + dependencies: + - build_gcc_dbg + artifacts: + paths: + - install/share/EvtGen/test + expire_in: 1 day + when: always + +# TODO - need to copy in the appropriate files to act as references for this run +# and save the resulting files for possible future use as references +# - where to store the reference files? CI cache? EOS? +# - need to add a test case for merge requests + +test_on_push: + extends: + - .test_template + rules: + - if: '$CI_PIPELINE_SOURCE == "push"' + script: + - cd install/share/EvtGen/test + - git diff --numstat $CI_COMMIT_BEFORE_SHA $CI_COMMIT_SHA | awk '{print $NF}' | xargs ./runTests.py Models.json SrcDeps.json + +test_on_schedule: + extends: + - .test_template + rules: + - if: '$CI_PIPELINE_SOURCE == "schedule" && $CI_COMMIT_BRANCH == "master"' + script: + - cd install/share/EvtGen/test + - git diff --numstat `git tag --list 'R*' | tail -n 1` $CI_COMMIT_SHA | awk '{print $NF}' | xargs ./runTests.py Models.json SrcDeps.json diff --git a/EvtGenBase/EvtParticle.hh b/EvtGenBase/EvtParticle.hh index ecaa341..953613a 100644 --- a/EvtGenBase/EvtParticle.hh +++ b/EvtGenBase/EvtParticle.hh @@ -1,499 +1,502 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTPARTICLE_HH #define EVTPARTICLE_HH -//#include #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtSpinDensity.hh" #include "EvtGenBase/EvtSpinType.hh" #include "EvtGenBase/EvtVector4R.hh" #include #include #include #include class EvtDiracSpinor; class EvtVector4C; class EvtTensor4C; class EvtStdHep; class EvtSecondary; class EvtRaritaSchwinger; const int MAX_DAUG = 100; const int MAX_LEVEL = 10; const int MAX_TRIES = 10000; class EvtParticle { public: /** * Default constructor. */ EvtParticle(); /** * Destructor. */ virtual ~EvtParticle(); /** * Returns polarization vector in the parents restframe. */ virtual EvtVector4C epsParent( int i ) const; /** * Returns polarization vector in the particles own restframe. */ virtual EvtVector4C eps( int i ) const; /** * Returns polarization vector in the parents restframe for a photon. */ virtual EvtVector4C epsParentPhoton( int i ); /** * Returns polarization vector in the particles own restframe for a photon. */ virtual EvtVector4C epsPhoton( int i ); /** * Returns Dirac spinor in the parents restframe for a Dirac particle. */ virtual EvtDiracSpinor spParent( int ) const; /** * Returns Dirac spinor in the particles own restframe for a Dirac particle. */ virtual EvtDiracSpinor sp( int ) const; /** * Returns Dirac spinor in the parents restframe for a Neutrino particle. */ virtual EvtDiracSpinor spParentNeutrino() const; /** * Returns Dirac spinor in the particles own restframe for a * Neutrino particle. */ virtual EvtDiracSpinor spNeutrino() const; /** * Returns tensor in the parents restframe for a spin 2 particle. */ virtual EvtTensor4C epsTensorParent( int i ) const; /** * Returns tensor in the particles own restframe for a spin 2 particle. */ virtual EvtTensor4C epsTensor( int i ) const; /** * Returns Rarita-Schwinger spinor in the parents restframe for a * Rarita-Schwinger particle. */ virtual EvtRaritaSchwinger spRSParent( int ) const; /** * Returns Rarita-Schwinger spinor in the particles own restframe for a * Rarita-Schwinger particle. */ virtual EvtRaritaSchwinger spRS( int ) const; /** * Initialiaze particle with id and 4momentum. */ virtual void init( EvtId part_n, const EvtVector4R& p4 ) = 0; /** * Add another daughter to the particle */ void addDaug( EvtParticle* node ); /** * Decay particle */ void decay(); /** * Delete a decay chain */ void deleteTree(); void deleteDaughters( bool keepChannel = false ); /** * Should only be used internally. */ void setChannel( int i ); /** * Creates the daughters in the list of ids and * adds them to the parent. Note that momentum * is left uninitialized, this is _only_ creation. */ void makeDaughters( unsigned int ndaug, EvtId* id ); /** * Creates the daughters in the list of ids and * adds them to the parent. Note that momentum * is left uninitialized, this is _only_ creation. */ void makeDaughters( unsigned int ndaug, std::vector idVector ); /** * Similar to the routine above except that here * momentum is generated according to phase space * daughters are filled with this momentum. */ double initializePhaseSpace( unsigned int numdaughter, EvtId* daughters, bool forceResetMasses = false, double poleSize = -1., int whichTwo1 = 0, int whichTwo2 = 1 ); /** * Get pointer the the i:th daugther. */ - const EvtParticle* getDaug( const int i ) const { return _daug[i]; } EvtParticle* getDaug( const int i ) { return _daug[i]; } /** + * Get const pointer the the i:th daugther. + */ + const EvtParticle* getDaug( const int i ) const { return _daug[i]; } + + /** * Iterates over the particles in a decay chain. */ EvtParticle* nextIter( EvtParticle* rootOfTree = 0 ); /** * Makes stdhep list */ void makeStdHep( EvtStdHep& stdhep, EvtSecondary& secondary, EvtId* stable_parent_ihep ); void makeStdHep( EvtStdHep& stdhep ); /** * Gets 4vector in the labframe, i.e., the frame in which the root * particles momentum is measured. */ EvtVector4R getP4Lab() const; /** * Gets 4vector in the labframe for the 4-momentum before FSR was * generated in the parents decay. The lab frame is where the root * particles momentum is measured. */ EvtVector4R getP4LabBeforeFSR(); /** * Gets 4vector in the particles restframe, i.e. this functiont will * return (m,0,0,0) */ EvtVector4R getP4Restframe() const; /** * Returns the 4position of the particle in the lab frame. */ EvtVector4R get4Pos() const; /** * Returns pointer to parent particle. */ EvtParticle* getParent() const; /** * Makes partptr the idaug:th daugther. */ void insertDaugPtr( int idaug, EvtParticle* partptr ) { _daug[idaug] = partptr; partptr->_parent = this; } /** * Returns mass of particle. */ double mass() const; /** * Used internally to decide if first time particle is decayed. */ int firstornot() const; void setFirstOrNot(); void resetFirstOrNot(); /** * Returns Id of particle. */ EvtId getId() const; /** * Returns the PDG id of the particle */ int getPDGId() const; /** * Returns particle type. */ EvtSpinType::spintype getSpinType() const; /** * Returns number of spin states of the particle. */ int getSpinStates() const; /** * Returns 4momentum in parents restframe. */ const EvtVector4R& getP4() const; /** * Sets the 4momentum in the parents restframe. */ void setP4( const EvtVector4R& p4 ) { _p = p4; _pBeforeFSR = p4; } void setP4WithFSR( const EvtVector4R& p4 ) { _p = p4; } void setFSRP4toZero() { _pBeforeFSR.set( 0.0, 0.0, 0.0, 0.0 ); } /** * Retunrs the decay channel. */ int getChannel() const; /** * Returns number of daugthers. */ size_t getNDaug() const; void resetNDaug() { _ndaug = 0; return; } /** * Prints out the particle "tree" of a given particle. The * tree consists of all daughters (and their daughters, etc) * and their properties. */ void printTree() const; void printTreeRec( unsigned int level ) const; std::string treeStr() const; std::string treeStrRec( unsigned int level ) const; /** * Prints information for the particle. */ void printParticle() const; /** * Set lifetime of the particle in parents restframe. */ void setLifetime( double tau ); /** * Generate lifetime according to pure exponential. */ void setLifetime(); /** * Returns the lifetime. */ - double getLifetime(); + double getLifetime() const; /** * Set diagonal spindensity matrix. */ void setDiagonalSpinDensity(); /** * Set spindensity matrix for e+e- -> V */ void setVectorSpinDensity(); /** * Set forward spin density matrix. */ void setSpinDensityForward( const EvtSpinDensity& rho ) { _rhoForward = rho; } /** * Set forward spin density matrix according to the density matrix * rho in the helicity amplitude basis. */ void setSpinDensityForwardHelicityBasis( const EvtSpinDensity& rho ); void setSpinDensityForwardHelicityBasis( const EvtSpinDensity& rho, double alpha, double beta, double gamma ); /** * Returns a rotation matrix need to rotate the basis state * to the helicity basis. The EvtSpinDensity matrix is just use * as a matrix here. This function is to be implemented in each * derived class. */ virtual EvtSpinDensity rotateToHelicityBasis() const = 0; virtual EvtSpinDensity rotateToHelicityBasis( double alpha, double beta, double gamma ) const = 0; /** * Get forward spin density matrix. */ EvtSpinDensity getSpinDensityForward() { return _rhoForward; } /** * Set backward spin density matrix. */ void setSpinDensityBackward( const EvtSpinDensity& rho ) { _rhoBackward = rho; } /** * Get backward spin density matrix. */ EvtSpinDensity getSpinDensityBackward() { return _rhoBackward; } //Hacks will be removed when better solutions are thought of! //This is used to suppress use of random numbers when doing initialization //of some models. void noLifeTime() { _genlifetime = 0; } //lange - April 29, 2002 void setId( EvtId id ) { _id = id; } void initDecay( bool useMinMass = false ); bool generateMassTree(); double compMassProb(); //setMass will blow away any existing 4vector void setMass( double m ) { _p = EvtVector4R( m, 0.0, 0.0, 0.0 ); } //void setMixed() {_mix=true;} //void setUnMixed() {_mix=false;} //bool getMixed() {return _mix;} //void takeCConj() {EvtGenReport(EVTGEN_INFO,"EvtGen") << "should take conj\n";} //this means that the particle has gone through initDecay // and thus has a mass bool isInitialized() { return _isInit; } bool hasValidP4() { return _validP4; } bool isDecayed() { return _isDecayed; } // decay prob - only relevent if already decayed // and is a scalar particle // returned is a double* that should be prob/probMax double* decayProb() { return _decayProb; } void setDecayProb( double p ); // Return the name of the particle (from the EvtId number) - std::string getName(); + std::string getName() const; // Specify whether the particle has a special named attribute with // a set value. By default, nothing is set, but derived classes // can set this to mean something specific, e.g. if a photon is FSR void setAttribute( std::string attName, int attValue ) { _intAttributes[attName] = attValue; } // Retrieve the integer value for the given attribute name int getAttribute( std::string attName ); // Specify if the particle has a double attribute value, e.g. amplitude weight. // By default, nothing is set, but derived classes can set this to mean something specific void setAttributeDouble( std::string attName, double attValue ) { _dblAttributes[attName] = attValue; } // Retrieve the double value for the given attribute name double getAttributeDouble( std::string attName ); protected: void setp( double e, double px, double py, double pz ) { _p.set( e, px, py, pz ); _pBeforeFSR = _p; } void setp( const EvtVector4R& p4 ) { _p = p4; _pBeforeFSR = _p; } void setpart_num( EvtId particle_number ) { assert( _channel == -10 || _id.getId() == particle_number.getId() || _id.getId() == -1 ); _id = particle_number; } bool _validP4; // A typedef to define the attribute (name, integer) map typedef std::map EvtAttIntMap; EvtAttIntMap _intAttributes; // A typedef to define the attribute (name, double) map typedef std::map EvtAttDblMap; EvtAttDblMap _dblAttributes; private: EvtParticle* _daug[MAX_DAUG]; size_t _ndaug; EvtParticle* _parent; int _channel; int _first; EvtId _id; EvtVector4R _p; EvtVector4R _pBeforeFSR; double _t; bool _isInit; bool _isDecayed; //bool _mix; EvtSpinDensity _rhoForward; EvtSpinDensity _rhoBackward; void makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep, EvtSecondary& secondary, EvtId* stable_parent_ihep ); void makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep ); //This is a hack until things gets straightened out. (Ryd) int _genlifetime; //should never be used, therefor is private. //these does _not_ have an implementation EvtParticle& operator=( const EvtParticle& p ); EvtParticle( const EvtParticle& p ); double* _decayProb; }; #endif diff --git a/EvtGenModels/EvtBTo4piCP.hh b/EvtGenModels/EvtBTo4piCP.hh index dc12d4b..a034d8e 100644 --- a/EvtGenModels/EvtBTo4piCP.hh +++ b/EvtGenModels/EvtBTo4piCP.hh @@ -1,37 +1,38 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTBTO4PICP_HH #define EVTBTO4PICP_HH #include "EvtGenBase/EvtDecayAmp.hh" class EvtParticle; class EvtBTo4piCP : public EvtDecayAmp { public: std::string getName() override; EvtBTo4piCP* clone() override; void init() override; + void initProbMax() override; void decay( EvtParticle* p ) override; }; #endif diff --git a/EvtGenModels/EvtBToKpipiCP.hh b/EvtGenModels/EvtBToKpipiCP.hh index c397a72..520b78b 100644 --- a/EvtGenModels/EvtBToKpipiCP.hh +++ b/EvtGenModels/EvtBToKpipiCP.hh @@ -1,56 +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 . * ***********************************************************************/ #ifndef EVTBTOKPIPICP_HH #define EVTBTOKPIPICP_HH #include "EvtGenBase/EvtDecayAmp.hh" #include "EvtGenBase/EvtVector4R.hh" #include "EvtGenModels/EvtBTo3hCP.hh" class EvtParticle; // Description: Routine to decay B->K pi pi // and has CP violation. // --- This is the routine to be called by the Main generator // to get the decay of B0 -->-- K+ pi- pi0 // The decay proceeeds through three channels: // a) B0 -->-- K*+ pi- ; K*+ -->-- K+ pi0 // b) K*0 pi0 ; K*0bar -->-- K+ pi- // c) K- rho+ ; rho+ -->-- pi+ pi0 // It provides at the same time the CP conjugate decay // B0bar -->-- K- pi+ pi0 class EvtBToKpipiCP : public EvtDecayAmp { public: EvtBToKpipiCP() {} std::string getName() override; EvtBToKpipiCP* clone() override; void init() override; + void initProbMax() override; void decay( EvtParticle* p ) override; private: EvtBTo3hCP generator; }; #endif diff --git a/EvtGenModels/EvtISGW.hh b/EvtGenModels/EvtISGW.hh index ebe44b4..3d1bbc2 100644 --- a/EvtGenModels/EvtISGW.hh +++ b/EvtGenModels/EvtISGW.hh @@ -1,44 +1,45 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTISGW_HH #define EVTISGW_HH #include "EvtGenBase/EvtDecayAmp.hh" #include "EvtGenBase/EvtSemiLeptonicAmp.hh" #include "EvtGenBase/EvtSemiLeptonicFF.hh" #include class EvtParticle; class EvtISGW : public EvtDecayAmp { public: std::string getName() override; EvtDecayBase* clone() override; void decay( EvtParticle* p ) override; void init() override; + void initProbMax() override; private: std::unique_ptr isgwffmodel; std::unique_ptr calcamp; }; #endif diff --git a/EvtGenModels/EvtKstarnunu.hh b/EvtGenModels/EvtKstarnunu.hh index 20dab04..637de19 100644 --- a/EvtGenModels/EvtKstarnunu.hh +++ b/EvtGenModels/EvtKstarnunu.hh @@ -1,38 +1,39 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTKSTARNUNU_HH #define EVTKSTARNUNU_HH #include "EvtGenBase/EvtDecayAmp.hh" class EvtParticle; class EvtKstarnunu : public EvtDecayAmp { public: std::string getName() override; EvtDecayBase* clone() override; void init() override; + void initProbMax() override; void decay( EvtParticle* p ) override; }; #endif diff --git a/EvtGenModels/EvtLambdaB2LambdaV.hh b/EvtGenModels/EvtLambdaB2LambdaV.hh index 81c83d3..3b2044f 100644 --- a/EvtGenModels/EvtLambdaB2LambdaV.hh +++ b/EvtGenModels/EvtLambdaB2LambdaV.hh @@ -1,182 +1,180 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTLAMBDAB2LAMBDAV_HH #define EVTLAMBDAB2LAMBDAV_HH #include "EvtGenBase/EvtDecayProb.hh" -#include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" -#include "EvtGenBase/EvtReport.hh" #include #include namespace VID { enum VectorMesonType { JPSI, OMEGA, RHO, RHO_OMEGA_MIXING }; } // Description: // Class to generate LambdaB -> Lambda(p pi) V(Vp Vm) decays // with V a vector meson such as J/psi (mu+mu-) // Rho (pi+pi-) // Omega (pi+pi-) // Rho-omega mixing (pi+pi-) // // DECAY : LambdaB -> Lambda + vector meson // // d(Sigma) // -------- = 1 + A*B*cos(theta) + 2*A*Re(C*exp(i*phi))*sin(theta) // d(Omega) // // with A (real) : lambdaB helicity asymmetry parameter // B (real) : lambdaB polarisation // C (complex) : lambdaB density matrix element rho+- // // cf : O. Leitner, Z.J Ajaltouni, E. Conte, // PCCF RI 0601, ECT-05-15, LPNHE/2006-01, hep-ph/0602043 class EvtLambdaB2LambdaV : public EvtDecayProb { public: EvtLambdaB2LambdaV(); EvtDecayBase* clone() override; std::string getName() override; void init() override; void initProbMax() override; void decay( EvtParticle* lambdab ) override; private: //class name for report method std::string fname; //meson vector identity VID::VectorMesonType Vtype; //decay dynamics parameters double A; double B; EvtComplex C; //V mass generator method double getVMass( double MASS_LAMBDAB, double MASS_LAMBDA ); //PDF generator method double BreitWignerRelPDF( double m, double _m0, double _g0 ); double RhoOmegaMixingPDF( double m, double _mr, double _gr, double _mo, double _go ); }; //******************************************************************* //* * //* Class EvtLambda2PPiForLambdaB2LambdaV * //* * //******************************************************************* // // DECAY : Lambda -> p + pi- // // d(Sigma) // -------- = 1 + A*B*cos(theta) + 2*A*Re(D*exp(i*phi))*sin(theta) // d(Omega) // // with A (real) : lambda asymmetry parameter // B (real) : lambda polarisation // C (real) : lambdaB polarisation // D (complex) : lambda density matrix element rho+- // // cf : O. Leitner, Z.J Ajaltouni, E. Conte // PCCF RI 0601, ECT-05-15, LPNHE/2006-01, hep-ph/0602043 class EvtLambda2PPiForLambdaB2LambdaV : public EvtDecayProb { public: EvtLambda2PPiForLambdaB2LambdaV(); EvtDecayBase* clone() override; std::string getName() override; void init() override; void initProbMax() override; void decay( EvtParticle* lambda ) override; private: //class name for report method std::string fname; //meson vector identity VID::VectorMesonType Vtype; //decay dynamics parameters double A; double B; double C; EvtComplex D; }; //******************************************************************* //* * //* Class EvtV2VpVmForLambdaB2LambdaV * //* * //******************************************************************* // // DECAY : vector meson V -> Vp + Vm // // d(Sigma) // -------- = (1-3A)*cos(theta)^2 + (1+A) //leptonic decays // d(Omega) // // d(Sigma) // -------- = (3A-1)*cos(theta)^2 + (1-A) //hadronic decays // d(Omega) // // with A (real) : V density matrix element indicating the // probability to be longitudinally polarized // // cf : O. Leitner, Z.J Ajaltouni, E. Conte // PCCF RI 0601, ECT-05-15, LPNHE/2006-01, hep-ph/0602043 class EvtV2VpVmForLambdaB2LambdaV : public EvtDecayProb { public: EvtV2VpVmForLambdaB2LambdaV(); EvtDecayBase* clone() override; std::string getName() override; void init() override; void initProbMax() override; void decay( EvtParticle* V ) override; private: //class name for report method std::string fname; //meson vector identity VID::VectorMesonType Vtype; //decay dynamics parameters double A; }; #endif diff --git a/EvtGenModels/EvtMelikhov.hh b/EvtGenModels/EvtMelikhov.hh index da9b7ad..261d34c 100644 --- a/EvtGenModels/EvtMelikhov.hh +++ b/EvtGenModels/EvtMelikhov.hh @@ -1,47 +1,48 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTMELIKHOV_HH #define EVTMELIKHOV_HH #include "EvtGenBase/EvtDecayAmp.hh" #include "EvtGenBase/EvtSemiLeptonicAmp.hh" #include "EvtGenBase/EvtSemiLeptonicFF.hh" #include class EvtParticle; // Description:Implementation of the Melikhov semileptonic model class EvtMelikhov : public EvtDecayAmp { public: std::string getName() override; EvtDecayBase* clone() override; void decay( EvtParticle* p ) override; void init() override; + void initProbMax() override; private: std::unique_ptr Melikhovffmodel; std::unique_ptr calcamp; }; #endif diff --git a/EvtGenModels/EvtPhiDalitz.hh b/EvtGenModels/EvtPhiDalitz.hh index dec0c51..ada0306 100644 --- a/EvtGenModels/EvtPhiDalitz.hh +++ b/EvtGenModels/EvtPhiDalitz.hh @@ -1,49 +1,49 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTPHIDALITZ_HH #define EVTPHIDALITZ_HH #include "EvtGenBase/EvtDecayAmp.hh" class EvtParticle; class EvtPhiDalitz : public EvtDecayAmp { public: std::string getName() override; EvtDecayBase* clone() override; void init() override; - + void initProbMax() override; void decay( EvtParticle* p ) override; private: double _mRho; double _gRho; double _aD; double _phiD; double _aOmega; double _phiOmega; int _locPip; int _locPim; int _locPi0; }; #endif diff --git a/EvtGenModels/EvtSSSCPT.hh b/EvtGenModels/EvtSSSCPT.hh index 79ff801..33ebbea 100644 --- a/EvtGenModels/EvtSSSCPT.hh +++ b/EvtGenModels/EvtSSSCPT.hh @@ -1,37 +1,45 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTSSSCPT_HH #define EVTSSSCPT_HH #include "EvtGenBase/EvtDecayAmp.hh" class EvtParticle; class EvtSSSCPT : public EvtDecayAmp { public: std::string getName() override; EvtDecayBase* clone() override; void init() override; + void initProbMax() override; void decay( EvtParticle* p ) override; + + private: + // Amplitude coeffs + EvtComplex A, Abar; + EvtComplex P, Q, D, Im; + // Set amplitude coeffs from decay model params + void setAmpCoeffs(); }; #endif diff --git a/EvtGenModels/EvtSVSCPiso.hh b/EvtGenModels/EvtSVSCPiso.hh index f683251..84aca33 100644 --- a/EvtGenModels/EvtSVSCPiso.hh +++ b/EvtGenModels/EvtSVSCPiso.hh @@ -1,44 +1,63 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTSVSCPISO_HH #define EVTSVSCPISO_HH +#include "EvtGenBase/EvtComplex.hh" #include "EvtGenBase/EvtDecayAmp.hh" class EvtParticle; // Description: Routine to decay scalar -> vectors scalar // with CP violation and isospin amplitudes. // More specifically, it is indended to handle // decays like B->rho pi and B->a1 pi. class EvtSVSCPiso : public EvtDecayAmp { public: std::string getName() override; EvtDecayBase* clone() override; void init() override; void initProbMax() override; void decay( EvtParticle* p ) override; + + private: + // Amplitude coefficients + EvtComplex Tp0, Tp0_bar, T0p, T0p_bar; + EvtComplex Tpm, Tpm_bar, Tmp, Tmp_bar; + EvtComplex P1, P1_bar, P0, P0_bar; + + // Amplitudes + EvtComplex A_f, Abar_f; + EvtComplex A_fbar, Abar_fbar; + EvtComplex Apm, Apm_bar, Amp, Amp_bar; + // Charged mode flag + int charged{ 0 }; + + // Set amplitude coeffs from decay model pars + void setAmpCoeffs(); + // Calculate amplitude terms + void calcAmpTerms(); }; #endif diff --git a/EvtGenModels/EvtSingleParticle.hh b/EvtGenModels/EvtSingleParticle.hh index d527769..793a687 100644 --- a/EvtGenModels/EvtSingleParticle.hh +++ b/EvtGenModels/EvtSingleParticle.hh @@ -1,46 +1,47 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTSINGLEPARTICLE_HH #define EVTSINGLEPARTICLE_HH #include "EvtGenBase/EvtDecayIncoherent.hh" class EvtParticle; // Description: //This is a special decay model to generate single particles. class EvtSingleParticle : public EvtDecayIncoherent { public: std::string getName() override; EvtDecayBase* clone() override; void decay( EvtParticle* p ) override; void init() override; + void initProbMax() override; private: double pmin, pmax; double cthetamin, cthetamax; double phimin, phimax; }; #endif diff --git a/EvtGenModels/EvtSll.hh b/EvtGenModels/EvtSll.hh index 9920516..b86551e 100644 --- a/EvtGenModels/EvtSll.hh +++ b/EvtGenModels/EvtSll.hh @@ -1,40 +1,41 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #ifndef EVTSLL_HH #define EVTSLL_HH #include "EvtGenBase/EvtDecayAmp.hh" class EvtParticle; //Class to handle decays of the form SCALAR -> DIRAC DIRAC. class EvtSll : public EvtDecayAmp { public: std::string getName() override; EvtDecayBase* clone() override; void init() override; + void initProbMax() override; void decay( EvtParticle* p ) override; }; #endif diff --git a/src/EvtGenBase/EvtMTree.cpp b/src/EvtGenBase/EvtMTree.cpp index 506ebbb..9ddc973 100644 --- a/src/EvtGenBase/EvtMTree.cpp +++ b/src/EvtGenBase/EvtMTree.cpp @@ -1,464 +1,471 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenBase/EvtMTree.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtKine.hh" #include "EvtGenBase/EvtMBreitWigner.hh" #include "EvtGenBase/EvtMHelAmp.hh" #include "EvtGenBase/EvtMTrivialLS.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtReport.hh" #include #include #include using std::endl; EvtMTree::EvtMTree( const EvtId* idtbl, unsigned int ndaug ) { for ( size_t i = 0; i < ndaug; ++i ) { _lbltbl.push_back( EvtPDL::name( idtbl[i] ) ); } } EvtMTree::~EvtMTree() { for ( size_t i = 0; i < _root.size(); ++i ) delete _root[i]; } bool EvtMTree::parsecheck( char arg, const string& chars ) { bool ret = false; for ( size_t i = 0; i < chars.size(); ++i ) { ret = ret || ( chars[i] == arg ); } return ret; } vector EvtMTree::makeparticles( const string& strid ) { vector particles; vector labels; for ( size_t i = 0; i < _lbltbl.size(); ++i ) { if ( _lbltbl[i] == strid ) labels.push_back( i ); } if ( labels.size() == 0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Error unknown particle label " << strid << endl; ::abort(); } for ( size_t i = 0; i < labels.size(); ++i ) particles.push_back( new EvtMParticle( labels[i], EvtPDL::getId( strid ) ) ); return particles; } EvtMRes* EvtMTree::makeresonance( const EvtId& id, const string& ls, const vector& lsarg, const string& type, const vector& amps, const vector& children ) { EvtMRes* resonance = NULL; EvtMLineShape* lineshape = NULL; if ( ls == "BREITWIGNER" ) { lineshape = new EvtMBreitWigner( id, lsarg ); } else if ( ls == "TRIVIAL" ) { lineshape = new EvtMTrivialLS( id, lsarg ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Lineshape " << lineshape << " not recognized." << endl; ::abort(); } if ( type == "HELAMP" ) { resonance = new EvtMHelAmp( id, lineshape, children, amps ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Model " << type << " not recognized." << endl; ::abort(); } lineshape->setres( resonance ); return resonance; } void EvtMTree::parseerror( bool flag, ptype& c_iter, ptype& c_begin, ptype& c_end ) { if ( !flag ) return; string error; while ( c_begin != c_end ) { if ( c_begin == c_iter ) { error += '_'; error += *c_begin; error += '_'; } else error += *c_begin; ++c_begin; } EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Parse error at: " << error << endl; ::abort(); } string EvtMTree::parseId( ptype& c_iter, ptype& c_begin, ptype& c_end ) { string strid; while ( c_iter != c_end ) { parseerror( parsecheck( *c_iter, ")[]," ), c_iter, c_begin, c_end ); if ( *c_iter == '(' ) { ++c_iter; return strid; } strid += *c_iter; ++c_iter; } return strid; } string EvtMTree::parseKey( ptype& c_iter, ptype& c_begin, ptype& c_end ) { string key; while ( *c_iter != ',' ) { parseerror( c_iter == c_end || parsecheck( *c_iter, "()[]" ), c_iter, c_begin, c_end ); key += *c_iter; ++c_iter; } ++c_iter; parseerror( c_iter == c_end, c_iter, c_begin, c_end ); return key; } vector EvtMTree::parseArg( ptype& c_iter, ptype& c_begin, ptype& c_end ) { vector arg; if ( *c_iter != '[' ) return arg; ++c_iter; string temp; while ( true ) { parseerror( c_iter == c_end || parsecheck( *c_iter, "[()" ), c_iter, c_begin, c_end ); if ( *c_iter == ']' ) { ++c_iter; if ( temp.size() > 0 ) arg.push_back( temp ); break; } if ( *c_iter == ',' ) { arg.push_back( temp ); temp.clear(); ++c_iter; continue; } temp += *c_iter; ++c_iter; } parseerror( c_iter == c_end || *c_iter != ',', c_iter, c_begin, c_end ); ++c_iter; return arg; } vector EvtMTree::parseAmps( ptype& c_iter, ptype& c_begin, ptype& c_end ) { vector parg = parseArg( c_iter, c_begin, c_end ); parseerror( parg.size() == 0, c_iter, c_begin, c_end ); // Get parametrization amplitudes vector::iterator amp_iter = parg.begin(); vector::iterator amp_end = parg.end(); vector amps; while ( amp_iter != amp_end ) { const char* nptr; char* endptr = NULL; double amp = 0.0, phase = 0.0; nptr = ( *amp_iter ).c_str(); amp = strtod( nptr, &endptr ); parseerror( nptr == endptr, c_iter, c_begin, c_end ); ++amp_iter; parseerror( amp_iter == amp_end, c_iter, c_begin, c_end ); nptr = ( *amp_iter ).c_str(); phase = strtod( nptr, &endptr ); parseerror( nptr == endptr, c_iter, c_begin, c_end ); amps.push_back( amp * exp( EvtComplex( 0.0, phase ) ) ); ++amp_iter; } return amps; } vector EvtMTree::duplicate( const vector& list ) const { vector newlist; for ( size_t i = 0; i < list.size(); ++i ) newlist.push_back( list[i]->duplicate() ); return newlist; } // XXX Warning it is unsafe to use cl1 after a call to this function XXX vector> EvtMTree::unionChildren( const string& nodestr, vector>& cl1 ) { vector cl2 = parsenode( nodestr, false ); vector> cl; if ( cl1.size() == 0 ) { for ( size_t i = 0; i < cl2.size(); ++i ) { vector temp( 1, cl2[i] ); cl.push_back( temp ); } return cl; } for ( size_t i = 0; i < cl1.size(); ++i ) { for ( size_t j = 0; j < cl2.size(); ++j ) { vector temp; temp = duplicate( cl1[i] ); temp.push_back( cl2[j]->duplicate() ); cl.push_back( temp ); } } for ( size_t i = 0; i < cl1.size(); ++i ) for ( size_t j = 0; j < cl1[i].size(); ++j ) delete cl1[i][j]; for ( size_t i = 0; i < cl2.size(); ++i ) delete ( cl2[i] ); return cl; } vector> EvtMTree::parseChildren( ptype& c_iter, ptype& c_begin, ptype& c_end ) { bool test = true; int pcount = 0; string nodestr; vector> children; parseerror( c_iter == c_end || *c_iter != '[', c_iter, c_begin, c_end ); ++c_iter; while ( test ) { parseerror( c_iter == c_end || pcount < 0, c_iter, c_begin, c_end ); switch ( *c_iter ) { case ')': --pcount; nodestr += *c_iter; break; case '(': ++pcount; nodestr += *c_iter; break; case ']': if ( pcount == 0 ) { children = unionChildren( nodestr, children ); test = false; } else { nodestr += *c_iter; } break; case ',': if ( pcount == 0 ) { children = unionChildren( nodestr, children ); nodestr.clear(); } else { nodestr += *c_iter; } break; default: nodestr += *c_iter; break; } ++c_iter; } return children; } vector EvtMTree::parsenode( const string& args, bool rootnode ) { ptype c_iter, c_begin, c_end; c_iter = c_begin = args.begin(); c_end = args.end(); string strid = parseId( c_iter, c_begin, c_end ); // Case 1: Particle if ( c_iter == c_end ) return makeparticles( strid ); // Case 2: Resonance - parse further EvtId id = EvtPDL::getId( strid ); parseerror( EvtId( -1, -1 ) == id, c_iter, c_begin, c_end ); string ls; vector lsarg; if ( rootnode ) { ls = "TRIVIAL"; } else { // Get lineshape (e.g. BREITWIGNER) ls = parseKey( c_iter, c_begin, c_end ); lsarg = parseArg( c_iter, c_begin, c_end ); } // Get resonance parametrization type (e.g. HELAMP) string type = parseKey( c_iter, c_begin, c_end ); vector amps = parseAmps( c_iter, c_begin, c_end ); // Children vector> children = parseChildren( c_iter, c_begin, c_end ); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << children.size() << endl; vector resonances; for ( size_t i = 0; i < children.size(); ++i ) { resonances.push_back( makeresonance( id, ls, lsarg, type, amps, children[i] ) ); } parseerror( c_iter == c_end || *c_iter != ')', c_iter, c_begin, c_end ); return resonances; } bool EvtMTree::validTree( const EvtMNode* root ) const { vector res = root->getresonance(); vector check( res.size(), false ); for ( size_t i = 0; i < res.size(); ++i ) { check[res[i]] = true; } bool ret = true; for ( size_t i = 0; i < check.size(); ++i ) { ret = ret && check[i]; } + // Function appears to check child integer indices, but this fails if they are + // not always the first and second ones, so just return true for all cases + ret = true; + return ret; + } void EvtMTree::addtree( const string& str ) { - vector roots = parsenode( str, true ); + // vector roots = parsenode( str, true ); + // Edit previous line to allow the creation of node resonances: + vector roots = parsenode( str, false ); _norm = 0; for ( size_t i = 0; i < roots.size(); ++i ) { if ( validTree( roots[i] ) ) { _root.push_back( roots[i] ); _norm = _norm + 1; } else delete roots[i]; } _norm = 1.0 / sqrt( _norm ); } EvtSpinAmp EvtMTree::getrotation( EvtParticle* p ) const { // Set up the rotation matrix for the root particle (for now) EvtSpinDensity sd = p->rotateToHelicityBasis(); EvtSpinType::spintype type = EvtPDL::getSpinType( _root[0]->getid() ); int twospin = EvtSpinType::getSpin2( type ); vector types( 2, type ); EvtSpinAmp rot( types, EvtComplex( 0.0, 0.0 ) ); vector index = rot.iterallowedinit(); do { rot( index ) = sd.get( ( index[0] + twospin ) / 2, ( index[1] + twospin ) / 2 ); } while ( rot.iterateallowed( index ) ); return rot; } EvtSpinAmp EvtMTree::amplitude( EvtParticle* p ) const { vector product; for ( size_t i = 0; i < p->getNDaug(); ++i ) product.push_back( p->getDaug( i )->getP4Lab() ); if ( _root.size() == 0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "No decay tree present." << endl; ::abort(); } EvtSpinAmp amp = _root[0]->amplitude( product ); for ( size_t i = 1; i < _root.size(); ++i ) { // Assume that helicity amplitude is returned amp += _root[i]->amplitude( product ); } amp = _norm * amp; //ryd return amp; // Do Rotation to Proper Frame EvtSpinAmp newamp = getrotation( p ); newamp.extcont( amp, 1, 0 ); return newamp; } diff --git a/src/EvtGenBase/EvtParticle.cpp b/src/EvtGenBase/EvtParticle.cpp index 2184fb5..c405294 100644 --- a/src/EvtGenBase/EvtParticle.cpp +++ b/src/EvtGenBase/EvtParticle.cpp @@ -1,1314 +1,1314 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtCPUtil.hh" #include "EvtGenBase/EvtDecayTable.hh" #include "EvtGenBase/EvtDiracParticle.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtIdSet.hh" #include "EvtGenBase/EvtNeutrinoParticle.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticleFactory.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtPhotonParticle.hh" #include "EvtGenBase/EvtRadCorr.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtRaritaSchwingerParticle.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtScalarParticle.hh" #include "EvtGenBase/EvtSecondary.hh" #include "EvtGenBase/EvtStatus.hh" #include "EvtGenBase/EvtStdHep.hh" #include "EvtGenBase/EvtStringParticle.hh" #include "EvtGenBase/EvtTensorParticle.hh" #include "EvtGenBase/EvtVectorParticle.hh" #include #include #include #include #include using std::endl; EvtParticle::~EvtParticle() { delete _decayProb; } EvtParticle::EvtParticle() { _ndaug = 0; _parent = 0; _channel = -10; _t = 0.0; _genlifetime = 1; _first = 1; _isInit = false; _validP4 = false; _isDecayed = false; _decayProb = 0; _intAttributes.clear(); _dblAttributes.clear(); // _mix=false; } void EvtParticle::setFirstOrNot() { _first = 0; } void EvtParticle::resetFirstOrNot() { _first = 1; } void EvtParticle::setChannel( int i ) { _channel = i; } EvtParticle* EvtParticle::getParent() const { return _parent; } void EvtParticle::setLifetime( double tau ) { _t = tau; } void EvtParticle::setLifetime() { if ( _genlifetime ) { _t = -log( EvtRandom::Flat() ) * EvtPDL::getctau( getId() ); } } -double EvtParticle::getLifetime() +double EvtParticle::getLifetime() const { return _t; } void EvtParticle::addDaug( EvtParticle* node ) { node->_daug[node->_ndaug++] = this; _ndaug = 0; _parent = node; } int EvtParticle::firstornot() const { return _first; } EvtId EvtParticle::getId() const { return _id; } int EvtParticle::getPDGId() const { return EvtPDL::getStdHep( _id ); } EvtSpinType::spintype EvtParticle::getSpinType() const { return EvtPDL::getSpinType( _id ); } int EvtParticle::getSpinStates() const { return EvtSpinType::getSpinStates( EvtPDL::getSpinType( _id ) ); } const EvtVector4R& EvtParticle::getP4() const { return _p; } int EvtParticle::getChannel() const { return _channel; } size_t EvtParticle::getNDaug() const { return _ndaug; } double EvtParticle::mass() const { return _p.mass(); } void EvtParticle::setDiagonalSpinDensity() { _rhoForward.setDiag( getSpinStates() ); } void EvtParticle::setVectorSpinDensity() { if ( getSpinStates() != 3 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Error in EvtParticle::setVectorSpinDensity" << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "spin_states:" << getSpinStates() << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "particle:" << EvtPDL::name( _id ).c_str() << endl; ::abort(); } EvtSpinDensity rho; //Set helicity +1 and -1 to 1. rho.setDiag( getSpinStates() ); rho.set( 1, 1, EvtComplex( 0.0, 0.0 ) ); setSpinDensityForwardHelicityBasis( rho ); } void EvtParticle::setSpinDensityForwardHelicityBasis( const EvtSpinDensity& rho ) { EvtSpinDensity R = rotateToHelicityBasis(); assert( R.getDim() == rho.getDim() ); int n = rho.getDim(); _rhoForward.setDim( n ); int i, j, k, l; for ( i = 0; i < n; i++ ) { for ( j = 0; j < n; j++ ) { EvtComplex tmp = 0.0; for ( k = 0; k < n; k++ ) { for ( l = 0; l < n; l++ ) { tmp += R.get( l, i ) * rho.get( l, k ) * conj( R.get( k, j ) ); } } _rhoForward.set( i, j, tmp ); } } } void EvtParticle::setSpinDensityForwardHelicityBasis( const EvtSpinDensity& rho, double alpha, double beta, double gamma ) { EvtSpinDensity R = rotateToHelicityBasis( alpha, beta, gamma ); assert( R.getDim() == rho.getDim() ); int n = rho.getDim(); _rhoForward.setDim( n ); int i, j, k, l; for ( i = 0; i < n; i++ ) { for ( j = 0; j < n; j++ ) { EvtComplex tmp = 0.0; for ( k = 0; k < n; k++ ) { for ( l = 0; l < n; l++ ) { tmp += R.get( l, i ) * rho.get( l, k ) * conj( R.get( k, j ) ); } } _rhoForward.set( i, j, tmp ); } } } void EvtParticle::initDecay( bool useMinMass ) { EvtParticle* p = this; // carefull - the parent mass might be fixed in stone.. EvtParticle* par = p->getParent(); double parMass = -1.; if ( par != 0 ) { if ( par->hasValidP4() ) parMass = par->mass(); for ( size_t i = 0; i < par->getNDaug(); i++ ) { EvtParticle* tDaug = par->getDaug( i ); if ( p != tDaug ) parMass -= EvtPDL::getMinMass( tDaug->getId() ); } } if ( _isInit ) { //we have already been here - just reroll the masses! if ( _ndaug > 0 ) { for ( size_t ii = 0; ii < _ndaug; ii++ ) { if ( _ndaug == 1 || EvtPDL::getWidth( p->getDaug( ii )->getId() ) > 0.0000001 ) p->getDaug( ii )->initDecay( useMinMass ); else p->getDaug( ii )->setMass( EvtPDL::getMeanMass( p->getDaug( ii )->getId() ) ); } } EvtId* dauId = 0; double* dauMasses = 0; if ( _ndaug > 0 ) { dauId = new EvtId[_ndaug]; dauMasses = new double[_ndaug]; for ( size_t j = 0; j < _ndaug; j++ ) { dauId[j] = p->getDaug( j )->getId(); dauMasses[j] = p->getDaug( j )->mass(); } } EvtId* parId = 0; EvtId* othDauId = 0; EvtParticle* tempPar = p->getParent(); if ( tempPar ) { parId = new EvtId( tempPar->getId() ); if ( tempPar->getNDaug() == 2 ) { if ( tempPar->getDaug( 0 ) == this ) othDauId = new EvtId( tempPar->getDaug( 1 )->getId() ); else othDauId = new EvtId( tempPar->getDaug( 0 )->getId() ); } } if ( p->getParent() && _validP4 == false ) { if ( !useMinMass ) { p->setMass( EvtPDL::getRandMass( p->getId(), parId, _ndaug, dauId, othDauId, parMass, dauMasses ) ); } else p->setMass( EvtPDL::getMinMass( p->getId() ) ); } if ( parId ) delete parId; if ( othDauId ) delete othDauId; if ( dauId ) delete[] dauId; if ( dauMasses ) delete[] dauMasses; return; } //Will include effects of mixing here //added by Lange Jan4,2000 static EvtId BS0 = EvtPDL::getId( "B_s0" ); static EvtId BSB = EvtPDL::getId( "anti-B_s0" ); static EvtId BD0 = EvtPDL::getId( "B0" ); static EvtId BDB = EvtPDL::getId( "anti-B0" ); static EvtId D0 = EvtPDL::getId( "D0" ); static EvtId D0B = EvtPDL::getId( "anti-D0" ); static EvtId U4S = EvtPDL::getId( "Upsilon(4S)" ); static EvtIdSet borUps( BS0, BSB, BD0, BDB, U4S ); //only makes sense if there is no parent particle which is a B or an Upsilon bool hasBorUps = false; if ( getParent() && borUps.contains( getParent()->getId() ) ) hasBorUps = true; // if ( (getNDaug()==0)&&(getParent()==0) && (getId()==BS0||getId()==BSB||getId()==BD0||getId()==BDB)){ EvtId thisId = getId(); // remove D0 mixing for now. // if ( (getNDaug()==0 && !hasBorUps) && (thisId==BS0||thisId==BSB||thisId==BD0||thisId==BDB||thisId==D0||thisId==D0B)){ if ( ( getNDaug() == 0 && !hasBorUps ) && ( thisId == BS0 || thisId == BSB || thisId == BD0 || thisId == BDB ) ) { double t; int mix; EvtCPUtil::getInstance()->incoherentMix( getId(), t, mix ); setLifetime( t ); if ( mix ) { EvtScalarParticle* scalar_part; scalar_part = new EvtScalarParticle; if ( getId() == BS0 ) { EvtVector4R p_init( EvtPDL::getMass( BSB ), 0.0, 0.0, 0.0 ); scalar_part->init( EvtPDL::chargeConj( getId() ), p_init ); } else if ( getId() == BSB ) { EvtVector4R p_init( EvtPDL::getMass( BS0 ), 0.0, 0.0, 0.0 ); scalar_part->init( EvtPDL::chargeConj( getId() ), p_init ); } else if ( getId() == BD0 ) { EvtVector4R p_init( EvtPDL::getMass( BDB ), 0.0, 0.0, 0.0 ); scalar_part->init( EvtPDL::chargeConj( getId() ), p_init ); } else if ( getId() == BDB ) { EvtVector4R p_init( EvtPDL::getMass( BD0 ), 0.0, 0.0, 0.0 ); scalar_part->init( EvtPDL::chargeConj( getId() ), p_init ); } else if ( getId() == D0 ) { EvtVector4R p_init( EvtPDL::getMass( D0B ), 0.0, 0.0, 0.0 ); scalar_part->init( EvtPDL::chargeConj( getId() ), p_init ); } else if ( getId() == D0B ) { EvtVector4R p_init( EvtPDL::getMass( D0 ), 0.0, 0.0, 0.0 ); scalar_part->init( EvtPDL::chargeConj( getId() ), p_init ); } scalar_part->setLifetime( 0 ); scalar_part->setDiagonalSpinDensity(); insertDaugPtr( 0, scalar_part ); _ndaug = 1; _isInit = true; p = scalar_part; p->initDecay( useMinMass ); return; } } EvtDecayBase* decayer; decayer = EvtDecayTable::getInstance()->getDecayFunc( p ); if ( decayer ) { p->makeDaughters( decayer->nRealDaughters(), decayer->getDaugs() ); //then loop over the daughters and init their decay for ( size_t i = 0; i < p->getNDaug(); i++ ) { // std::cout << EvtPDL::name(p->getDaug(i)->getId()) << " " << i << " " << p->getDaug(i)->getSpinType() << " " << EvtPDL::name(p->getId()) << std::endl; if ( EvtPDL::getWidth( p->getDaug( i )->getId() ) > 0.0000001 ) p->getDaug( i )->initDecay( useMinMass ); else p->getDaug( i )->setMass( EvtPDL::getMeanMass( p->getDaug( i )->getId() ) ); } } int j; EvtId* dauId = 0; double* dauMasses = 0; int nDaugT = p->getNDaug(); if ( nDaugT > 0 ) { dauId = new EvtId[nDaugT]; dauMasses = new double[nDaugT]; for ( j = 0; j < nDaugT; j++ ) { dauId[j] = p->getDaug( j )->getId(); dauMasses[j] = p->getDaug( j )->mass(); } } EvtId* parId = 0; EvtId* othDauId = 0; EvtParticle* tempPar = p->getParent(); if ( tempPar ) { parId = new EvtId( tempPar->getId() ); if ( tempPar->getNDaug() == 2 ) { if ( tempPar->getDaug( 0 ) == this ) othDauId = new EvtId( tempPar->getDaug( 1 )->getId() ); else othDauId = new EvtId( tempPar->getDaug( 0 )->getId() ); } } if ( p->getParent() && p->hasValidP4() == false ) { if ( !useMinMass ) { p->setMass( EvtPDL::getRandMass( p->getId(), parId, p->getNDaug(), dauId, othDauId, parMass, dauMasses ) ); } else { p->setMass( EvtPDL::getMinMass( p->getId() ) ); } } if ( parId ) delete parId; if ( othDauId ) delete othDauId; if ( dauId ) delete[] dauId; if ( dauMasses ) delete[] dauMasses; _isInit = true; } void EvtParticle::decay() { //P is particle to decay, typically 'this' but sometime //modified by mixing EvtParticle* p = this; //Did it mix? //if ( p->getMixed() ) { //should take C(p) - this should only //happen the first time we call decay for this //particle //p->takeCConj(); // p->setUnMixed(); //} EvtDecayBase* decayer; decayer = EvtDecayTable::getInstance()->getDecayFunc( p ); // if ( decayer ) { // EvtGenReport(EVTGEN_INFO,"EvtGen") << "calling decay for " << EvtPDL::name(p->getId()) << " " << p->mass() << " " << p->getP4() << " " << p->getNDaug() << " " << p << endl; // EvtGenReport(EVTGEN_INFO,"EvtGen") << "NDaug= " << decayer->getNDaug() << endl; // int ti; // for ( ti=0; tigetNDaug(); ti++) // EvtGenReport(EVTGEN_INFO,"EvtGen") << "Daug " << ti << " " << EvtPDL::name(decayer->getDaug(ti)) << endl; // } //if (p->_ndaug>0) { // EvtGenReport(EVTGEN_INFO,"EvtGen") <<"Is decaying particle with daughters!!!!!"<getId() ) << " with mass " << p->mass() << " to decay channel number " << _channel << endl; _isDecayed = false; return; } static EvtId BS0 = EvtPDL::getId( "B_s0" ); static EvtId BSB = EvtPDL::getId( "anti-B_s0" ); static EvtId BD0 = EvtPDL::getId( "B0" ); static EvtId BDB = EvtPDL::getId( "anti-B0" ); // static EvtId D0=EvtPDL::getId("D0"); // static EvtId D0B=EvtPDL::getId("anti-D0"); EvtId thisId = getId(); // remove D0 mixing for now.. // if ( _ndaug==1 && (thisId==BS0||thisId==BSB||thisId==BD0||thisId==BDB||thisId==D0||thisId==D0B) ) { if ( _ndaug == 1 && ( thisId == BS0 || thisId == BSB || thisId == BD0 || thisId == BDB ) ) { p = p->getDaug( 0 ); decayer = EvtDecayTable::getInstance()->getDecayFunc( p ); } //now we have accepted a set of masses - time if ( decayer != 0 ) { decayer->makeDecay( p ); } else { p->_rhoBackward.setDiag( p->getSpinStates() ); } _isDecayed = true; return; } bool EvtParticle::generateMassTree() { bool isOK( true ); double massProb = 1.; double ranNum = 2.; int counter = 0; EvtParticle* p = this; while ( massProb < ranNum ) { //check it out the first time. p->initDecay(); massProb = p->compMassProb(); ranNum = EvtRandom::Flat(); counter++; if ( counter > 10000 ) { if ( counter == 10001 ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Too many iterations to determine the mass tree. Parent mass= " << p->mass() << " " << massProb << endl; p->printTree(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "will take next combo with non-zero likelihood\n"; } if ( massProb > 0. ) massProb = 2.0; if ( counter > 20000 ) { // one last try - take the minimum masses p->initDecay( true ); p->printTree(); massProb = p->compMassProb(); if ( massProb > 0. ) { massProb = 2.0; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Taking the minimum mass of all particles in the chain\n"; } else { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Sorry, no luck finding a valid set of masses. This may be a pathological combo\n"; isOK = false; break; } } } } return isOK; } double EvtParticle::compMassProb() { EvtParticle* p = this; double mass = p->mass(); double parMass = 0.; if ( p->getParent() ) { parMass = p->getParent()->mass(); } int nDaug = p->getNDaug(); double* dMasses = 0; int i; if ( nDaug > 0 ) { dMasses = new double[nDaug]; for ( i = 0; i < nDaug; i++ ) dMasses[i] = p->getDaug( i )->mass(); } double temp = 1.0; temp = EvtPDL::getMassProb( p->getId(), mass, parMass, nDaug, dMasses ); //If the particle already has a mass, we dont need to include //it in the probability calculation if ( ( !p->getParent() || _validP4 ) && temp > 0.0 ) temp = 1.; delete[] dMasses; for ( i = 0; i < nDaug; i++ ) { temp *= p->getDaug( i )->compMassProb(); } return temp; } void EvtParticle::deleteDaughters( bool keepChannel ) { for ( size_t i = 0; i < _ndaug; i++ ) { _daug[i]->deleteTree(); } _ndaug = 0; if ( !keepChannel ) _channel = -10; _first = 1; _isInit = false; } void EvtParticle::deleteTree() { this->deleteDaughters(); delete this; } EvtVector4C EvtParticle::epsParent( int i ) const { EvtVector4C temp; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th polarization vector." << " I.e. you thought it was a" << " vector particle!" << endl; ::abort(); return temp; } EvtVector4C EvtParticle::eps( int i ) const { EvtVector4C temp; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th polarization vector." << " I.e. you thought it was a" << " vector particle!" << endl; ::abort(); return temp; } EvtVector4C EvtParticle::epsParentPhoton( int i ) { EvtVector4C temp; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th polarization vector of photon." << " I.e. you thought it was a" << " photon particle!" << endl; ::abort(); return temp; } EvtVector4C EvtParticle::epsPhoton( int i ) { EvtVector4C temp; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th polarization vector of a photon." << " I.e. you thought it was a" << " photon particle!" << endl; ::abort(); return temp; } EvtDiracSpinor EvtParticle::spParent( int i ) const { EvtDiracSpinor tempD; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th dirac spinor." << " I.e. you thought it was a" << " Dirac particle!" << endl; ::abort(); return tempD; } EvtDiracSpinor EvtParticle::sp( int i ) const { EvtDiracSpinor tempD; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th dirac spinor." << " I.e. you thought it was a" << " Dirac particle!" << endl; ::abort(); return tempD; } EvtDiracSpinor EvtParticle::spParentNeutrino() const { EvtDiracSpinor tempD; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the " << "dirac spinor." << " I.e. you thought it was a" << " neutrino particle!" << endl; ::abort(); return tempD; } EvtDiracSpinor EvtParticle::spNeutrino() const { EvtDiracSpinor tempD; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the " << "dirac spinor." << " I.e. you thought it was a" << " neutrino particle!" << endl; ::abort(); return tempD; } EvtTensor4C EvtParticle::epsTensorParent( int i ) const { EvtTensor4C tempC; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th tensor." << " I.e. you thought it was a" << " Tensor particle!" << endl; ::abort(); return tempC; } EvtTensor4C EvtParticle::epsTensor( int i ) const { EvtTensor4C tempC; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th tensor." << " I.e. you thought it was a" << " Tensor particle!" << endl; ::abort(); return tempC; } EvtRaritaSchwinger EvtParticle::spRSParent( int i ) const { EvtRaritaSchwinger tempD; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th Rarita-Schwinger spinor." << " I.e. you thought it was a" << " RaritaSchwinger particle!" << std::endl; ::abort(); return tempD; } EvtRaritaSchwinger EvtParticle::spRS( int i ) const { EvtRaritaSchwinger tempD; printParticle(); EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "and you have asked for the:" << i << "th Rarita-Schwinger spinor." << " I.e. you thought it was a" << " RaritaSchwinger particle!" << std::endl; ::abort(); return tempD; } EvtVector4R EvtParticle::getP4Lab() const { EvtVector4R temp, mom; const EvtParticle* ptemp; temp = this->getP4(); ptemp = this; while ( ptemp->getParent() != 0 ) { ptemp = ptemp->getParent(); mom = ptemp->getP4(); temp = boostTo( temp, mom ); } return temp; } EvtVector4R EvtParticle::getP4LabBeforeFSR() { EvtVector4R temp, mom; EvtParticle* ptemp; temp = this->_pBeforeFSR; ptemp = this; while ( ptemp->getParent() != 0 ) { ptemp = ptemp->getParent(); mom = ptemp->getP4(); temp = boostTo( temp, mom ); } return temp; } EvtVector4R EvtParticle::getP4Restframe() const { return EvtVector4R( mass(), 0.0, 0.0, 0.0 ); } EvtVector4R EvtParticle::get4Pos() const { EvtVector4R temp, mom; EvtParticle* ptemp; temp.set( 0.0, 0.0, 0.0, 0.0 ); ptemp = getParent(); if ( ptemp == 0 ) return temp; temp = ( ptemp->_t / ptemp->mass() ) * ( ptemp->getP4() ); while ( ptemp->getParent() != 0 ) { ptemp = ptemp->getParent(); mom = ptemp->getP4(); temp = boostTo( temp, mom ); temp = temp + ( ptemp->_t / ptemp->mass() ) * ( ptemp->getP4() ); } return temp; } EvtParticle* EvtParticle::nextIter( EvtParticle* rootOfTree ) { EvtParticle* bpart; EvtParticle* current; current = this; size_t i; if ( _ndaug != 0 ) return _daug[0]; do { bpart = current->_parent; if ( bpart == 0 ) return 0; i = 0; while ( bpart->_daug[i] != current ) { i++; } if ( bpart == rootOfTree ) { if ( i + 1 == bpart->_ndaug ) return 0; } i++; current = bpart; } while ( i >= bpart->_ndaug ); return bpart->_daug[i]; } void EvtParticle::makeStdHep( EvtStdHep& stdhep, EvtSecondary& secondary, EvtId* list_of_stable ) { //first add particle to the stdhep list; stdhep.createParticle( getP4Lab(), get4Pos(), -1, -1, EvtPDL::getStdHep( getId() ) ); int ii = 0; //lets see if this is a longlived particle and terminate the //list building! while ( list_of_stable[ii] != EvtId( -1, -1 ) ) { if ( getId() == list_of_stable[ii] ) { secondary.createSecondary( 0, this ); return; } ii++; } for ( size_t i = 0; i < _ndaug; i++ ) { stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(), 0, 0, EvtPDL::getStdHep( _daug[i]->getId() ) ); } for ( size_t i = 0; i < _ndaug; i++ ) { _daug[i]->makeStdHepRec( 1 + i, 1 + i, stdhep, secondary, list_of_stable ); } return; } void EvtParticle::makeStdHep( EvtStdHep& stdhep ) { //first add particle to the stdhep list; stdhep.createParticle( getP4Lab(), get4Pos(), -1, -1, EvtPDL::getStdHep( getId() ) ); for ( size_t i = 0; i < _ndaug; i++ ) { stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(), 0, 0, EvtPDL::getStdHep( _daug[i]->getId() ) ); } for ( size_t i = 0; i < _ndaug; i++ ) { _daug[i]->makeStdHepRec( 1 + i, 1 + i, stdhep ); } return; } void EvtParticle::makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep, EvtSecondary& secondary, EvtId* list_of_stable ) { int ii = 0; //lets see if this is a longlived particle and terminate the //list building! while ( list_of_stable[ii] != EvtId( -1, -1 ) ) { if ( getId() == list_of_stable[ii] ) { secondary.createSecondary( firstparent, this ); return; } ii++; } int parent_num = stdhep.getNPart(); for ( size_t i = 0; i < _ndaug; i++ ) { stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(), firstparent, lastparent, EvtPDL::getStdHep( _daug[i]->getId() ) ); } for ( size_t i = 0; i < _ndaug; i++ ) { _daug[i]->makeStdHepRec( parent_num + i, parent_num + i, stdhep, secondary, list_of_stable ); } return; } void EvtParticle::makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep ) { int parent_num = stdhep.getNPart(); for ( size_t i = 0; i < _ndaug; i++ ) { stdhep.createParticle( _daug[i]->getP4Lab(), _daug[i]->get4Pos(), firstparent, lastparent, EvtPDL::getStdHep( _daug[i]->getId() ) ); } for ( size_t i = 0; i < _ndaug; i++ ) { _daug[i]->makeStdHepRec( parent_num + i, parent_num + i, stdhep ); } return; } void EvtParticle::printTreeRec( unsigned int level ) const { size_t newlevel, i; newlevel = level + 1; if ( _ndaug != 0 ) { if ( level > 0 ) { for ( i = 0; i < ( 5 * level ); i++ ) { EvtGenReport( EVTGEN_INFO, "" ) << " "; } } EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::name( _id ).c_str(); EvtGenReport( EVTGEN_INFO, "" ) << " -> "; for ( i = 0; i < _ndaug; i++ ) { EvtGenReport( EVTGEN_INFO, "" ) << EvtPDL::name( _daug[i]->getId() ).c_str() << " "; } for ( i = 0; i < _ndaug; i++ ) { EvtGenReport( EVTGEN_INFO, "" ) << _daug[i]->mass() << " " << _daug[i]->getP4() << " " << _daug[i]->getSpinStates() << "; "; } EvtGenReport( EVTGEN_INFO, "" ) << endl; for ( i = 0; i < _ndaug; i++ ) { _daug[i]->printTreeRec( newlevel ); } } } void EvtParticle::printTree() const { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is the current decay chain" << endl; EvtGenReport( EVTGEN_INFO, "" ) << "This top particle is " << EvtPDL::name( _id ).c_str() << " " << this->mass() << " " << this->getP4() << endl; this->printTreeRec( 0 ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "End of decay chain." << endl; } std::string EvtParticle::treeStrRec( unsigned int level ) const { size_t newlevel, i; newlevel = level + 1; std::string retval = ""; for ( i = 0; i < _ndaug; i++ ) { retval += EvtPDL::name( _daug[i]->getId() ); if ( _daug[i]->getNDaug() > 0 ) { retval += " ("; retval += _daug[i]->treeStrRec( newlevel ); retval += ") "; } else { if ( i + 1 != _ndaug ) retval += " "; } } return retval; } std::string EvtParticle::treeStr() const { std::string retval = EvtPDL::name( _id ); retval += " -> "; retval += treeStrRec( 0 ); return retval; } void EvtParticle::printParticle() const { switch ( EvtPDL::getSpinType( _id ) ) { case EvtSpinType::SCALAR: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is a scalar particle:" << EvtPDL::name( _id ).c_str() << "\n"; break; case EvtSpinType::VECTOR: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is a vector particle:" << EvtPDL::name( _id ).c_str() << "\n"; break; case EvtSpinType::TENSOR: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is a tensor particle:" << EvtPDL::name( _id ).c_str() << "\n"; break; case EvtSpinType::DIRAC: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is a dirac particle:" << EvtPDL::name( _id ).c_str() << "\n"; break; case EvtSpinType::PHOTON: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is a photon:" << EvtPDL::name( _id ).c_str() << "\n"; break; case EvtSpinType::NEUTRINO: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is a neutrino:" << EvtPDL::name( _id ).c_str() << "\n"; break; case EvtSpinType::STRING: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "This is a string:" << EvtPDL::name( _id ).c_str() << "\n"; break; default: EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Unknown particle type in EvtParticle::printParticle()" << endl; break; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Number of daughters:" << _ndaug << "\n"; } void init_vector( EvtParticle** part ) { *part = new EvtVectorParticle; } void init_scalar( EvtParticle** part ) { *part = new EvtScalarParticle; } void init_tensor( EvtParticle** part ) { *part = new EvtTensorParticle; } void init_dirac( EvtParticle** part ) { *part = new EvtDiracParticle; } void init_photon( EvtParticle** part ) { *part = new EvtPhotonParticle; } void init_neutrino( EvtParticle** part ) { *part = new EvtNeutrinoParticle; } void init_string( EvtParticle** part ) { *part = new EvtStringParticle; } double EvtParticle::initializePhaseSpace( unsigned int numdaughter, EvtId* daughters, bool forceDaugMassReset, double poleSize, int whichTwo1, int whichTwo2 ) { double m_b; unsigned int i; //lange // this->makeDaughters(numdaughter,daughters); static EvtVector4R p4[100]; static double mass[100]; m_b = this->mass(); //lange - Jan2,2002 - Need to check to see if the daughters of the parent // have changed. If so, delete them and start over. //EvtGenReport(EVTGEN_INFO,"EvtGen") << "the parent is\n"; //if ( this->getParent() ) { // if ( this->getParent()->getParent() ) this->getParent()->getParent()->printTree(); // this->getParent()->printTree(); //} //EvtGenReport(EVTGEN_INFO,"EvtGen") << "and this is\n"; //if ( this) this->printTree(); bool resetDaughters = false; if ( numdaughter != this->getNDaug() && this->getNDaug() > 0 ) resetDaughters = true; if ( numdaughter == this->getNDaug() ) for ( i = 0; i < numdaughter; i++ ) { if ( this->getDaug( i )->getId() != daughters[i] ) resetDaughters = true; //EvtGenReport(EVTGEN_INFO,"EvtGen") << EvtPDL::name(this->getDaug(i)->getId()) // << " " << EvtPDL::name(daughters[i]) << endl; } if ( resetDaughters || forceDaugMassReset ) { bool t1 = true; //but keep the decay channel of the parent. this->deleteDaughters( t1 ); this->makeDaughters( numdaughter, daughters ); bool massTreeOK = this->generateMassTree(); if ( massTreeOK == false ) { return 0.0; } } double weight = 0.; for ( i = 0; i < numdaughter; i++ ) { mass[i] = this->getDaug( i )->mass(); } if ( poleSize < -0.1 ) { //special case to enforce 4-momentum conservation in 1->1 decays if ( numdaughter == 1 ) { this->getDaug( 0 )->init( daughters[0], EvtVector4R( m_b, 0.0, 0.0, 0.0 ) ); } else { EvtGenKine::PhaseSpace( numdaughter, mass, p4, m_b ); for ( i = 0; i < numdaughter; i++ ) { this->getDaug( i )->init( daughters[i], p4[i] ); } } } else { if ( numdaughter != 3 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Only can generate pole phase space " << "distributions for 3 body final states" << endl << "Will terminate." << endl; ::abort(); } bool ok = false; if ( ( whichTwo1 == 1 && whichTwo2 == 0 ) || ( whichTwo1 == 0 && whichTwo2 == 1 ) ) { weight = EvtGenKine::PhaseSpacePole( m_b, mass[0], mass[1], mass[2], poleSize, p4 ); this->getDaug( 0 )->init( daughters[0], p4[0] ); this->getDaug( 1 )->init( daughters[1], p4[1] ); this->getDaug( 2 )->init( daughters[2], p4[2] ); ok = true; } if ( ( whichTwo1 == 1 && whichTwo2 == 2 ) || ( whichTwo1 == 2 && whichTwo2 == 1 ) ) { weight = EvtGenKine::PhaseSpacePole( m_b, mass[2], mass[1], mass[0], poleSize, p4 ); this->getDaug( 0 )->init( daughters[0], p4[2] ); this->getDaug( 1 )->init( daughters[1], p4[1] ); this->getDaug( 2 )->init( daughters[2], p4[0] ); ok = true; } if ( ( whichTwo1 == 0 && whichTwo2 == 2 ) || ( whichTwo1 == 2 && whichTwo2 == 0 ) ) { weight = EvtGenKine::PhaseSpacePole( m_b, mass[1], mass[0], mass[2], poleSize, p4 ); this->getDaug( 0 )->init( daughters[0], p4[1] ); this->getDaug( 1 )->init( daughters[1], p4[0] ); this->getDaug( 2 )->init( daughters[2], p4[2] ); ok = true; } if ( !ok ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Invalid pair of particle to generate a pole dist " << whichTwo1 << " " << whichTwo2 << endl << "Will terminate." << endl; ::abort(); } } return weight; } void EvtParticle::makeDaughters( unsigned int ndaugstore, std::vector idVector ) { // Convert the STL vector method to use the array method for now, since the // array method pervades most of the EvtGen code... unsigned int nVector = idVector.size(); if ( nVector < ndaugstore ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Asking to make " << ndaugstore << " daughters when there " << "are only " << nVector << " EvtId values available" << endl; return; } EvtId* idArray = new EvtId[ndaugstore]; unsigned int i; for ( i = 0; i < ndaugstore; i++ ) { idArray[i] = idVector[i]; } this->makeDaughters( ndaugstore, idArray ); delete[] idArray; } void EvtParticle::makeDaughters( unsigned int ndaugstore, EvtId* id ) { unsigned int i; if ( _channel < 0 ) { setChannel( 0 ); } EvtParticle* pdaug; if ( _ndaug != 0 ) { if ( _ndaug != ndaugstore ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Asking to make a different number of " << "daughters than what was previously created." << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Original parent:" << EvtPDL::name( _id ) << endl; for ( size_t i = 0; i < _ndaug; i++ ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Original daugther:" << EvtPDL::name( getDaug( i )->getId() ) << endl; } for ( size_t i = 0; i < ndaugstore; i++ ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "New Daug:" << EvtPDL::name( id[i] ) << endl; } EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate." << endl; ::abort(); } } else { for ( i = 0; i < ndaugstore; i++ ) { pdaug = EvtParticleFactory::particleFactory( EvtPDL::getSpinType( id[i] ) ); pdaug->setId( id[i] ); pdaug->addDaug( this ); } } //else } //makeDaughters void EvtParticle::setDecayProb( double prob ) { if ( _decayProb == 0 ) _decayProb = new double; *_decayProb = prob; } -std::string EvtParticle::getName() +std::string EvtParticle::getName() const { std::string theName = _id.getName(); return theName; } int EvtParticle::getAttribute( std::string attName ) { // Retrieve the attribute integer if the name exists. // Otherwise, simply return 0 int attValue = 0; EvtAttIntMap::iterator mapIter; if ( ( mapIter = _intAttributes.find( attName ) ) != _intAttributes.end() ) { attValue = mapIter->second; } return attValue; } double EvtParticle::getAttributeDouble( std::string attName ) { // Retrieve the attribute double if the name exists. // Otherwise, simply return 0.0 double attValue = 0.0; EvtAttDblMap::iterator mapIter; if ( ( mapIter = _dblAttributes.find( attName ) ) != _dblAttributes.end() ) { attValue = mapIter->second; } return attValue; } diff --git a/src/EvtGenBase/EvtPto3PAmpFactory.cpp b/src/EvtGenBase/EvtPto3PAmpFactory.cpp index b6a7cbb..94f4e9b 100644 --- a/src/EvtGenBase/EvtPto3PAmpFactory.cpp +++ b/src/EvtGenBase/EvtPto3PAmpFactory.cpp @@ -1,371 +1,371 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenBase/EvtPto3PAmpFactory.hh" #include "EvtGenBase/EvtComplex.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtCyclic3.hh" #include "EvtGenBase/EvtDalitzFlatPdf.hh" #include "EvtGenBase/EvtDalitzResPdf.hh" #include "EvtGenBase/EvtFlatAmp.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtLASSAmp.hh" #include "EvtGenBase/EvtNonresonantAmp.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtPropBreitWigner.hh" #include "EvtGenBase/EvtPropBreitWignerRel.hh" #include "EvtGenBase/EvtPropFlatte.hh" #include "EvtGenBase/EvtPto3PAmp.hh" #include "EvtGenBase/EvtSpinType.hh" #include #include #include #include #include using namespace EvtCyclic3; #include void EvtPto3PAmpFactory::processAmp( EvtComplex c, std::vector vv, bool conj ) { if ( _verbose ) { printf( "Make %samplitude\n", conj ? "CP conjugate" : "" ); unsigned i; for ( i = 0; i < vv.size(); i++ ) printf( "%s\n", vv[i].c_str() ); printf( "\n" ); } std::unique_ptr> amp; std::unique_ptr> pdf; std::string name; Pair pairRes = AB; size_t i; /* Experimental amplitudes */ if ( vv[0] == "PHASESPACE" ) { pdf = std::make_unique( _dp ); amp = std::make_unique>(); name = "NR"; } else if ( !vv[0].find( "NONRES" ) ) { double alpha = 0; EvtPto3PAmp::NumType typeNRes = EvtPto3PAmp::NONRES; if ( vv[0] == "NONRES_LIN" ) { typeNRes = EvtPto3PAmp::NONRES_LIN; pairRes = strToPair( vv[1].c_str() ); } else if ( vv[0] == "NONRES_EXP" ) { typeNRes = EvtPto3PAmp::NONRES_EXP; pairRes = strToPair( vv[1].c_str() ); alpha = strtod( vv[2].c_str(), 0 ); } else assert( 0 ); pdf = std::make_unique( _dp ); amp = std::make_unique( &_dp, typeNRes, pairRes, alpha ); } else if ( vv[0] == "LASS" || vv[0] == "LASS_ELASTIC" || vv[0] == "LASS_RESONANT" ) { pairRes = strToPair( vv[1].c_str() ); double m0 = strtod( vv[2].c_str(), 0 ); double g0 = strtod( vv[3].c_str(), 0 ); double a = strtod( vv[4].c_str(), 0 ); double r = strtod( vv[5].c_str(), 0 ); double cutoff = strtod( vv[6].c_str(), 0 ); pdf = std::make_unique( _dp, m0, g0, pairRes ); amp = std::make_unique( &_dp, pairRes, m0, g0, a, r, cutoff, vv[0] ); } /* Resonant amplitudes */ else if ( vv[0] == "RESONANCE" ) { std::unique_ptr partAmp; // RESONANCE stanza pairRes = strToPair( vv[1].c_str() ); EvtSpinType::spintype spinR = EvtSpinType::SCALAR; double mR, gR; name = vv[2]; EvtId resId = EvtPDL::getId( vv[2] ); if ( _verbose ) printf( "Particles %s form %sresonance %s\n", vv[1].c_str(), vv[2].c_str(), conj ? "(conj) " : "" ); // If no valid particle name is given, assume that // it is the spin, the mass and the width of the particle. if ( resId.getId() == -1 ) { switch ( atoi( vv[2].c_str() ) ) { case 0: { spinR = EvtSpinType::SCALAR; break; } case 1: { spinR = EvtSpinType::VECTOR; break; } case 2: { spinR = EvtSpinType::TENSOR; break; } case 3: { spinR = EvtSpinType::SPIN3; break; } case 4: { spinR = EvtSpinType::SPIN4; break; } default: { assert( 0 ); break; } } mR = strtod( vv[3].c_str(), 0 ); gR = strtod( vv[4].c_str(), 0 ); i = 4; } else { // For a valid particle get spin, mass and width spinR = EvtPDL::getSpinType( resId ); mR = EvtPDL::getMeanMass( resId ); gR = EvtPDL::getWidth( resId ); i = 2; // It's possible to specify mass and width of a particle // explicitly if ( vv[3] != "ANGULAR" ) { if ( _verbose ) printf( "Setting m(%s)=%s g(%s)=%s\n", vv[2].c_str(), vv[3].c_str(), vv[2].c_str(), vv[4].c_str() ); mR = strtod( vv[3].c_str(), 0 ); gR = strtod( vv[4].c_str(), 0 ); i = 4; } } // ANGULAR stanza if ( vv[++i] != "ANGULAR" ) { printf( "%s instead of ANGULAR\n", vv[i].c_str() ); exit( 0 ); } Pair pairAng = strToPair( vv[++i].c_str() ); if ( _verbose ) printf( "Angle is measured between particles %s\n", vv[i].c_str() ); // TYPE stanza std::string typeName = vv[++i]; assert( typeName == "TYPE" ); std::string type = vv[++i]; if ( _verbose ) printf( "Propagator type %s\n", vv[i].c_str() ); if ( type == "NBW" ) { EvtPropBreitWigner prop( mR, gR ); partAmp = std::make_unique( _dp, pairAng, pairRes, spinR, prop, EvtPto3PAmp::NBW ); } else if ( type == "RBW_ZEMACH" ) { EvtPropBreitWignerRel prop( mR, gR ); partAmp = std::make_unique( _dp, pairAng, pairRes, spinR, prop, EvtPto3PAmp::RBW_ZEMACH ); } else if ( type == "RBW_KUEHN" ) { EvtPropBreitWignerRel prop( mR, gR ); partAmp = std::make_unique( _dp, pairAng, pairRes, spinR, prop, EvtPto3PAmp::RBW_KUEHN ); } else if ( type == "RBW_CLEO" ) { EvtPropBreitWignerRel prop( mR, gR ); partAmp = std::make_unique( _dp, pairAng, pairRes, spinR, prop, EvtPto3PAmp::RBW_CLEO ); } else if ( type == "FLATTE" ) { double m1a = _dp.m( first( pairRes ) ); double m1b = _dp.m( second( pairRes ) ); // 2nd channel double g2 = strtod( vv[++i].c_str(), 0 ); double m2a = strtod( vv[++i].c_str(), 0 ); double m2b = strtod( vv[++i].c_str(), 0 ); EvtPropFlatte prop( mR, gR, m1a, m1b, g2, m2a, m2b ); partAmp = std::make_unique( _dp, pairAng, pairRes, spinR, prop, EvtPto3PAmp::FLATTE ); } else assert( 0 ); // Optional DVFF, BVFF stanzas if ( i < vv.size() - 1 ) { if ( vv[i + 1] == "DVFF" ) { i++; if ( vv[++i] == "BLATTWEISSKOPF" ) { double R = strtod( vv[++i].c_str(), 0 ); partAmp->set_fd( R ); } else assert( 0 ); } } if ( i < vv.size() - 1 ) { if ( vv[i + 1] == "BVFF" ) { i++; if ( vv[++i] == "BLATTWEISSKOPF" ) { if ( _verbose ) printf( "BVFF=%s\n", vv[i].c_str() ); double R = strtod( vv[++i].c_str(), 0 ); partAmp->set_fb( R ); } else assert( 0 ); } } const int minwidths = 5; //Optional resonance minimum and maximum if ( i < vv.size() - 1 ) { if ( vv[i + 1] == "CUTOFF" ) { i++; if ( vv[i + 1] == "MIN" ) { i++; double min = strtod( vv[++i].c_str(), 0 ); if ( _verbose ) std::cout << "CUTOFF MIN = " << min << " " << minwidths << std::endl; //ensure against cutting off too close to the resonance assert( min < ( mR - minwidths * gR ) ); partAmp->setmin( min ); } else if ( vv[i + 1] == "MAX" ) { i++; double max = strtod( vv[++i].c_str(), 0 ); if ( _verbose ) std::cout << "CUTOFF MAX = " << max << " " << minwidths << std::endl; //ensure against cutting off too close to the resonance assert( max > ( mR + minwidths * gR ) ); partAmp->setmax( max ); } else assert( 0 ); } } //2nd iteration in case min and max are both specified if ( i < vv.size() - 1 ) { if ( vv[i + 1] == "CUTOFF" ) { i++; if ( vv[i + 1] == "MIN" ) { i++; double min = strtod( vv[++i].c_str(), 0 ); if ( _verbose ) std::cout << "CUTOFF MIN = " << min << std::endl; //ensure against cutting off too close to the resonance assert( min < ( mR - minwidths * gR ) ); partAmp->setmin( min ); } else if ( vv[i + 1] == "MAX" ) { i++; double max = strtod( vv[++i].c_str(), 0 ); if ( _verbose ) std::cout << "CUTOFF MAX = " << max << std::endl; //ensure against cutting off too close to the resonance assert( max > ( mR + minwidths * gR ) ); partAmp->setmax( max ); } else assert( 0 ); } } i++; pdf = std::make_unique( _dp, mR, gR, pairRes ); amp = std::move( partAmp ); } assert( amp ); assert( pdf ); - double scale = matchIsobarCoef( *_amp, *pdf, pairRes ); + double scale = matchIsobarCoef( *amp, *pdf, pairRes ); if ( !conj ) { _amp->addOwnedTerm( c, std::move( amp ) ); } else { _ampConj->addOwnedTerm( c, std::move( amp ) ); } _pc->addOwnedTerm( abs2( c ) * scale, std::move( pdf ) ); _names.push_back( name ); } double EvtPto3PAmpFactory::matchIsobarCoef( EvtAmplitude& amp, EvtPdf& pdf, EvtCyclic3::Pair ipair ) { // account for differences in the definition of amplitudes by matching // Integral( c'*pdf ) = Integral( c*|A|^2 ) // to improve generation efficiency ... double Ipdf = pdf.compute_integral( 10000 ).value(); double Iamp2 = 0; EvtCyclic3::Pair jpair = EvtCyclic3::next( ipair ); EvtCyclic3::Pair kpair = EvtCyclic3::next( jpair ); // Trapezoidal integral int N = 10000; double di = ( _dp.qAbsMax( ipair ) - _dp.qAbsMin( ipair ) ) / ( (double)N ); double siMin = _dp.qAbsMin( ipair ); double s[3]; // playing with fire for ( int i = 1; i < N; i++ ) { s[ipair] = siMin + di * i; s[jpair] = _dp.q( jpair, 0.9999, ipair, s[ipair] ); s[kpair] = _dp.bigM() * _dp.bigM() - s[ipair] - s[jpair] + _dp.mA() * _dp.mA() + _dp.mB() * _dp.mB() + _dp.mC() * _dp.mC(); EvtDalitzPoint point( _dp.mA(), _dp.mB(), _dp.mC(), s[EvtCyclic3::AB], s[EvtCyclic3::BC], s[EvtCyclic3::CA] ); if ( !point.isValid() ) continue; double p = point.p( other( ipair ), ipair ); double q = point.p( first( ipair ), ipair ); double itg = abs2( amp.evaluate( point ) ) * di * 4 * q * p; Iamp2 += itg; } if ( _verbose ) std::cout << "integral = " << Iamp2 << " pdf=" << Ipdf << std::endl; assert( Ipdf > 0 && Iamp2 > 0 ); return Iamp2 / Ipdf; } diff --git a/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp b/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp index e283221..b8c5220 100644 --- a/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp +++ b/src/EvtGenBase/EvtSemiLeptonicBaryonAmp.cpp @@ -1,788 +1,788 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenBase/EvtSemiLeptonicBaryonAmp.hh" #include "EvtGenBase/EvtAmp.hh" #include "EvtGenBase/EvtDiracParticle.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtGammaMatrix.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRaritaSchwinger.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtSemiLeptonicFF.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include using std::endl; void EvtSemiLeptonicBaryonAmp::CalcAmp( EvtParticle* parent, EvtAmp& amp, EvtSemiLeptonicFF* FormFactors ) { static EvtId EM = EvtPDL::getId( "e-" ); static EvtId MUM = EvtPDL::getId( "mu-" ); static EvtId TAUM = EvtPDL::getId( "tau-" ); static EvtId EP = EvtPDL::getId( "e+" ); static EvtId MUP = EvtPDL::getId( "mu+" ); static EvtId TAUP = EvtPDL::getId( "tau+" ); //Add the lepton and neutrino 4 momenta to find q2 EvtVector4R q = parent->getDaug( 1 )->getP4() + parent->getDaug( 2 )->getP4(); double q2 = ( q.mass2() ); double f1v, f1a, f2v, f2a; double m_meson = parent->getDaug( 0 )->mass(); FormFactors->getbaryonff( parent->getId(), parent->getDaug( 0 )->getId(), q2, m_meson, &f1v, &f1a, &f2v, &f2a ); EvtVector4R p4b; p4b.set( parent->mass(), 0.0, 0.0, 0.0 ); EvtVector4C temp_00_term1; EvtVector4C temp_00_term2; EvtVector4C temp_01_term1; EvtVector4C temp_01_term2; EvtVector4C temp_10_term1; EvtVector4C temp_10_term2; EvtVector4C temp_11_term1; EvtVector4C temp_11_term2; EvtDiracSpinor p0 = parent->sp( 0 ); EvtDiracSpinor p1 = parent->sp( 1 ); EvtDiracSpinor d0 = parent->getDaug( 0 )->spParent( 0 ); EvtDiracSpinor d1 = parent->getDaug( 0 )->spParent( 1 ); temp_00_term1.set( 0, f1v * ( d0 * ( EvtGammaMatrix::g0() * p0 ) ) ); temp_00_term2.set( 0, f1a * ( d0 * ( ( EvtGammaMatrix::g0() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_01_term1.set( 0, f1v * ( d0 * ( EvtGammaMatrix::g0() * p1 ) ) ); temp_01_term2.set( 0, f1a * ( d0 * ( ( EvtGammaMatrix::g0() * EvtGammaMatrix::g5() ) * p1 ) ) ); temp_10_term1.set( 0, f1v * ( d1 * ( EvtGammaMatrix::g0() * p0 ) ) ); temp_10_term2.set( 0, f1a * ( d1 * ( ( EvtGammaMatrix::g0() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_11_term1.set( 0, f1v * ( d1 * ( EvtGammaMatrix::g0() * p1 ) ) ); temp_11_term2.set( 0, f1a * ( d1 * ( ( EvtGammaMatrix::g0() * EvtGammaMatrix::g5() ) * p1 ) ) ); temp_00_term1.set( 1, f1v * ( d0 * ( EvtGammaMatrix::g1() * p0 ) ) ); temp_00_term2.set( 1, f1a * ( d0 * ( ( EvtGammaMatrix::g1() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_01_term1.set( 1, f1v * ( d0 * ( EvtGammaMatrix::g1() * p1 ) ) ); temp_01_term2.set( 1, f1a * ( d0 * ( ( EvtGammaMatrix::g1() * EvtGammaMatrix::g5() ) * p1 ) ) ); temp_10_term1.set( 1, f1v * ( d1 * ( EvtGammaMatrix::g1() * p0 ) ) ); temp_10_term2.set( 1, f1a * ( d1 * ( ( EvtGammaMatrix::g1() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_11_term1.set( 1, f1v * ( d1 * ( EvtGammaMatrix::g1() * p1 ) ) ); temp_11_term2.set( 1, f1a * ( d1 * ( ( EvtGammaMatrix::g1() * EvtGammaMatrix::g5() ) * p1 ) ) ); temp_00_term1.set( 2, f1v * ( d0 * ( EvtGammaMatrix::g2() * p0 ) ) ); temp_00_term2.set( 2, f1a * ( d0 * ( ( EvtGammaMatrix::g2() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_01_term1.set( 2, f1v * ( d0 * ( EvtGammaMatrix::g2() * p1 ) ) ); temp_01_term2.set( 2, f1a * ( d0 * ( ( EvtGammaMatrix::g2() * EvtGammaMatrix::g5() ) * p1 ) ) ); temp_10_term1.set( 2, f1v * ( d1 * ( EvtGammaMatrix::g2() * p0 ) ) ); temp_10_term2.set( 2, f1a * ( d1 * ( ( EvtGammaMatrix::g2() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_11_term1.set( 2, f1v * ( d1 * ( EvtGammaMatrix::g2() * p1 ) ) ); temp_11_term2.set( 2, f1a * ( d1 * ( ( EvtGammaMatrix::g2() * EvtGammaMatrix::g5() ) * p1 ) ) ); temp_00_term1.set( 3, f1v * ( d0 * ( EvtGammaMatrix::g3() * p0 ) ) ); temp_00_term2.set( 3, f1a * ( d0 * ( ( EvtGammaMatrix::g3() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_01_term1.set( 3, f1v * ( d0 * ( EvtGammaMatrix::g3() * p1 ) ) ); temp_01_term2.set( 3, f1a * ( d0 * ( ( EvtGammaMatrix::g3() * EvtGammaMatrix::g5() ) * p1 ) ) ); temp_10_term1.set( 3, f1v * ( d1 * ( EvtGammaMatrix::g3() * p0 ) ) ); temp_10_term2.set( 3, f1a * ( d1 * ( ( EvtGammaMatrix::g3() * EvtGammaMatrix::g5() ) * p0 ) ) ); temp_11_term1.set( 3, f1v * ( d1 * ( EvtGammaMatrix::g3() * p1 ) ) ); temp_11_term2.set( 3, f1a * ( d1 * ( ( EvtGammaMatrix::g3() * EvtGammaMatrix::g5() ) * p1 ) ) ); EvtVector4C l1, l2; EvtId l_num = parent->getDaug( 1 )->getId(); if ( l_num == EM || l_num == MUM || l_num == TAUM ) { l1 = EvtLeptonVACurrent( parent->getDaug( 1 )->spParent( 0 ), parent->getDaug( 2 )->spParentNeutrino() ); l2 = EvtLeptonVACurrent( parent->getDaug( 1 )->spParent( 1 ), parent->getDaug( 2 )->spParentNeutrino() ); } else { if ( l_num == EP || l_num == MUP || l_num == TAUP ) { l1 = EvtLeptonVACurrent( parent->getDaug( 2 )->spParentNeutrino(), parent->getDaug( 1 )->spParent( 0 ) ); l2 = EvtLeptonVACurrent( parent->getDaug( 2 )->spParentNeutrino(), parent->getDaug( 1 )->spParent( 1 ) ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Wrong lepton number" << endl; } } amp.vertex( 0, 0, 0, l1.cont( temp_00_term1 + temp_00_term2 ) ); amp.vertex( 0, 0, 1, l2.cont( temp_00_term1 + temp_00_term2 ) ); amp.vertex( 0, 1, 0, l1.cont( temp_01_term1 + temp_01_term2 ) ); amp.vertex( 0, 1, 1, l2.cont( temp_01_term1 + temp_01_term2 ) ); amp.vertex( 1, 0, 0, l1.cont( temp_10_term1 + temp_10_term2 ) ); amp.vertex( 1, 0, 1, l2.cont( temp_10_term1 + temp_10_term2 ) ); amp.vertex( 1, 1, 0, l1.cont( temp_11_term1 + temp_11_term2 ) ); amp.vertex( 1, 1, 1, l2.cont( temp_11_term1 + temp_11_term2 ) ); return; } double EvtSemiLeptonicBaryonAmp::CalcMaxProb( EvtId parent, EvtId baryon, EvtId lepton, EvtId nudaug, EvtSemiLeptonicFF* FormFactors, EvtComplex r00, EvtComplex r01, EvtComplex r10, EvtComplex r11 ) { //This routine takes the arguements parent, baryon, and lepton //number, and a form factor model, and returns a maximum //probability for this semileptonic form factor model. A //brute force method is used. The 2D cos theta lepton and //q2 phase space is probed. //Start by declaring a particle at rest. //It only makes sense to have a scalar parent. For now. //This should be generalized later. // EvtScalarParticle *scalar_part; // scalar_part=new EvtScalarParticle; EvtDiracParticle* dirac_part; EvtParticle* root_part; dirac_part = new EvtDiracParticle; //cludge to avoid generating random numbers! // scalar_part->noLifeTime(); dirac_part->noLifeTime(); EvtVector4R p_init; p_init.set( EvtPDL::getMass( parent ), 0.0, 0.0, 0.0 ); // scalar_part->init(parent,p_init); // root_part=(EvtParticle *)scalar_part; // root_part->set_type(EvtSpinType::SCALAR); dirac_part->init( parent, p_init ); root_part = (EvtParticle*)dirac_part; root_part->setDiagonalSpinDensity(); EvtParticle *daughter, *lep, *trino; EvtAmp amp; EvtId listdaug[3]; listdaug[0] = baryon; listdaug[1] = lepton; listdaug[2] = nudaug; amp.init( parent, 3, listdaug ); root_part->makeDaughters( 3, listdaug ); daughter = root_part->getDaug( 0 ); lep = root_part->getDaug( 1 ); trino = root_part->getDaug( 2 ); //cludge to avoid generating random numbers! daughter->noLifeTime(); lep->noLifeTime(); trino->noLifeTime(); //Initial particle is unpolarized, well it is a scalar so it is //trivial EvtSpinDensity rho; rho.setDiag( root_part->getSpinStates() ); double mass[3]; double m = root_part->mass(); EvtVector4R p4baryon, p4lepton, p4nu, p4w; double q2max; double q2, elepton, plepton; int i, j; double erho, prho, costl; double maxfoundprob = 0.0; double prob = -10.0; int massiter; for ( massiter = 0; massiter < 3; massiter++ ) { mass[0] = EvtPDL::getMass( baryon ); mass[1] = EvtPDL::getMass( lepton ); mass[2] = EvtPDL::getMass( nudaug ); if ( massiter == 1 ) { mass[0] = EvtPDL::getMinMass( baryon ); } if ( massiter == 2 ) { mass[0] = EvtPDL::getMaxMass( baryon ); } q2max = ( m - mass[0] ) * ( m - mass[0] ); //loop over q2 for ( i = 0; i < 25; i++ ) { q2 = ( ( i + 0.5 ) * q2max ) / 25.0; erho = ( m * m + mass[0] * mass[0] - q2 ) / ( 2.0 * m ); prho = sqrt( erho * erho - mass[0] * mass[0] ); p4baryon.set( erho, 0.0, 0.0, -1.0 * prho ); p4w.set( m - erho, 0.0, 0.0, prho ); //This is in the W rest frame elepton = ( q2 + mass[1] * mass[1] ) / ( 2.0 * sqrt( q2 ) ); plepton = sqrt( elepton * elepton - mass[1] * mass[1] ); double probctl[3]; for ( j = 0; j < 3; j++ ) { costl = 0.99 * ( j - 1.0 ); //These are in the W rest frame. Need to boost out into //the B frame. p4lepton.set( elepton, 0.0, plepton * sqrt( 1.0 - costl * costl ), plepton * costl ); p4nu.set( plepton, 0.0, -1.0 * plepton * sqrt( 1.0 - costl * costl ), -1.0 * plepton * costl ); EvtVector4R boost( ( m - erho ), 0.0, 0.0, 1.0 * prho ); p4lepton = boostTo( p4lepton, boost ); p4nu = boostTo( p4nu, boost ); //Now initialize the daughters... daughter->init( baryon, p4baryon ); lep->init( lepton, p4lepton ); trino->init( nudaug, p4nu ); CalcAmp( root_part, amp, FormFactors, r00, r01, r10, r11 ); //Now find the probability at this q2 and cos theta lepton point //and compare to maxfoundprob. //Do a little magic to get the probability!! prob = rho.normalizedProb( amp.getSpinDensity() ); probctl[j] = prob; } //probclt contains prob at ctl=-1,0,1. //prob=a+b*ctl+c*ctl^2 double a = probctl[1]; double b = 0.5 * ( probctl[2] - probctl[0] ); double c = 0.5 * ( probctl[2] + probctl[0] ) - probctl[1]; prob = probctl[0]; if ( probctl[1] > prob ) prob = probctl[1]; if ( probctl[2] > prob ) prob = probctl[2]; if ( fabs( c ) > 1e-20 ) { double ctlx = -0.5 * b / c; if ( fabs( ctlx ) < 1.0 ) { double probtmp = a + b * ctlx + c * ctlx * ctlx; if ( probtmp > prob ) prob = probtmp; } } //EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "prob,probctl:"< maxfoundprob ) { maxfoundprob = prob; } } if ( EvtPDL::getWidth( baryon ) <= 0.0 ) { //if the particle is narrow dont bother with changing the mass. massiter = 4; } } root_part->deleteTree(); maxfoundprob *= 1.1; return maxfoundprob; } void EvtSemiLeptonicBaryonAmp::CalcAmp( EvtParticle* parent, EvtAmp& amp, EvtSemiLeptonicFF* FormFactors, EvtComplex r00, EvtComplex r01, EvtComplex r10, EvtComplex r11 ) { // Leptons static EvtId EM = EvtPDL::getId( "e-" ); static EvtId MUM = EvtPDL::getId( "mu-" ); static EvtId TAUM = EvtPDL::getId( "tau-" ); // Anti-Leptons static EvtId EP = EvtPDL::getId( "e+" ); static EvtId MUP = EvtPDL::getId( "mu+" ); static EvtId TAUP = EvtPDL::getId( "tau+" ); // Baryons static EvtId LAMCP = EvtPDL::getId( "Lambda_c+" ); static EvtId LAMC1P = EvtPDL::getId( "Lambda_c(2593)+" ); static EvtId LAMC2P = EvtPDL::getId( "Lambda_c(2625)+" ); static EvtId LAMB = EvtPDL::getId( "Lambda_b0" ); // Anti-Baryons static EvtId LAMCM = EvtPDL::getId( "anti-Lambda_c-" ); static EvtId LAMC1M = EvtPDL::getId( "anti-Lambda_c(2593)-" ); static EvtId LAMC2M = EvtPDL::getId( "anti-Lambda_c(2625)-" ); static EvtId LAMBB = EvtPDL::getId( "anti-Lambda_b0" ); // Set the spin density matrix of the parent baryon EvtSpinDensity rho; rho.setDim( 2 ); rho.set( 0, 0, r00 ); rho.set( 0, 1, r01 ); rho.set( 1, 0, r10 ); rho.set( 1, 1, r11 ); EvtVector4R vector4P = parent->getP4Lab(); double pmag = vector4P.d3mag(); - double cosTheta = vector4P.get( 3 ) / pmag; + double cosTheta = pmag > 0.0 ? vector4P.get( 3 ) / pmag : 0.0; double theta = acos( cosTheta ); double phi = atan2( vector4P.get( 2 ), vector4P.get( 1 ) ); parent->setSpinDensityForwardHelicityBasis( rho, phi, theta, 0.0 ); //parent->setSpinDensityForward(rho); // Set the four momentum of the parent baryon in it's rest frame EvtVector4R p4b; p4b.set( parent->mass(), 0.0, 0.0, 0.0 ); // Get the four momentum of the daughter baryon in the parent's rest frame EvtVector4R p4daught = parent->getDaug( 0 )->getP4(); // Add the lepton and neutrino 4 momenta to find q (q^2) EvtVector4R q = parent->getDaug( 1 )->getP4() + parent->getDaug( 2 )->getP4(); double q2 = q.mass2(); EvtId l_num = parent->getDaug( 1 )->getId(); EvtId bar_num = parent->getDaug( 0 )->getId(); EvtId par_num = parent->getId(); double baryonmass = parent->getDaug( 0 )->mass(); // Handle spin-1/2 daughter baryon Dirac spinor cases if ( EvtPDL::getSpinType( parent->getDaug( 0 )->getId() ) == EvtSpinType::DIRAC ) { // Set the form factors double f1, f2, f3, g1, g2, g3; FormFactors->getdiracff( par_num, bar_num, q2, baryonmass, &f1, &f2, &f3, &g1, &g2, &g3 ); const double form_fact[6] = {f1, f2, f3, g1, g2, g3}; EvtVector4C b11, b12, b21, b22, l1, l2; // Lepton Current if ( l_num == EM || l_num == MUM || l_num == TAUM ) { l1 = EvtLeptonVACurrent( parent->getDaug( 1 )->spParent( 0 ), parent->getDaug( 2 )->spParentNeutrino() ); l2 = EvtLeptonVACurrent( parent->getDaug( 1 )->spParent( 1 ), parent->getDaug( 2 )->spParentNeutrino() ); } else if ( l_num == EP || l_num == MUP || l_num == TAUP ) { l1 = EvtLeptonVACurrent( parent->getDaug( 2 )->spParentNeutrino(), parent->getDaug( 1 )->spParent( 0 ) ); l2 = EvtLeptonVACurrent( parent->getDaug( 2 )->spParentNeutrino(), parent->getDaug( 1 )->spParent( 1 ) ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Wrong lepton number \n"; ::abort(); } // Baryon current // Flag for particle/anti-particle parent, daughter with same/opp. parity // pflag = 0 => particle, same parity parent, daughter // pflag = 1 => particle, opp. parity parent, daughter // pflag = 2 => anti-particle, same parity parent, daughter // pflag = 3 => anti-particle, opp. parity parent, daughter int pflag = 0; // Handle 1/2+ -> 1/2+ first if ( ( par_num == LAMB && bar_num == LAMCP ) || ( par_num == LAMBB && bar_num == LAMCM ) ) { // Set particle/anti-particle flag if ( bar_num == LAMCP ) pflag = 0; else if ( bar_num == LAMCM ) pflag = 2; b11 = EvtBaryonVACurrent( parent->getDaug( 0 )->spParent( 0 ), parent->sp( 0 ), p4b, p4daught, form_fact, pflag ); b21 = EvtBaryonVACurrent( parent->getDaug( 0 )->spParent( 0 ), parent->sp( 1 ), p4b, p4daught, form_fact, pflag ); b12 = EvtBaryonVACurrent( parent->getDaug( 0 )->spParent( 1 ), parent->sp( 0 ), p4b, p4daught, form_fact, pflag ); b22 = EvtBaryonVACurrent( parent->getDaug( 0 )->spParent( 1 ), parent->sp( 1 ), p4b, p4daught, form_fact, pflag ); } // Handle 1/2+ -> 1/2- second else if ( ( par_num == LAMB && bar_num == LAMC1P ) || ( par_num == LAMBB && bar_num == LAMC1M ) ) { // Set particle/anti-particle flag if ( bar_num == LAMC1P ) pflag = 1; else if ( bar_num == LAMC1M ) pflag = 3; b11 = EvtBaryonVACurrent( ( parent->getDaug( 0 )->spParent( 0 ) ), ( EvtGammaMatrix::g5() * parent->sp( 0 ) ), p4b, p4daught, form_fact, pflag ); b21 = EvtBaryonVACurrent( ( parent->getDaug( 0 )->spParent( 0 ) ), ( EvtGammaMatrix::g5() * parent->sp( 1 ) ), p4b, p4daught, form_fact, pflag ); b12 = EvtBaryonVACurrent( ( parent->getDaug( 0 )->spParent( 1 ) ), ( EvtGammaMatrix::g5() * parent->sp( 0 ) ), p4b, p4daught, form_fact, pflag ); b22 = EvtBaryonVACurrent( ( parent->getDaug( 0 )->spParent( 1 ) ), ( EvtGammaMatrix::g5() * parent->sp( 1 ) ), p4b, p4daught, form_fact, pflag ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Dirac semilep. baryon current " << "not implemented for this decay sequence." << std::endl; ::abort(); } amp.vertex( 0, 0, 0, l1 * b11 ); amp.vertex( 0, 0, 1, l2 * b11 ); amp.vertex( 1, 0, 0, l1 * b21 ); amp.vertex( 1, 0, 1, l2 * b21 ); amp.vertex( 0, 1, 0, l1 * b12 ); amp.vertex( 0, 1, 1, l2 * b12 ); amp.vertex( 1, 1, 0, l1 * b22 ); amp.vertex( 1, 1, 1, l2 * b22 ); } // Need special handling for the spin-3/2 daughter baryon // Rarita-Schwinger spinor cases else if ( EvtPDL::getSpinType( parent->getDaug( 0 )->getId() ) == EvtSpinType::RARITASCHWINGER ) { // Set the form factors double f1, f2, f3, f4, g1, g2, g3, g4; FormFactors->getraritaff( par_num, bar_num, q2, baryonmass, &f1, &f2, &f3, &f4, &g1, &g2, &g3, &g4 ); const double form_fact[8] = {f1, f2, f3, f4, g1, g2, g3, g4}; EvtId l_num = parent->getDaug( 1 )->getId(); EvtVector4C b11, b12, b21, b22, b13, b23, b14, b24, l1, l2; // Lepton Current if ( l_num == EM || l_num == MUM || l_num == TAUM ) { // Lepton Current l1 = EvtLeptonVACurrent( parent->getDaug( 1 )->spParent( 0 ), parent->getDaug( 2 )->spParentNeutrino() ); l2 = EvtLeptonVACurrent( parent->getDaug( 1 )->spParent( 1 ), parent->getDaug( 2 )->spParentNeutrino() ); } else if ( l_num == EP || l_num == MUP || l_num == TAUP ) { l1 = EvtLeptonVACurrent( parent->getDaug( 2 )->spParentNeutrino(), parent->getDaug( 1 )->spParent( 0 ) ); l2 = EvtLeptonVACurrent( parent->getDaug( 2 )->spParentNeutrino(), parent->getDaug( 1 )->spParent( 1 ) ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Wrong lepton number \n"; } // Baryon Current // Declare particle, anti-particle flag, same/opp. parity // pflag = 0 => particle // pflag = 1 => anti-particle int pflag = 0; // Handle cases of 1/2+ -> 3/2- if ( par_num == LAMB && bar_num == LAMC2P ) { // Set flag for particle case pflag = 0; } else if ( par_num == LAMBB && bar_num == LAMC2M ) { // Set flag for anti-particle case pflag = 1; } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Rarita-Schwinger semilep. baryon current " << "not implemented for this decay sequence." << std::endl; ::abort(); } // Baryon current b11 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 0 ), parent->sp( 0 ), p4b, p4daught, form_fact, pflag ); b21 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 0 ), parent->sp( 1 ), p4b, p4daught, form_fact, pflag ); b12 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 1 ), parent->sp( 0 ), p4b, p4daught, form_fact, pflag ); b22 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 1 ), parent->sp( 1 ), p4b, p4daught, form_fact, pflag ); b13 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 2 ), parent->sp( 0 ), p4b, p4daught, form_fact, pflag ); b23 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 2 ), parent->sp( 1 ), p4b, p4daught, form_fact, pflag ); b14 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 3 ), parent->sp( 0 ), p4b, p4daught, form_fact, pflag ); b24 = EvtBaryonVARaritaCurrent( parent->getDaug( 0 )->spRSParent( 3 ), parent->sp( 1 ), p4b, p4daught, form_fact, pflag ); amp.vertex( 0, 0, 0, l1 * b11 ); amp.vertex( 0, 0, 1, l2 * b11 ); amp.vertex( 1, 0, 0, l1 * b21 ); amp.vertex( 1, 0, 1, l2 * b21 ); amp.vertex( 0, 1, 0, l1 * b12 ); amp.vertex( 0, 1, 1, l2 * b12 ); amp.vertex( 1, 1, 0, l1 * b22 ); amp.vertex( 1, 1, 1, l2 * b22 ); amp.vertex( 0, 2, 0, l1 * b13 ); amp.vertex( 0, 2, 1, l2 * b13 ); amp.vertex( 1, 2, 0, l1 * b23 ); amp.vertex( 1, 2, 1, l2 * b23 ); amp.vertex( 0, 3, 0, l1 * b14 ); amp.vertex( 0, 3, 1, l2 * b14 ); amp.vertex( 1, 3, 0, l1 * b24 ); amp.vertex( 1, 3, 1, l2 * b24 ); } } EvtVector4C EvtSemiLeptonicBaryonAmp::EvtBaryonVACurrent( const EvtDiracSpinor& Bf, const EvtDiracSpinor& Bi, EvtVector4R parent, EvtVector4R daught, const double* ff, int pflag ) { // flag == 0 => particle, same parity // flag == 1 => particle, opposite parity // flag == 2 => anti-particle, same parity // flag == 3 => anti-particle, opposite parity // particle EvtComplex cv = EvtComplex( 1.0, 0. ); EvtComplex ca = EvtComplex( 1.0, 0. ); EvtComplex cg0 = EvtComplex( 1.0, 0. ); EvtComplex cg5 = EvtComplex( 1.0, 0. ); // antiparticle- same parity parent & daughter if ( pflag == 2 ) { cv = EvtComplex( -1.0, 0. ); ca = EvtComplex( 1.0, 0. ); cg0 = EvtComplex( 1.0, 0.0 ); cg5 = EvtComplex( 0.0, -1.0 ); } // antiparticle- opposite parity parent & daughter else if ( pflag == 3 ) { cv = EvtComplex( 1.0, 0. ); ca = EvtComplex( -1.0, 0. ); cg0 = EvtComplex( 0.0, -1.0 ); cg5 = EvtComplex( 1.0, 0.0 ); } EvtVector4C t[6]; // Term 1 = \bar{u}(p',s')*(F_1(q^2)*\gamma_{mu})*u(p,s) t[0] = cv * EvtLeptonVCurrent( Bf, Bi ); // Term 2 = \bar{u}(p',s')*(F_2(q^2)*(p_{mu}/m_{\Lambda_Q}))*u(p,s) t[1] = cg0 * EvtLeptonSCurrent( Bf, Bi ) * ( parent / parent.mass() ); // Term 3 = \bar{u}(p',s')*(F_3(q^2)*(p'_{mu}/m_{\Lambda_q}))*u(p,s) t[2] = cg0 * EvtLeptonSCurrent( Bf, Bi ) * ( daught / daught.mass() ); // Term 4 = \bar{u}(p',s')*(G_1(q^2)*\gamma_{mu}*\gamma_5)*u(p,s) t[3] = ca * EvtLeptonACurrent( Bf, Bi ); // Term 5 = \bar{u}(p',s')*(G_2(q^2)*(p_{mu}/m_{\Lambda_Q})*\gamma_5)*u(p,s) t[4] = cg5 * EvtLeptonPCurrent( Bf, Bi ) * ( parent / parent.mass() ); // Term 6 = \bar{u}(p',s')*(G_3(q^2)*(p'_{mu}/m_{\Lambda_q})*\gamma_5)*u(p,s) t[5] = cg5 * EvtLeptonPCurrent( Bf, Bi ) * ( daught / daught.mass() ); // Sum the individual terms EvtVector4C current = ( ff[0] * t[0] + ff[1] * t[1] + ff[2] * t[2] - ff[3] * t[3] - ff[4] * t[4] - ff[5] * t[5] ); return current; } EvtVector4C EvtSemiLeptonicBaryonAmp::EvtBaryonVARaritaCurrent( const EvtRaritaSchwinger& Bf, const EvtDiracSpinor& Bi, EvtVector4R parent, EvtVector4R daught, const double* ff, int pflag ) { // flag == 0 => particle // flag == 1 => anti-particle // particle EvtComplex cv = EvtComplex( 1.0, 0. ); EvtComplex ca = EvtComplex( 1.0, 0. ); EvtComplex cg0 = EvtComplex( 1.0, 0. ); EvtComplex cg5 = EvtComplex( 1.0, 0. ); // antiparticle if ( pflag == 1 ) { cv = EvtComplex( -1.0, 0. ); ca = EvtComplex( 1.0, 0. ); cg0 = EvtComplex( 1.0, 0.0 ); cg5 = EvtComplex( 0.0, -1.0 ); } EvtVector4C t[8]; EvtTensor4C id; id.setdiag( 1.0, 1.0, 1.0, 1.0 ); EvtDiracSpinor tmp; for ( int i = 0; i < 4; i++ ) { tmp.set_spinor( i, Bf.getVector( i ) * parent ); } EvtVector4C v1, v2; for ( int i = 0; i < 4; i++ ) { v1.set( i, EvtLeptonSCurrent( Bf.getSpinor( i ), Bi ) ); v2.set( i, EvtLeptonPCurrent( Bf.getSpinor( i ), Bi ) ); } // Term 1 = \bar{u}^{\alpha}(p',s')*(p_{\alpha}/m_{\Lambda_Q})*(F_1(q^2)*\gamma_{mu})*u(p,s) t[0] = ( cv / parent.mass() ) * EvtLeptonVCurrent( tmp, Bi ); // Term 2 // = \bar{u}^{\alpha}(p',s')*(p_{\alpha}/m_{\Lambda_Q})*(F_2(q^2)*(p_{mu}/m_{\Lambda_Q}))*u(p,s) t[1] = ( ( cg0 / parent.mass() ) * EvtLeptonSCurrent( tmp, Bi ) ) * ( parent / parent.mass() ); // Term 3 // = \bar{u}^{\alpha}(p',s')*(p_{\alpha}/m_{\Lambda_Q})*(F_3(q^2)*(p'_{mu}/m_{\Lambda_q}))*u(p,s) t[2] = ( ( cg0 / parent.mass() ) * EvtLeptonSCurrent( tmp, Bi ) ) * ( daught / daught.mass() ); // Term 4 = \bar{u}^{\alpha}(p',s')*(F_4(q^2)*g_{\alpha,\mu})*u(p,s) t[3] = cg0 * ( id.cont2( v1 ) ); // Term 5 // = \bar{u}^{\alpha}(p',s')*(p_{\alpha}/m_{\Lambda_Q})*(G_1(q^2)*\gamma_{mu}*\gamma_5)*u(p,s) t[4] = ( ca / parent.mass() ) * EvtLeptonACurrent( tmp, Bi ); // Term 6 // = \bar{u}^{\alpha}(p',s')*(p_{\alpha}/m_{\Lambda_Q}) // *(G_2(q^2)*(p_{mu}/m_{\Lambda_Q})*\gamma_5)*u(p,s) t[5] = ( ( cg5 / parent.mass() ) * EvtLeptonPCurrent( tmp, Bi ) ) * ( parent / parent.mass() ); // Term 7 // = \bar{u}^{\alpha}(p',s')*(p_{\alpha}/m_{\Lambda_Q}) // *(G_3(q^2)*(p'_{mu}/m_{\Lambda_q})*\gamma_5)*u(p,s) t[6] = ( ( cg5 / parent.mass() ) * EvtLeptonPCurrent( tmp, Bi ) ) * ( daught / daught.mass() ); // Term 8 = \bar{u}^{\alpha}(p',s')*(G_4(q^2)*g_{\alpha,\mu}*\gamma_5))*u(p,s) t[7] = cg5 * ( id.cont2( v2 ) ); // Sum the individual terms EvtVector4C current = ( ff[0] * t[0] + ff[1] * t[1] + ff[2] * t[2] + ff[3] * t[3] - ff[4] * t[4] - ff[5] * t[5] - ff[6] * t[6] - ff[7] * t[7] ); return current; } diff --git a/src/EvtGenModels/EvtBTo4piCP.cpp b/src/EvtGenModels/EvtBTo4piCP.cpp index 46d9310..1bb6819 100644 --- a/src/EvtGenModels/EvtBTo4piCP.cpp +++ b/src/EvtGenModels/EvtBTo4piCP.cpp @@ -1,261 +1,266 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtBTo4piCP.hh" #include "EvtGenBase/EvtCPUtil.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtVector4R.hh" #include #include EvtComplex EvtAmpA2( const EvtVector4R& p4pi1, const EvtVector4R& p4pi2, const EvtVector4R& p4pi3, const EvtVector4R& p4pi4 ) { //added by Lange Jan4,2000 static EvtId A2M = EvtPDL::getId( "a_2-" ); static EvtId RHO0 = EvtPDL::getId( "rho0" ); EvtVector4R p4a2, p4rho, p4b; p4rho = p4pi1 + p4pi2; p4a2 = p4rho + p4pi3; p4b = p4a2 + p4pi4; EvtVector4R p4b_a2, p4rho_a2, p4pi1_a2, p4a2_a2; p4b_a2 = boostTo( p4b, p4a2 ); p4rho_a2 = boostTo( p4rho, p4a2 ); p4pi1_a2 = boostTo( p4pi1, p4a2 ); p4a2_a2 = boostTo( p4a2, p4a2 ); EvtVector4R p4pi1_rho; p4pi1_rho = boostTo( p4pi1_a2, p4rho_a2 ); EvtVector4R vb, vrho, vpi, t; vb = p4b_a2 / p4b_a2.d3mag(); vrho = p4rho_a2 / p4rho_a2.d3mag(); vpi = p4pi1_rho / p4pi1_rho.d3mag(); t.set( 1.0, 0.0, 0.0, 0.0 ); // EvtComplex amp_a1,amp_a2; EvtComplex amp_a2; // double bwm_a1=EvtPDL::getMeanMass(A1M); // double gamma_a1=EvtPDL::getWidth(A1M); double bwm_a2 = EvtPDL::getMeanMass( A2M ); double gamma_a2 = EvtPDL::getWidth( A2M ); double bwm_rho = EvtPDL::getMeanMass( RHO0 ); double gamma_rho = EvtPDL::getWidth( RHO0 ); amp_a2 = ( sqrt( gamma_a2 / EvtConst::twoPi ) / ( ( p4a2 ).mass() - bwm_a2 - EvtComplex( 0.0, 0.5 * gamma_a2 ) ) ) * ( sqrt( gamma_rho / EvtConst::twoPi ) / ( ( p4rho ).mass() - bwm_rho - EvtComplex( 0.0, 0.5 * gamma_rho ) ) ); return amp_a2 * ( vb.get( 1 ) * vrho.get( 1 ) + vb.get( 2 ) * vrho.get( 2 ) + vb.get( 3 ) * vrho.get( 3 ) ) * ( vpi.get( 1 ) * ( vb.get( 2 ) * vrho.get( 3 ) - vb.get( 3 ) * vrho.get( 2 ) ) + vpi.get( 2 ) * ( vb.get( 3 ) * vrho.get( 1 ) - vb.get( 1 ) * vrho.get( 3 ) ) + vpi.get( 3 ) * ( vb.get( 1 ) * vrho.get( 2 ) - vb.get( 2 ) * vrho.get( 1 ) ) ); } EvtComplex EvtAmpA1( const EvtVector4R& p4pi1, const EvtVector4R& p4pi2, const EvtVector4R& p4pi3, const EvtVector4R& p4pi4 ) { //added by Lange Jan4,2000 static EvtId A1M = EvtPDL::getId( "a_1-" ); static EvtId RHO0 = EvtPDL::getId( "rho0" ); EvtVector4R p4a1, p4rho, p4b; p4rho = p4pi1 + p4pi2; p4a1 = p4rho + p4pi3; p4b = p4a1 + p4pi4; EvtVector4R p4b_a1, p4rho_a1, p4pi1_a1, p4a1_a1; p4b_a1 = boostTo( p4b, p4a1 ); p4rho_a1 = boostTo( p4rho, p4a1 ); p4pi1_a1 = boostTo( p4pi1, p4a1 ); p4a1_a1 = boostTo( p4a1, p4a1 ); EvtVector4R p4pi1_rho; p4pi1_rho = boostTo( p4pi1_a1, p4rho_a1 ); EvtVector4R vb, vrho, vpi, t; vb = p4b_a1 / p4b_a1.d3mag(); vrho = p4rho_a1 / p4rho_a1.d3mag(); vpi = p4pi1_rho / p4pi1_rho.d3mag(); t.set( 1.0, 0.0, 0.0, 0.0 ); EvtComplex amp_a1; double bwm_a1 = EvtPDL::getMeanMass( A1M ); double gamma_a1 = EvtPDL::getWidth( A1M ); // double bwm_a2=EvtPDL::getMeanMass(A2M); // double gamma_a2=EvtPDL::getWidth(A2M); double bwm_rho = EvtPDL::getMeanMass( RHO0 ); double gamma_rho = EvtPDL::getWidth( RHO0 ); amp_a1 = ( sqrt( gamma_a1 / EvtConst::twoPi ) / ( ( p4a1 ).mass() - bwm_a1 - EvtComplex( 0.0, 0.5 * gamma_a1 ) ) ) * ( sqrt( gamma_rho / EvtConst::twoPi ) / ( ( p4rho ).mass() - bwm_rho - EvtComplex( 0.0, 0.5 * gamma_rho ) ) ); return amp_a1 * ( vb.get( 1 ) * vpi.get( 1 ) + vb.get( 2 ) * vpi.get( 2 ) + vb.get( 3 ) * vpi.get( 3 ) ); } std::string EvtBTo4piCP::getName() { return "BTO4PI_CP"; } EvtBTo4piCP* EvtBTo4piCP::clone() { return new EvtBTo4piCP; } +void EvtBTo4piCP::initProbMax() +{ + setProbMax( 50.0 ); +} + void EvtBTo4piCP::init() { // check that there are 18 arguments checkNArg( 18 ); checkNDaug( 4 ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::SCALAR ); checkSpinDaughter( 2, EvtSpinType::SCALAR ); checkSpinDaughter( 3, EvtSpinType::SCALAR ); } void EvtBTo4piCP::decay( EvtParticle* p ) { //added by Lange Jan4,2000 static EvtId B0 = EvtPDL::getId( "B0" ); static EvtId B0B = EvtPDL::getId( "anti-B0" ); double t; EvtId other_b; EvtCPUtil::getInstance()->OtherB( p, t, other_b, 0.5 ); p->initializePhaseSpace( getNDaug(), getDaugs() ); EvtVector4R mom1 = p->getDaug( 0 )->getP4(); EvtVector4R mom2 = p->getDaug( 1 )->getP4(); EvtVector4R mom3 = p->getDaug( 2 )->getP4(); EvtVector4R mom4 = p->getDaug( 3 )->getP4(); // double alpha=getArg(0); //double dm=getArg(1); EvtComplex amp; EvtComplex A, Abar; EvtComplex A_a1p, Abar_a1p, A_a2p, Abar_a2p; EvtComplex A_a1m, Abar_a1m, A_a2m, Abar_a2m; A_a1p = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ), getArg( 2 ) * sin( getArg( 3 ) ) ); Abar_a1p = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ), getArg( 4 ) * sin( getArg( 5 ) ) ); A_a2p = EvtComplex( getArg( 6 ) * cos( getArg( 7 ) ), getArg( 6 ) * sin( getArg( 7 ) ) ); Abar_a2p = EvtComplex( getArg( 8 ) * cos( getArg( 9 ) ), getArg( 8 ) * sin( getArg( 9 ) ) ); A_a1m = EvtComplex( getArg( 10 ) * cos( getArg( 11 ) ), getArg( 10 ) * sin( getArg( 11 ) ) ); Abar_a1m = EvtComplex( getArg( 12 ) * cos( getArg( 13 ) ), getArg( 12 ) * sin( getArg( 13 ) ) ); A_a2m = EvtComplex( getArg( 14 ) * cos( getArg( 15 ) ), getArg( 14 ) * sin( getArg( 15 ) ) ); Abar_a2m = EvtComplex( getArg( 16 ) * cos( getArg( 17 ) ), getArg( 16 ) * sin( getArg( 17 ) ) ); EvtComplex a2p_amp = EvtAmpA2( mom1, mom2, mom3, mom4 ) + EvtAmpA2( mom1, mom4, mom3, mom2 ) + EvtAmpA2( mom3, mom2, mom1, mom4 ) + EvtAmpA2( mom3, mom4, mom1, mom2 ); EvtComplex a2m_amp = EvtAmpA2( mom2, mom3, mom4, mom1 ) + EvtAmpA2( mom2, mom1, mom4, mom3 ) + EvtAmpA2( mom4, mom3, mom2, mom1 ) + EvtAmpA2( mom4, mom1, mom2, mom3 ); EvtComplex a1p_amp = EvtAmpA1( mom1, mom2, mom3, mom4 ) + EvtAmpA1( mom1, mom4, mom3, mom2 ) + EvtAmpA1( mom3, mom2, mom1, mom4 ) + EvtAmpA1( mom3, mom4, mom1, mom2 ); EvtComplex a1m_amp = EvtAmpA1( mom2, mom3, mom4, mom1 ) + EvtAmpA1( mom2, mom1, mom4, mom3 ) + EvtAmpA1( mom4, mom3, mom2, mom1 ) + EvtAmpA1( mom4, mom1, mom2, mom3 ); A = A_a2p * a2p_amp + A_a1p * a1p_amp + A_a2m * a2m_amp + A_a1m * a1m_amp; Abar = Abar_a2p * a2p_amp + Abar_a1p * a1p_amp + Abar_a2m * a2m_amp + Abar_a1m * a1m_amp; if ( other_b == B0B ) { amp = A * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + EvtComplex( cos( -2.0 * getArg( 0 ) ), sin( -2.0 * getArg( 0 ) ) ) * getArg( 2 ) * EvtComplex( 0.0, 1.0 ) * Abar * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); } if ( other_b == B0 ) { amp = A * EvtComplex( cos( 2.0 * getArg( 0 ) ), sin( 2.0 * getArg( 0 ) ) ) * EvtComplex( 0.0, 1.0 ) * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + getArg( 2 ) * Abar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); } vertex( amp ); return; } diff --git a/src/EvtGenModels/EvtBToKpipiCP.cpp b/src/EvtGenModels/EvtBToKpipiCP.cpp index d4b961d..c9c7bbe 100644 --- a/src/EvtGenModels/EvtBToKpipiCP.cpp +++ b/src/EvtGenModels/EvtBToKpipiCP.cpp @@ -1,125 +1,130 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtBToKpipiCP.hh" #include "EvtGenBase/EvtCPUtil.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtVector4R.hh" #include #include std::string EvtBToKpipiCP::getName() { return "BTOKPIPI_CP"; } EvtBToKpipiCP* EvtBToKpipiCP::clone() { return new EvtBToKpipiCP; } void EvtBToKpipiCP::init() { // check that there are 3 arguments checkNArg( 3 ); checkNDaug( 3 ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::SCALAR ); checkSpinDaughter( 2, EvtSpinType::SCALAR ); double alpha = getArg( 1 ); double beta = getArg( 2 ); int iset; iset = 10000; EvtVector4R p4Kplus, p4piminus, p4gamm1, p4gamm2; double realA, imgA, realbarA, imgbarA; generator.EvtKpipi( alpha, beta, iset, p4Kplus, p4piminus, p4gamm1, p4gamm2, realA, imgA, realbarA, imgbarA ); } +void EvtBToKpipiCP::initProbMax() +{ + setProbMax( 1.2 ); +} + void EvtBToKpipiCP::decay( EvtParticle* p ) { //added by Lange Jan4,2000 static EvtId B0 = EvtPDL::getId( "B0" ); static EvtId B0B = EvtPDL::getId( "anti-B0" ); double t; EvtId other_b; EvtCPUtil::getInstance()->OtherB( p, t, other_b, 0.5 ); EvtParticle *Kp, *pim, *pi0; p->makeDaughters( getNDaug(), getDaugs() ); Kp = p->getDaug( 0 ); pim = p->getDaug( 1 ); pi0 = p->getDaug( 2 ); EvtVector4R p4[3]; //double dm=getArg(0); double alpha = getArg( 1 ); double beta = getArg( 2 ); int iset; iset = 0; EvtVector4R p4Kplus, p4piminus, p4gamm1, p4gamm2; double realA, imgA, realbarA, imgbarA; generator.EvtKpipi( alpha, beta, iset, p4[0], p4[1], p4gamm1, p4gamm2, realA, imgA, realbarA, imgbarA ); p4[2] = p4gamm1 + p4gamm2; Kp->init( getDaug( 0 ), p4[0] ); pim->init( getDaug( 1 ), p4[1] ); pi0->init( getDaug( 2 ), p4[2] ); EvtComplex amp; EvtComplex A( realA, imgA ); EvtComplex Abar( realbarA, imgbarA ); if ( other_b == B0B ) { amp = Abar; } if ( other_b == B0 ) { amp = A; } vertex( amp ); return; } diff --git a/src/EvtGenModels/EvtBsquark.cpp b/src/EvtGenModels/EvtBsquark.cpp index 46c5530..65c61a9 100644 --- a/src/EvtGenModels/EvtBsquark.cpp +++ b/src/EvtGenModels/EvtBsquark.cpp @@ -1,206 +1,204 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtBsquark.hh" #include "EvtGenBase/EvtDiracParticle.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtGammaMatrix.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtIdSet.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include #include std::string EvtBsquark::getName() { return "BSQUARK"; } EvtDecayBase* EvtBsquark::clone() { return new EvtBsquark; } void EvtBsquark::init() { // check that there are 5 arguments checkNArg( 5 ); } void EvtBsquark::initProbMax() { - //For now do not set a maximum. - - //SetProbMax(0.000000000005); + setProbMax( 1e-6 ); } void EvtBsquark::decay( EvtParticle* p ) { static EvtId cquark = EvtPDL::getId( "c" ); static EvtId anticquark = EvtPDL::getId( "anti-c" ); static EvtIdSet leptons( "e-", "mu-", "tau-" ); p->initializePhaseSpace( getNDaug(), getDaugs() ); int charge = 1; EvtParticle* lepton; lepton = p->getDaug( 1 ); if ( leptons.contains( lepton->getId() ) ) { charge = -1; } EvtDiracParticle charmquark; //this is a very crude approximation... if ( charge == -1 ) { charmquark.init( cquark, p->getDaug( 0 )->getP4() ); } else { charmquark.init( anticquark, p->getDaug( 0 )->getP4() ); } EvtVector4R p4c = p->getDaug( 0 )->getP4(); EvtVector4R p4sn = p->getDaug( 2 )->getP4(); EvtVector4R p4b( p->mass(), 0.0, 0.0, 0.0 ); EvtComplex M[2][2]; int il, ic; //project out the right handed current EvtGammaMatrix PR = 0.5 * ( EvtGammaMatrix::id() + EvtGammaMatrix::g5() ); double tanbeta = getArg( 1 ); double cosbeta = cos( atan( tanbeta ) ); double sinbeta = sin( atan( tanbeta ) ); double mb = 4.9; double mc = 1.3; double mw = 80.4; double Mass = getArg( 2 ); double mu = getArg( 3 ); double mchargino = getArg( 4 ); double tan2phim = 2 * sqrt( 2.0 ) * mw * ( mu * cosbeta + Mass * sinbeta ) / ( Mass * Mass - mu * mu + 2 * mw * mw * cos( 2 * atan( tanbeta ) ) ); double phim = 0.5 * atan( tan2phim ); EvtComplex U11 = cos( phim ); EvtComplex U12 = sin( phim ); EvtComplex U21 = -sin( phim ); EvtComplex U22 = cos( phim ); double tan2phip = 2 * sqrt( 2.0 ) * mw * ( mu * cosbeta + Mass * sinbeta ) / ( Mass * Mass - mu * mu - 2 * mw * mw * cos( 2 * atan( tanbeta ) ) ); double phip = 0.5 * atan( tan2phip ); EvtComplex V11 = cos( phip ); EvtComplex V12 = sin( phip ); EvtComplex V21 = -sin( phip ); EvtComplex V22 = cos( phip ); double theta = getArg( 0 ); double ctheta = cos( theta ); double stheta = sin( theta ); double vcsb = 0.08; double mchi1 = mchargino; double mchi2 = mchargino; //overall scale factor double g = 1.0; EvtComplex a1 = mchi1 * ( U11 * ctheta - mb * U12 * stheta / ( sqrt( 2.0 ) * mw * cosbeta ) ); EvtComplex a2 = mchi2 * ( U21 * ctheta - mb * U22 * stheta / ( sqrt( 2.0 ) * mw * cosbeta ) ); EvtComplex b1 = mc * conj( V12 ) * ctheta / ( sqrt( 2.0 ) * mw * sinbeta ); EvtComplex b2 = mc * conj( V22 ) * ctheta / ( sqrt( 2.0 ) * mw * sinbeta ); EvtComplex f1 = -( g * g * V11 * vcsb ) / ( ( p4b - p4c ).mass2() - mchi1 * mchi1 ); EvtComplex f2 = -( g * g * V21 * vcsb ) / ( ( p4b - p4c ).mass2() - mchi1 * mchi2 ); //EvtGenReport(EVTGEN_INFO,"EvtGen") <spParent( il ) ); b = charmquark.spParent( ic ) * ( ( pslash * PR ) * lepton->spParent( il ) ); } else { a = lepton->spParent( il ) * ( PR * charmquark.spParent( ic ) ); b = lepton->spParent( il ) * ( ( pslash * PR ) * charmquark.spParent( ic ) ); } //EvtGenReport(EVTGEN_INFO,"EvtGen") <<"pslash*PR:"<spParent(il)<. * ***********************************************************************/ #include "EvtGenModels/EvtBtoKD3P.hh" #include "EvtGenBase/EvtCyclic3.hh" #include "EvtGenBase/EvtDalitzPoint.hh" #include "EvtGenBase/EvtDecayTable.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenModels/EvtPto3P.hh" #include using std::endl; //------------------------------------------------------------------ EvtDecayBase* EvtBtoKD3P::clone() { return new EvtBtoKD3P(); } //------------------------------------------------------------------ std::string EvtBtoKD3P::getName() { return "BTOKD3P"; } //------------------------------------------------------------------ void EvtBtoKD3P::init() { checkNArg( 2 ); // r, phase checkNDaug( 3 ); // K, D0(allowed), D0(suppressed). // The last two daughters are really one particle // check that the mother and all daughters are scalars: checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::SCALAR ); checkSpinDaughter( 2, EvtSpinType::SCALAR ); // Check that the B dtr types are K D D: // get the parameters: _r = getArg( 0 ); double phase = getArg( 1 ); _exp = EvtComplex( cos( phase ), sin( phase ) ); } //------------------------------------------------------------------ void EvtBtoKD3P::initProbMax() { setProbMax( 1 ); // this is later changed in decay() } //------------------------------------------------------------------ void EvtBtoKD3P::decay( EvtParticle* p ) { // tell the subclass that we decay the daughter: _daugsDecayedByParentModel = true; // the K is the 1st daughter of the B EvtParticle. // The decay mode of the allowed D (the one produced in b->c decay) is 2nd // The decay mode of the suppressed D (the one produced in b->u decay) is 3rd const int KIND = 0; const int D1IND = 1; const int D2IND = 2; // generate kinematics of daughters (K and D): EvtId tempDaug[2] = {getDaug( KIND ), getDaug( D1IND )}; p->initializePhaseSpace( 2, tempDaug ); // Get the D daughter particle and the decay models of the allowed // and suppressed D modes: EvtParticle* theD = p->getDaug( D1IND ); EvtPto3P* model1 = (EvtPto3P*)( EvtDecayTable::getInstance()->getDecayFunc( theD ) ); - // for the suppressed mode, re-initialize theD as the suppressed D alias: + // For the suppressed mode, re-initialize theD as the suppressed D alias. + // First set the id, then re-initialize (since it matches the expected id) + theD->setId( getDaug( D2IND ) ); theD->init( getDaug( D2IND ), theD->getP4() ); EvtPto3P* model2 = (EvtPto3P*)( EvtDecayTable::getInstance()->getDecayFunc( theD ) ); // on the first call: if ( false == _decayedOnce ) { _decayedOnce = true; // store the D decay model pointers: _model1 = model1; _model2 = model2; // check the decay models of the first 2 daughters and that they // have the same final states: std::string name1 = model1->getName(); std::string name2 = model2->getName(); if ( name1 != "PTO3P" ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "D daughters of EvtBtoKD3P decay must decay via the \"PTO3P\" model" << endl << " but found to decay via " << name1.c_str() << " or " << name2.c_str() << ". Will terminate execution!" << endl; assert( 0 ); } EvtId* daugs1 = model1->getDaugs(); EvtId* daugs2 = model2->getDaugs(); bool idMatch = true; int d; for ( d = 0; d < 2; ++d ) { if ( daugs1[d] != daugs2[d] ) { idMatch = false; } } if ( false == idMatch ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "D daughters of EvtBtoKD3P decay must decay to the same final state" << endl << " particles in the same order (not CP-conjugate order)," << endl << " but they were found to decay to" << endl; for ( d = 0; d < model1->getNDaug(); ++d ) { EvtGenReport( EVTGEN_ERROR, "" ) << " " << EvtPDL::name( daugs1[d] ).c_str() << " "; } EvtGenReport( EVTGEN_ERROR, "" ) << endl; for ( d = 0; d < model1->getNDaug(); ++d ) { EvtGenReport( EVTGEN_ERROR, "" ) << " " << EvtPDL::name( daugs2[d] ).c_str() << " "; } EvtGenReport( EVTGEN_ERROR, "" ) << endl << ". Will terminate execution!" << endl; assert( 0 ); } // estimate the probmax. Need to know the probmax's of the 2 // models for this: setProbMax( model1->getProbMax( 0 ) + _r * _r * model2->getProbMax( 0 ) + 2 * _r * sqrt( model1->getProbMax( 0 ) * model2->getProbMax( 0 ) ) ); } // end of things to do on the first call // make sure the models haven't changed since the first call: if ( _model1 != model1 || _model2 != model2 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "D daughters of EvtBtoKD3P decay should have only 1 decay modes, " << endl << " but a new decay mode was found after the first call" << endl << " Will terminate execution!" << endl; assert( 0 ); } + // Reset the D id to the 1st D + theD->setId( getDaug( D1IND ) ); + theD->init( getDaug( D1IND ), theD->getP4() ); + // get the cover function for each of the models and add them up. // They are summed with coefficients 1 because we are willing to // take a small inefficiency (~50%) in order to ensure that the // cover function is large enough without getting into complications // associated with the smallness of _r: EvtPdfSum* pc1 = model1->getPC(); EvtPdfSum* pc2 = model2->getPC(); EvtPdfSum pc; pc.addTerm( 1.0, *pc1 ); pc.addTerm( 1.0, *pc2 ); // from this combined cover function, generate the Dalitz point: EvtDalitzPoint x = pc.randomPoint(); // get the aptitude for each of the models on this point and add them up: EvtComplex amp1 = model1->amplNonCP( x ); EvtComplex amp2 = model2->amplNonCP( x ); EvtComplex amp = amp1 + amp2 * _r * _exp; // get the value of the cover function for this point and set the // relative amplitude for this decay: double comp = sqrt( pc.evaluate( x ) ); vertex( amp / comp ); // Make the daughters of theD: bool massTreeOK = theD->generateMassTree(); if ( massTreeOK == false ) { return; } // Now generate the p4's of the daughters of theD: std::vector v = model2->initDaughters( x ); if ( v.size() != theD->getNDaug() ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Number of daughters " << theD->getNDaug() << " != " << "Momentum vector size " << v.size() << endl << " Terminating execution." << endl; assert( 0 ); } // Apply the new p4's to the daughters: for ( unsigned int i = 0; i < theD->getNDaug(); ++i ) { theD->getDaug( i )->init( model2->getDaugs()[i], v[i] ); } } diff --git a/src/EvtGenModels/EvtBtoKpiCPiso.cpp b/src/EvtGenModels/EvtBtoKpiCPiso.cpp index 8f27a96..b8c8401 100644 --- a/src/EvtGenModels/EvtBtoKpiCPiso.cpp +++ b/src/EvtGenModels/EvtBtoKpiCPiso.cpp @@ -1,201 +1,201 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtBtoKpiCPiso.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include #include std::string EvtBtoKpiCPiso::getName() { return "BTOKPI_CP_ISO"; } EvtDecayBase* EvtBtoKpiCPiso::clone() { return new EvtBtoKpiCPiso; } void EvtBtoKpiCPiso::init() { - // check that there are 15 arguments - checkNArg( 15 ); + // check that there are 14 arguments + checkNArg( 14 ); checkNDaug( 2 ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::SCALAR ); } void EvtBtoKpiCPiso::initProbMax() { //this might need to be revised //added by Lange Jan4,2000 static EvtId PI0 = EvtPDL::getId( "pi0" ); static EvtId PIP = EvtPDL::getId( "pi+" ); - static EvtId PIM = EvtPDL::getId( "pi+" ); + static EvtId PIM = EvtPDL::getId( "pi-" ); static EvtId K0 = EvtPDL::getId( "K0" ); static EvtId KB = EvtPDL::getId( "anti-K0" ); static EvtId KP = EvtPDL::getId( "K+" ); static EvtId KM = EvtPDL::getId( "K-" ); if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == KP ) ) || ( ( getDaug( 0 ) == KP ) && ( getDaug( 1 ) == PI0 ) ) ) { setProbMax( 2.0 * ( getArg( 2 ) * getArg( 2 ) + getArg( 10 ) * getArg( 10 ) ) ); } if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == KM ) ) || ( ( getDaug( 0 ) == KM ) && ( getDaug( 1 ) == PI0 ) ) ) { setProbMax( 2.0 * ( getArg( 4 ) * getArg( 4 ) + getArg( 12 ) * getArg( 12 ) ) ); } if ( ( ( getDaug( 0 ) == PIP ) && ( getDaug( 1 ) == K0 ) ) || ( ( getDaug( 0 ) == K0 ) && ( getDaug( 1 ) == PIP ) ) ) { setProbMax( 4.0 * ( getArg( 6 ) * getArg( 6 ) + getArg( 10 ) * getArg( 10 ) ) ); } if ( ( ( getDaug( 0 ) == PIM ) && ( getDaug( 1 ) == KB ) ) || ( ( getDaug( 0 ) == KB ) && ( getDaug( 1 ) == PIM ) ) ) { setProbMax( 4.0 * ( getArg( 8 ) * getArg( 8 ) + getArg( 12 ) * getArg( 12 ) ) ); } if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == K0 ) ) || ( ( getDaug( 0 ) == K0 ) && ( getDaug( 1 ) == PI0 ) ) ) { setProbMax( 2.0 * ( getArg( 2 ) * getArg( 2 ) + getArg( 10 ) * getArg( 10 ) ) ); } if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == KB ) ) || ( ( getDaug( 0 ) == KB ) && ( getDaug( 1 ) == PI0 ) ) ) { setProbMax( 2.0 * ( getArg( 4 ) * getArg( 4 ) + getArg( 12 ) * getArg( 12 ) ) ); } if ( ( ( getDaug( 0 ) == PIM ) && ( getDaug( 1 ) == KP ) ) || ( ( getDaug( 0 ) == KP ) && ( getDaug( 1 ) == PIM ) ) ) { setProbMax( 4.0 * ( getArg( 6 ) * getArg( 6 ) + getArg( 10 ) * getArg( 10 ) ) ); } if ( ( ( getDaug( 0 ) == PIP ) && ( getDaug( 1 ) == KM ) ) || ( ( getDaug( 0 ) == KM ) && ( getDaug( 1 ) == PIP ) ) ) { setProbMax( 4.0 * ( getArg( 8 ) * getArg( 8 ) + getArg( 12 ) * getArg( 12 ) ) ); } } void EvtBtoKpiCPiso::decay( EvtParticle* p ) { p->initializePhaseSpace( getNDaug(), getDaugs() ); //added by Lange Jan4,2000 static EvtId PI0 = EvtPDL::getId( "pi0" ); static EvtId PIP = EvtPDL::getId( "pi+" ); - static EvtId PIM = EvtPDL::getId( "pi+" ); + static EvtId PIM = EvtPDL::getId( "pi-" ); static EvtId K0 = EvtPDL::getId( "K0" ); static EvtId KB = EvtPDL::getId( "anti-K0" ); static EvtId KP = EvtPDL::getId( "K+" ); static EvtId KM = EvtPDL::getId( "K-" ); EvtComplex A; EvtComplex U, Ubar, V, Vbar, W, Wbar; U = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ), getArg( 2 ) * sin( getArg( 3 ) ) ); Ubar = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ), getArg( 4 ) * sin( getArg( 5 ) ) ); V = EvtComplex( getArg( 6 ) * cos( getArg( 7 ) ), getArg( 6 ) * sin( getArg( 7 ) ) ); Vbar = EvtComplex( getArg( 8 ) * cos( getArg( 9 ) ), getArg( 8 ) * sin( getArg( 9 ) ) ); W = EvtComplex( getArg( 10 ) * cos( getArg( 11 ) ), getArg( 10 ) * sin( getArg( 11 ) ) ); Wbar = EvtComplex( getArg( 12 ) * cos( getArg( 13 ) ), getArg( 12 ) * sin( getArg( 13 ) ) ); //depending on what combination of K pi we have, there will be different //A and Abar (only A given in comments!) if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == KP ) ) || ( ( getDaug( 0 ) == KP ) && ( getDaug( 1 ) == PI0 ) ) ) { //pi0 K+, so U - W A = U - W; } if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == KM ) ) || ( ( getDaug( 0 ) == KM ) && ( getDaug( 1 ) == PI0 ) ) ) { //pi0 K-, so Ubar - Wbar A = Ubar - Wbar; } if ( ( ( getDaug( 0 ) == PIP ) && ( getDaug( 1 ) == K0 ) ) || ( ( getDaug( 0 ) == K0 ) && ( getDaug( 1 ) == PIP ) ) ) { //pi+ K0, so V + W A = sqrt( 2.0 ) * ( V + W ); } if ( ( ( getDaug( 0 ) == PIM ) && ( getDaug( 1 ) == KB ) ) || ( ( getDaug( 0 ) == KB ) && ( getDaug( 1 ) == PIM ) ) ) { //pi- K0bar, so Vbar + Wbar A = sqrt( 2.0 ) * ( Vbar + Wbar ); } if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == K0 ) ) || ( ( getDaug( 0 ) == K0 ) && ( getDaug( 1 ) == PI0 ) ) ) { //pi0 K0, so U + W A = U + W; } if ( ( ( getDaug( 0 ) == PI0 ) && ( getDaug( 1 ) == KB ) ) || ( ( getDaug( 0 ) == KB ) && ( getDaug( 1 ) == PI0 ) ) ) { A = Ubar + Wbar; } if ( ( ( getDaug( 0 ) == PIM ) && ( getDaug( 1 ) == KP ) ) || ( ( getDaug( 0 ) == KP ) && ( getDaug( 1 ) == PIM ) ) ) { //pi- K+, so V - W A = sqrt( 2.0 ) * ( V - W ); } if ( ( ( getDaug( 0 ) == PIP ) && ( getDaug( 1 ) == KM ) ) || ( ( getDaug( 0 ) == KM ) && ( getDaug( 1 ) == PIP ) ) ) { A = sqrt( 2.0 ) * ( Vbar - Wbar ); } vertex( A ); return; } diff --git a/src/EvtGenModels/EvtDMix.cpp b/src/EvtGenModels/EvtDMix.cpp index 142bc3c..07026fd 100644 --- a/src/EvtGenModels/EvtDMix.cpp +++ b/src/EvtGenModels/EvtDMix.cpp @@ -1,96 +1,96 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtDMix.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include #include std::string EvtDMix::getName() { return "DMIX"; } EvtDecayBase* EvtDMix::clone() { return new EvtDMix; } void EvtDMix::init() { - // check that there are 0 arguments + // check arguments checkNArg( 3 ); _rd = getArg( 0 ); _xpr = getArg( 1 ); _ypr = getArg( 2 ); } void EvtDMix::initProbMax() { noProbMax(); } void EvtDMix::decay( EvtParticle* p ) { //unneeded - lange - may13-02 //if ( p->getNDaug() != 0 ) { //Will end up here because maxrate multiplies by 1.2 // EvtGenReport(EVTGEN_DEBUG,"EvtGen") << "In EvtDMix: has " // <<" daugthers should not be here!"<initializePhaseSpace( getNDaug(), getDaugs() ); double ctau = EvtPDL::getctau( p->getId() ); if ( ctau == 0. ) return; double pdf, random, gt, weight; double maxPdf = _rd + sqrt( _rd ) * _ypr * 50. + 2500.0 * ( _xpr * _xpr + _ypr * _ypr ) / 4.0; bool keepGoing = true; while ( keepGoing ) { random = EvtRandom::Flat(); gt = -log( random ); weight = random; pdf = _rd + sqrt( _rd ) * _ypr * gt + gt * gt * ( _xpr * _xpr + _ypr * _ypr ) / 4.0; pdf *= exp( -1.0 * gt ); pdf /= weight; if ( pdf > maxPdf ) std::cout << pdf << " " << weight << " " << maxPdf << " " << gt << std::endl; if ( pdf > maxPdf * EvtRandom::Flat() ) keepGoing = false; } p->setLifetime( gt * ctau ); return; } diff --git a/src/EvtGenModels/EvtISGW.cpp b/src/EvtGenModels/EvtISGW.cpp index 0f2507c..6c738fe 100644 --- a/src/EvtGenModels/EvtISGW.cpp +++ b/src/EvtGenModels/EvtISGW.cpp @@ -1,82 +1,87 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtISGW.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtSemiLeptonicScalarAmp.hh" #include "EvtGenBase/EvtSemiLeptonicTensorAmp.hh" #include "EvtGenBase/EvtSemiLeptonicVectorAmp.hh" #include "EvtGenModels/EvtISGWFF.hh" #include #include std::string EvtISGW::getName() { return "ISGW"; } EvtDecayBase* EvtISGW::clone() { return new EvtISGW; } void EvtISGW::decay( EvtParticle* p ) { p->initializePhaseSpace( getNDaug(), getDaugs() ); calcamp->CalcAmp( p, _amp2, isgwffmodel.get() ); } void EvtISGW::init() { checkNArg( 0 ); checkNDaug( 3 ); //We expect the parent to be a scalar //and the daughters to be X lepton neutrino EvtSpinType::spintype mesontype = EvtPDL::getSpinType( getDaug( 0 ) ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::DIRAC ); checkSpinDaughter( 2, EvtSpinType::NEUTRINO ); isgwffmodel = std::make_unique(); switch ( mesontype ) { case EvtSpinType::SCALAR: calcamp = std::make_unique(); break; case EvtSpinType::VECTOR: calcamp = std::make_unique(); break; case EvtSpinType::TENSOR: calcamp = std::make_unique(); break; default:; } } + +void EvtISGW::initProbMax() +{ + setProbMax( 10000.0 ); +} diff --git a/src/EvtGenModels/EvtKKLambdaC.cpp b/src/EvtGenModels/EvtKKLambdaC.cpp index 9aebafc..562ef40 100644 --- a/src/EvtGenModels/EvtKKLambdaC.cpp +++ b/src/EvtGenModels/EvtKKLambdaC.cpp @@ -1,82 +1,82 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtKKLambdaC.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtSemiLeptonicBaryonAmp.hh" #include "EvtGenModels/EvtKKLambdaCFF.hh" #include #include std::string EvtKKLambdaC::getName() { return "KK_LAMBDAC_SL"; } EvtDecayBase* EvtKKLambdaC::clone() { return new EvtKKLambdaC; } void EvtKKLambdaC::decay( EvtParticle* p ) { p->initializePhaseSpace( getNDaug(), getDaugs() ); _calcamp->CalcAmp( p, _amp2, _ffmodel.get() ); } void EvtKKLambdaC::initProbMax() { EvtId parnum, mesnum, lnum, nunum; parnum = getParentId(); mesnum = getDaug( 0 ); lnum = getDaug( 1 ); nunum = getDaug( 2 ); //double mymaxprob = _calcamp->CalcMaxProb(parnum,mesnum, // lnum,nunum,_ffmodel); - double mymaxprob = 100.; + double mymaxprob = 1e3; setProbMax( mymaxprob ); } void EvtKKLambdaC::init() { checkNDaug( 3 ); //We expect the parent to be a dirac //and the daughters to be dirac lepton neutrino checkSpinParent( EvtSpinType::DIRAC ); checkSpinDaughter( 0, EvtSpinType::DIRAC ); checkSpinDaughter( 1, EvtSpinType::DIRAC ); checkSpinDaughter( 2, EvtSpinType::NEUTRINO ); _ffmodel = std::make_unique( getNArg(), getArgs() ); _calcamp = std::make_unique(); } diff --git a/src/EvtGenModels/EvtKstarnunu.cpp b/src/EvtGenModels/EvtKstarnunu.cpp index fb9b86d..b1744ba 100644 --- a/src/EvtGenModels/EvtKstarnunu.cpp +++ b/src/EvtGenModels/EvtKstarnunu.cpp @@ -1,134 +1,139 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtKstarnunu.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include #include #include std::string EvtKstarnunu::getName() { return "KSTARNUNU"; } EvtDecayBase* EvtKstarnunu::clone() { return new EvtKstarnunu; } void EvtKstarnunu::init() { // check that there are 0 arguments checkNArg( 0 ); checkNDaug( 3 ); //We expect the parent to be a scalar //and the daughters to be K neutrino netrino checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::VECTOR ); checkSpinDaughter( 1, EvtSpinType::NEUTRINO ); checkSpinDaughter( 2, EvtSpinType::NEUTRINO ); } +void EvtKstarnunu::initProbMax() +{ + setProbMax( 7000.0 ); +} + void EvtKstarnunu::decay( EvtParticle* p ) { static EvtId NUE = EvtPDL::getId( "nu_e" ); static EvtId NUM = EvtPDL::getId( "nu_mu" ); static EvtId NUT = EvtPDL::getId( "nu_tau" ); static EvtId NUEB = EvtPDL::getId( "anti-nu_e" ); static EvtId NUMB = EvtPDL::getId( "anti-nu_mu" ); static EvtId NUTB = EvtPDL::getId( "anti-nu_tau" ); p->initializePhaseSpace( getNDaug(), getDaugs() ); double m_b = p->mass(); EvtParticle *meson, *neutrino1, *neutrino2; meson = p->getDaug( 0 ); neutrino1 = p->getDaug( 1 ); neutrino2 = p->getDaug( 2 ); EvtVector4R momnu1 = neutrino1->getP4(); EvtVector4R momnu2 = neutrino2->getP4(); EvtVector4R momkstar = meson->getP4(); double v0_0, a1_0, a2_0; double m2v0, a1_b, a2_b; v0_0 = 0.47; a1_0 = 0.37; a2_0 = 0.40; m2v0 = 5. * 5.; a1_b = -0.023; a2_b = 0.034; EvtVector4R q = momnu1 + momnu2; double q2 = q.mass2(); double v0, a1, a2; v0 = v0_0 / ( 1 - q2 / m2v0 ); a1 = a1_0 * ( 1 + a1_b * q2 ); a2 = a2_0 * ( 1 + a2_b * q2 ); EvtVector4R p4b; p4b.set( m_b, 0., 0., 0. ); // Do calcs in mother rest frame double m_k = meson->mass(); EvtTensor4C tds = ( -2 * v0 / ( m_b + m_k ) ) * dual( EvtGenFunctions::directProd( p4b, momkstar ) ) - EvtComplex( 0.0, 1.0 ) * ( ( m_b + m_k ) * a1 * EvtTensor4C::g() - ( a2 / ( m_b + m_k ) ) * EvtGenFunctions::directProd( p4b - momkstar, p4b + momkstar ) ); EvtVector4C l; if ( getDaug( 1 ) == NUE || getDaug( 1 ) == NUM || getDaug( 1 ) == NUT ) { l = EvtLeptonVACurrent( neutrino1->spParentNeutrino(), neutrino2->spParentNeutrino() ); } if ( getDaug( 1 ) == NUEB || getDaug( 1 ) == NUMB || getDaug( 1 ) == NUTB ) { l = EvtLeptonVACurrent( neutrino2->spParentNeutrino(), neutrino1->spParentNeutrino() ); } EvtVector4C et0, et1, et2; et0 = tds.cont1( meson->epsParent( 0 ).conj() ); et1 = tds.cont1( meson->epsParent( 1 ).conj() ); et2 = tds.cont1( meson->epsParent( 2 ).conj() ); vertex( 0, l * et0 ); vertex( 1, l * et1 ); vertex( 2, l * et2 ); return; } diff --git a/src/EvtGenModels/EvtLambdaB2LambdaV.cpp b/src/EvtGenModels/EvtLambdaB2LambdaV.cpp index d7f1cc8..f541960 100644 --- a/src/EvtGenModels/EvtLambdaB2LambdaV.cpp +++ b/src/EvtGenModels/EvtLambdaB2LambdaV.cpp @@ -1,1488 +1,1409 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtLambdaB2LambdaV.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include #include #include #include using std::fstream; //************************************************************************ //* * //* Class EvtLambdaB2LambdaV * //* * //************************************************************************ //DECLARE_COMPONENT( EvtLambdaB2LambdaV ); EvtLambdaB2LambdaV::EvtLambdaB2LambdaV() { //set facility name fname = "EvtGen.EvtLambdaB2LambdaV"; } //------------------------------------------------------------------------ // Method 'getName' //------------------------------------------------------------------------ std::string EvtLambdaB2LambdaV::getName() { return "LAMBDAB2LAMBDAV"; } //------------------------------------------------------------------------ // Method 'clone' //------------------------------------------------------------------------ EvtDecayBase* EvtLambdaB2LambdaV::clone() { return new EvtLambdaB2LambdaV; } //------------------------------------------------------------------------ // Method 'initProbMax' //------------------------------------------------------------------------ void EvtLambdaB2LambdaV::initProbMax() { //maximum (case where C=0) - double Max = 1 + fabs( A * B ); - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " PDF max value : " << Max << std::endl; + double Max = 1.0 + fabs( A * B ) + 2.0 * fabs( A * abs( C ) ); + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " PDF max value : " << Max << std::endl; + } setProbMax( Max ); } //------------------------------------------------------------------------ // Method 'init' //------------------------------------------------------------------------ void EvtLambdaB2LambdaV::init() { bool antiparticle = false; //introduction - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << "*************************************************" << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << "* Event Model Class : EvtLambdaB2LambdaV *" << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << "*************************************************" << std::endl; + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << "*************************************************" << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << "* Event Model Class : EvtLambdaB2LambdaV *" << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << "*************************************************" << std::endl; + } //check the number of arguments checkNArg( 2 ); //check the number of daughters checkNDaug( 2 ); const EvtId Id_mother = getParentId(); const EvtId Id_daug1 = getDaug( 0 ); const EvtId Id_daug2 = getDaug( 1 ); //lambdab identification if ( Id_mother == EvtPDL::getId( "Lambda_b0" ) ) { antiparticle = false; } else if ( Id_mother == EvtPDL::getId( "anti-Lambda_b0" ) ) { antiparticle = true; } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Mother is not a Lambda_b0 or an anti-Lambda_b0, but a " << EvtPDL::name( Id_mother ) << std::endl; abort(); } //lambda if ( !( Id_daug1 == EvtPDL::getId( "Lambda0" ) && !antiparticle ) && !( Id_daug1 == EvtPDL::getId( "anti-Lambda0" ) && antiparticle ) ) { if ( !antiparticle ) { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter1 is not a Lambda0, but a " << EvtPDL::name( Id_daug1 ) << std::endl; } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter1 is not an anti-Lambda0, but a " << EvtPDL::name( Id_daug1 ) << std::endl; } abort(); } //identification meson V if ( getArg( 1 ) == 1 ) Vtype = VID::JPSI; else if ( getArg( 1 ) == 2 ) Vtype = VID::RHO; else if ( getArg( 1 ) == 3 ) Vtype = VID::OMEGA; else if ( getArg( 1 ) == 4 ) Vtype = VID::RHO_OMEGA_MIXING; else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Vtype " << getArg( 1 ) << " is unknown" << std::endl; abort(); } //check vector meson V if ( Id_daug2 == EvtPDL::getId( "J/psi" ) && Vtype == VID::JPSI ) { if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : Lambda_b0 -> Lambda J/psi" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : anti-Lambda_b0 -> anti-Lambda J/psi" << std::endl; } else if ( Id_daug2 == EvtPDL::getId( "rho0" ) && Vtype == VID::RHO ) { if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : Lambda_b0 -> Lambda rho0" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : anti-Lambda_b0 -> anti-Lambda rho0" << std::endl; } else if ( Id_daug2 == EvtPDL::getId( "omega" ) && Vtype == VID::OMEGA ) { if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : Lambda_b0 -> Lambda omega" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : anti-Lambda_b0 -> anti-Lambda omega" << std::endl; } else if ( ( Id_daug2 == EvtPDL::getId( "omega" ) || Id_daug2 == EvtPDL::getId( "rho0" ) ) && Vtype == VID::RHO_OMEGA_MIXING ) { if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : " << "Lambda_b0 -> Lambda rho-omega-mixing" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : " << "anti-Lambda_b0 -> anti-Lambda rho-omega-mixing" << std::endl; } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter2 is not a J/psi, phi or rho0 but a " << EvtPDL::name( Id_daug2 ) << std::endl; abort(); } //fix dynamics parameters B = (double)getArg( 0 ); C = EvtComplex( ( sqrt( 2. ) / 2. ), ( sqrt( 2. ) / 2. ) ); switch ( Vtype ) { case VID::JPSI: A = 0.490; break; case VID::RHO: case VID::OMEGA: case VID::RHO_OMEGA_MIXING: A = 0.194; break; default: A = 0; break; } - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " LambdaB decay parameters : " << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - lambda asymmetry A = " << A << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - lambdab polarisation B = " << B << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - lambdab density matrix rho+- C = " << C << std::endl; + + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " LambdaB decay parameters : " << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - lambda asymmetry A = " << A << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - lambdab polarisation B = " << B << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - lambdab density matrix rho+- C = " << C << std::endl; + } } //------------------------------------------------------------------------ // Method 'decay' //------------------------------------------------------------------------ void EvtLambdaB2LambdaV::decay( EvtParticle* lambdab ) { + // Using formulae from hep-ph/0602043 + lambdab->makeDaughters( getNDaug(), getDaugs() ); //get lambda and V particles EvtParticle* lambda = lambdab->getDaug( 0 ); EvtParticle* V = lambdab->getDaug( 1 ); //get resonance masses // - LAMBDAB -> mass given by the preceding class // - LAMBDA -> nominal mass // - V -> getVmass method double MASS_LAMBDAB = lambdab->mass(); double MASS_LAMBDA = EvtPDL::getMeanMass( EvtPDL::getId( "Lambda0" ) ); double MASS_V = getVMass( MASS_LAMBDAB, MASS_LAMBDA ); //generate random angles double phi = EvtRandom::Flat( 0, 2 * EvtConst::pi ); double theta = acos( EvtRandom::Flat( -1, +1 ) ); - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " Angular angles : theta = " << theta << " ; phi = " << phi - << std::endl; - //computate resonance quadrivectors + + // Get 4-vectors double E_lambda = ( MASS_LAMBDAB * MASS_LAMBDAB + MASS_LAMBDA * MASS_LAMBDA - MASS_V * MASS_V ) / ( 2 * MASS_LAMBDAB ); double E_V = ( MASS_LAMBDAB * MASS_LAMBDAB + MASS_V * MASS_V - MASS_LAMBDA * MASS_LAMBDA ) / ( 2 * MASS_LAMBDAB ); double P = sqrt( E_lambda * E_lambda - lambda->mass() * lambda->mass() ); EvtVector4R P_lambdab = lambdab->getP4(); double px = P_lambdab.get( 1 ); double py = P_lambdab.get( 2 ); double pz = P_lambdab.get( 3 ); double E = P_lambdab.get( 0 ); - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << "E of lambdab: " << P_lambdab.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << "E of lambdab: " << E << std::endl; - - EvtVector4R q_lambdab2( E, - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( px * ( px ) ) + ( py * ( py ) ) ) ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( -( ( py ) * ( px ) ) + ( px * ( py ) ) ) ), - ( pz ) ); + + const double pxSq = px * px; + const double pySq = py * py; + const double pT = sqrt( pxSq + pySq ); + const double invPT = pT > 0.0 ? 1.0 / pT : 0.0; + EvtVector4R q_lambdab2( E, pT, 0.0, pz ); EvtVector4R q_lambdab3( E, q_lambdab2.get( 3 ), q_lambdab2.get( 1 ), q_lambdab2.get( 2 ) ); EvtVector4R q_lambda0( E_lambda, P * sin( theta ) * cos( phi ), P * sin( theta ) * sin( phi ), P * cos( theta ) ); EvtVector4R q_V0( E_V, -P * sin( theta ) * cos( phi ), -P * sin( theta ) * sin( phi ), -P * cos( theta ) ); EvtVector4R q_lambda1( E_lambda, q_lambda0.get( 2 ), q_lambda0.get( 3 ), q_lambda0.get( 1 ) ); EvtVector4R q_V1( E_V, q_V0.get( 2 ), q_V0.get( 3 ), q_V0.get( 1 ) ); EvtVector4R q_lambda( - E_lambda, - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( px * ( q_lambda1.get( 1 ) ) ) - ( py * ( q_lambda1.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( py * ( q_lambda1.get( 1 ) ) ) + ( px * ( q_lambda1.get( 2 ) ) ) ) ), - ( q_lambda1.get( 3 ) ) ); - - EvtVector4R q_V( - E_V, - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( px * ( q_V1.get( 1 ) ) ) - ( py * ( q_V1.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( py * ( q_V1.get( 1 ) ) ) + ( px * ( q_V1.get( 2 ) ) ) ) ), - ( q_V1.get( 3 ) ) ); - - lambda->getP4(); - V->getP4(); - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " LambdaB px: " << px << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " LambdaB py: " << py << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " LambdaB pz: " << pz << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " LambdaB E: " << E << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 E: " << q_lambdab3.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 px: " << q_lambda0.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 py: " << q_lambda0.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 pz: " << q_lambda0.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 E: " << q_lambda0.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 px: " << q_lambda1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 py: " << q_lambda1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 pz: " << q_lambda1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 E: " << q_lambda1.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda px: " << q_lambda.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda py: " << q_lambda.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda pz: " << q_lambda.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda E: " << q_lambda0.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 px: " << q_V0.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 py: " << q_V0.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 pz: " << q_V0.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 E: " << q_V0.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 px: " << q_V1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 py: " << q_V1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 pz: " << q_V1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 E: " << q_V1.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V px: " << q_V.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V py: " << q_V.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V pz: " << q_V.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V E: " << q_V0.get( 3 ) << std::endl; - //set quadrivectors to particles + E_lambda, invPT * ( px * q_lambda1.get( 1 ) - py * q_lambda1.get( 2 ) ), + invPT * ( py * q_lambda1.get( 1 ) + px * q_lambda1.get( 2 ) ), + q_lambda1.get( 3 ) ); + + EvtVector4R q_V( E_V, invPT * ( px * q_V1.get( 1 ) - py * q_V1.get( 2 ) ), + invPT * ( py * q_V1.get( 1 ) + px * q_V1.get( 2 ) ), + q_V1.get( 3 ) ); + + // Set particle 4-vectors lambda->init( getDaugs()[0], q_lambda ); V->init( getDaugs()[1], q_V ); - //computate pdf - double pdf = 1 + A * B * cos( theta ) + - 2 * A * real( C * EvtComplex( cos( phi ), sin( phi ) ) ) * + // Find pdf (eq 11 in paper) + double pdf = 1.0 + A * B * cos( theta ) + + 2.0 * A * real( C * EvtComplex( cos( phi ), sin( phi ) ) ) * sin( theta ); - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " LambdaB decay pdf value : " << pdf << std::endl; //set probability setProb( pdf ); - return; + if ( verbose() ) { + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Angular angles : theta = " << theta << " ; phi = " << phi + << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << "E of lambdab: " << P_lambdab.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << "E of lambdab: " << E << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " LambdaB px: " << px << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " LambdaB py: " << py << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " LambdaB pz: " << pz << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " LambdaB E: " << E << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 E: " << q_lambdab3.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 px: " << q_lambda0.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 py: " << q_lambda0.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 pz: " << q_lambda0.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 E: " << q_lambda0.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 px: " << q_lambda1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 py: " << q_lambda1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 pz: " << q_lambda1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 E: " << q_lambda1.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda px: " << q_lambda.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda py: " << q_lambda.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda pz: " << q_lambda.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda E: " << q_lambda0.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 px: " << q_V0.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 py: " << q_V0.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 pz: " << q_V0.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 E: " << q_V0.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 px: " << q_V1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 py: " << q_V1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 pz: " << q_V1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 E: " << q_V1.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V px: " << q_V.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V py: " << q_V.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V pz: " << q_V.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V E: " << q_V0.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " LambdaB decay pdf value : " << pdf << std::endl; + } } //------------------------------------------------------------------------ // Method 'BreitWignerRelPDF' //------------------------------------------------------------------------ double EvtLambdaB2LambdaV::BreitWignerRelPDF( double m, double _m0, double _g0 ) { double a = ( _m0 * _g0 ) * ( _m0 * _g0 ); double b = ( m * m - _m0 * _m0 ) * ( m * m - _m0 * _m0 ); return a / ( b + a ); } //------------------------------------------------------------------------ // Method 'RhoOmegaMixingPDF' //------------------------------------------------------------------------ double EvtLambdaB2LambdaV::RhoOmegaMixingPDF( double m, double _mr, double _gr, double _mo, double _go ) { double a = m * m - _mr * _mr; double b = m * m - _mo * _mo; double c = _gr * _mr; double d = _go * _mo; double re_pi = -3500e-6; //GeV^2 double im_pi = -300e-6; //GeV^2 double va_pi = re_pi + im_pi; - //computate pdf value + //compute pdf value double f = 1 / ( a * a + c * c ) * ( 1 + ( va_pi * va_pi + 2 * b * re_pi + 2 * d * im_pi ) / ( b * b + d * d ) ); - //computate pdf max value + //compute pdf max value a = 0; b = _mr * _mr - _mo * _mo; double maxi = 1 / ( a * a + c * c ) * ( 1 + ( va_pi * va_pi + 2 * b * re_pi + 2 * d * im_pi ) / ( b * b + d * d ) ); return f / maxi; } //------------------------------------------------------------------------ // Method 'getVMass' //------------------------------------------------------------------------ double EvtLambdaB2LambdaV::getVMass( double MASS_LAMBDAB, double MASS_LAMBDA ) { //JPSI case if ( Vtype == VID::JPSI ) { return EvtPDL::getMass( EvtPDL::getId( "J/psi" ) ); } //RHO,OMEGA,MIXING case else { //parameters double MASS_RHO = EvtPDL::getMeanMass( EvtPDL::getId( "rho0" ) ); double MASS_OMEGA = EvtPDL::getMeanMass( EvtPDL::getId( "omega" ) ); double WIDTH_RHO = EvtPDL::getWidth( EvtPDL::getId( "rho0" ) ); double WIDTH_OMEGA = EvtPDL::getWidth( EvtPDL::getId( "omega" ) ); double MASS_PION = EvtPDL::getMeanMass( EvtPDL::getId( "pi-" ) ); double _max = MASS_LAMBDAB - MASS_LAMBDA; double _min = 2 * MASS_PION; double mass = 0; bool test = false; int ntimes = 10000; do { double y = EvtRandom::Flat( 0, 1 ); //generate mass mass = ( _max - _min ) * EvtRandom::Flat( 0, 1 ) + _min; //pdf calculate double f = 0; switch ( Vtype ) { case VID::RHO: f = BreitWignerRelPDF( mass, MASS_RHO, WIDTH_RHO ); break; case VID::OMEGA: f = BreitWignerRelPDF( mass, MASS_OMEGA, WIDTH_OMEGA ); break; case VID::RHO_OMEGA_MIXING: f = RhoOmegaMixingPDF( mass, MASS_RHO, WIDTH_RHO, MASS_OMEGA, WIDTH_OMEGA ); break; default: f = 1; break; } ntimes--; if ( y < f ) test = true; } while ( ntimes && !test ); //looping 10000 times if ( ntimes == 0 ) { EvtGenReport( EVTGEN_INFO, fname.c_str() ) << "Tried accept/reject:10000" << " times, and rejected all the times!" << std::endl; EvtGenReport( EVTGEN_INFO, fname.c_str() ) << "Is therefore accepting the last event!" << std::endl; } //return V particle mass return mass; } } //************************************************************************ //* * //* Class EvtLambda2PPiForLambdaB2LambdaV * //* * //************************************************************************ //------------------------------------------------------------------------ // Constructor //------------------------------------------------------------------------ EvtLambda2PPiForLambdaB2LambdaV::EvtLambda2PPiForLambdaB2LambdaV() { //set facility name fname = "EvtGen.EvtLambda2PPiForLambdaB2LambdaV"; } //------------------------------------------------------------------------ // Method 'getName' //------------------------------------------------------------------------ std::string EvtLambda2PPiForLambdaB2LambdaV::getName() { return "LAMBDA2PPIFORLAMBDAB2LAMBDAV"; } //------------------------------------------------------------------------ // Method 'clone' //------------------------------------------------------------------------ EvtDecayBase* EvtLambda2PPiForLambdaB2LambdaV::clone() { return new EvtLambda2PPiForLambdaB2LambdaV; } //------------------------------------------------------------------------ // Method 'initProbMax' //------------------------------------------------------------------------ void EvtLambda2PPiForLambdaB2LambdaV::initProbMax() { - //maximum (case where D is real) - double Max = 0; - if ( A == 0 ) - Max = 1; - else if ( C == 0 || real( D ) == 0 ) - Max = 1 + fabs( A * B ); - else if ( B == 0 ) - Max = 1 + EvtConst::pi / 2.0 * fabs( C * A * real( D ) ); - else { - double theta_max = atan( -EvtConst::pi / 2.0 * C * real( D ) / B ); - double max1 = 1 + fabs( A * B * cos( theta_max ) - - EvtConst::pi / 2.0 * C * A * real( D ) * - sin( theta_max ) ); - double max2 = 1 + fabs( A * B ); - if ( max1 > max2 ) - Max = max1; - else - Max = max2; + double Max = 1.0 + fabs( A * B ) + 2.0 * fabs( A * abs( D ) ); + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " PDF max value : " << Max << std::endl; } - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " PDF max value : " << Max << std::endl; setProbMax( Max ); } //------------------------------------------------------------------------ // Method 'init' //------------------------------------------------------------------------ void EvtLambda2PPiForLambdaB2LambdaV::init() { bool antiparticle = false; - //introduction - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " ***********************************************************" - << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " * Event Model Class : EvtLambda2PPiForLambdaB2LambdaV *" - << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " ***********************************************************" - << std::endl; + if ( verbose() ) { + //introduction + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " ***********************************************************" + << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " * Event Model Class : EvtLambda2PPiForLambdaB2LambdaV *" + << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " ***********************************************************" + << std::endl; + } //check the number of arguments checkNArg( 2 ); //check the number of daughters checkNDaug( 2 ); const EvtId Id_mother = getParentId(); const EvtId Id_daug1 = getDaug( 0 ); const EvtId Id_daug2 = getDaug( 1 ); //lambda identification if ( Id_mother == EvtPDL::getId( "Lambda0" ) ) { antiparticle = false; } else if ( Id_mother == EvtPDL::getId( "anti-Lambda0" ) ) { antiparticle = true; } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Mother is not a Lambda0 or an anti-Lambda0, but a " << EvtPDL::name( Id_mother ) << std::endl; abort(); } //proton identification if ( !( Id_daug1 == EvtPDL::getId( "p+" ) && !antiparticle ) && !( Id_daug1 == EvtPDL::getId( "anti-p-" ) && antiparticle ) ) { if ( !antiparticle ) { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter1 is not a p+, but a " << EvtPDL::name( Id_daug1 ) << std::endl; } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter1 is not an anti-p-, but a " << EvtPDL::name( Id_daug1 ) << std::endl; } abort(); } //pion identification if ( !( Id_daug2 == EvtPDL::getId( "pi-" ) && !antiparticle ) && !( Id_daug2 == EvtPDL::getId( "pi+" ) && antiparticle ) ) { if ( !antiparticle ) { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter2 is not a p-, but a " << EvtPDL::name( Id_daug1 ) << std::endl; } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter2 is not an p+, but a " << EvtPDL::name( Id_daug1 ) << std::endl; } abort(); } if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : Lambda0 -> p+ pi-" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : Anti-Lambda0 -> anti-p- pi+" << std::endl; //identification meson V if ( getArg( 1 ) == 1 ) { Vtype = VID::JPSI; if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : Lambda_b0 -> Lambda J/psi" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : anti-Lambda_b0 -> anti-Lambda J/psi" << std::endl; } else if ( getArg( 1 ) == 2 ) { Vtype = VID::RHO; if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : Lambda_b0 -> Lambda rho0" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : anti-Lambda_b0 -> anti-Lambda rho0" << std::endl; } else if ( getArg( 1 ) == 3 ) { Vtype = VID::OMEGA; if ( !antiparticle ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : Lambda_b0 -> Lambda omega" << std::endl; else EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : anti-Lambda_b0 -> anti-Lambda omega" << std::endl; } else if ( getArg( 1 ) == 4 ) { Vtype = VID::RHO_OMEGA_MIXING; } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Vtype " << getArg( 1 ) << " is unknown" << std::endl; if ( !antiparticle ) { EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : Lambda_b0 -> Lambda rho-omega-mixing" << std::endl; } else { EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " From : anti-Lambda_b0 -> anti-Lambda rho-omega-mixing" << std::endl; } abort(); } //constants A = 0.642; C = (double)getArg( 0 ); switch ( Vtype ) { case VID::JPSI: B = -0.167; D = EvtComplex( 0.25, 0.0 ); break; case VID::RHO: case VID::OMEGA: case VID::RHO_OMEGA_MIXING: B = -0.21; D = EvtComplex( 0.31, 0.0 ); break; default: B = 0; D = EvtComplex( 0, 0 ); break; } - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " Lambda decay parameters : " << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - proton asymmetry A = " << A << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - lambda polarisation B = " << B << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - lambdaB polarisation C = " << C << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - lambda density matrix rho+- D = " << D << std::endl; + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " Lambda decay parameters : " << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - proton asymmetry A = " << A << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - lambda polarisation B = " << B << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - lambdaB polarisation C = " << C << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - lambda density matrix rho+- D = " << D << std::endl; + } + + // Update max prob + initProbMax(); } //------------------------------------------------------------------------ // Method 'decay' //------------------------------------------------------------------------ void EvtLambda2PPiForLambdaB2LambdaV::decay( EvtParticle* lambda ) { lambda->makeDaughters( getNDaug(), getDaugs() ); //get proton and pion particles EvtParticle* proton = lambda->getDaug( 0 ); EvtParticle* pion = lambda->getDaug( 1 ); //get resonance masses // - LAMBDA -> mass given by EvtLambdaB2LambdaV class // - PROTON & PION -> nominal mass double MASS_LAMBDA = lambda->mass(); double MASS_PROTON = EvtPDL::getMeanMass( EvtPDL::getId( "p+" ) ); double MASS_PION = EvtPDL::getMeanMass( EvtPDL::getId( "pi-" ) ); //generate random angles - double phi = EvtRandom::Flat( 0, 2 * EvtConst::pi ); - double theta = acos( EvtRandom::Flat( -1, +1 ) ); - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " Angular angles : theta = " << theta << " ; phi = " << phi - << std::endl; + double phi = EvtRandom::Flat( 0.0, 2.0 * EvtConst::pi ); + double theta = acos( EvtRandom::Flat( -1.0, 1.0 ) ); - //computate resonance quadrivectors + // Find 4-vectors double E_proton = ( MASS_LAMBDA * MASS_LAMBDA + MASS_PROTON * MASS_PROTON - MASS_PION * MASS_PION ) / ( 2 * MASS_LAMBDA ); double E_pion = ( MASS_LAMBDA * MASS_LAMBDA + MASS_PION * MASS_PION - MASS_PROTON * MASS_PROTON ) / ( 2 * MASS_LAMBDA ); double P = sqrt( E_proton * E_proton - proton->mass() * proton->mass() ); EvtVector4R P_lambda = lambda->getP4(); EvtParticle* Mother_lambda = lambda->getParent(); EvtVector4R lambdab = Mother_lambda->getP4(); double E_lambda = P_lambda.get( 0 ); double px_M = lambdab.get( 1 ); double py_M = lambdab.get( 2 ); double pz_M = lambdab.get( 3 ); double E_M = lambdab.get( 0 ); - EvtVector4R q_lambdab2( - E_M, - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( px_M ) ) + ( py_M * ( py_M ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( -( ( py_M ) * ( px_M ) ) + ( px_M * ( py_M ) ) ) ), - ( pz_M ) ); + const double px_MSq = px_M * px_M; + const double py_MSq = py_M * py_M; + const double pT_M = sqrt( px_MSq + py_MSq ); + const double invPT_M = pT_M > 0.0 ? 1.0 / pT_M : 0.0; + + EvtVector4R q_lambdab2( E_M, pT_M, 0.0, pz_M ); EvtVector4R q_lambdab3( E_M, q_lambdab2.get( 3 ), q_lambdab2.get( 1 ), q_lambdab2.get( 2 ) ); - EvtVector4R q_lambda1( E_lambda, - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( P_lambda.get( 1 ) ) ) + - ( py_M * ( P_lambda.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( -( py_M * ( P_lambda.get( 1 ) ) ) + - ( px_M * ( P_lambda.get( 2 ) ) ) ) ), - P_lambda.get( 3 ) ); + EvtVector4R q_lambda1( + E_lambda, + invPT_M * ( px_M * P_lambda.get( 1 ) + py_M * P_lambda.get( 2 ) ), + invPT_M * ( -py_M * P_lambda.get( 1 ) + px_M * P_lambda.get( 2 ) ), + P_lambda.get( 3 ) ); EvtVector4R q_lambda2( E_lambda, q_lambda1.get( 3 ), q_lambda1.get( 1 ), q_lambda1.get( 2 ) ); - double px = q_lambda2.get( 1 ); - double py = q_lambda2.get( 2 ); - double pz = q_lambda2.get( 3 ); - - EvtVector4R q_lambda4( - q_lambda2.get( 0 ), - ( ( 1 / ( sqrt( pow( q_lambda2.get( 1 ), 2 ) + pow( q_lambda2.get( 2 ), 2 ) + - pow( q_lambda2.get( 3 ), 2 ) ) ) ) * - ( 1 / ( sqrt( pow( q_lambda2.get( 1 ), 2 ) + - pow( q_lambda2.get( 2 ), 2 ) ) ) ) * - ( ( q_lambda2.get( 1 ) ) * ( q_lambda2.get( 1 ) ) * - ( q_lambda2.get( 3 ) ) + - ( ( q_lambda2.get( 2 ) ) * ( q_lambda2.get( 2 ) ) * - ( q_lambda2.get( 3 ) ) ) - - ( ( q_lambda2.get( 3 ) ) * ( pow( q_lambda2.get( 1 ), 2 ) + - pow( q_lambda2.get( 2 ), 2 ) ) ) ) ), - ( ( ( ( q_lambda2.get( 2 ) ) * ( q_lambda2.get( 1 ) ) ) - - ( ( q_lambda2.get( 1 ) ) * ( q_lambda2.get( 2 ) ) ) ) / - ( sqrt( pow( q_lambda2.get( 1 ), 2 ) + pow( q_lambda2.get( 2 ), 2 ) ) ) ), - ( ( ( 1 / sqrt( pow( q_lambda2.get( 1 ), 2 ) + pow( q_lambda2.get( 2 ), 2 ) + - pow( q_lambda2.get( 3 ), 2 ) ) ) * - ( ( ( q_lambda2.get( 1 ) ) * ( q_lambda2.get( 1 ) ) ) + - ( ( q_lambda2.get( 2 ) ) * ( q_lambda2.get( 2 ) ) ) + - ( ( q_lambda2.get( 3 ) ) * ( q_lambda2.get( 3 ) ) ) ) ) ) ); + const double E = q_lambda2.get( 0 ); + const double px = q_lambda2.get( 1 ); + const double py = q_lambda2.get( 2 ); + const double pz = q_lambda2.get( 3 ); + const double pxSq = px * px; + const double pySq = py * py; + const double pzSq = pz * pz; + const double pTSq = pxSq + pySq; + const double p = sqrt( pTSq + pzSq ); + const double invP = p > 0.0 ? 1.0 / p : 0.0; + const double invPSq = invP * invP; + const double pT = sqrt( pTSq ); + + //EvtVector4R q_lambda4( E, 0.0, 0.0, p ); + EvtVector4R q_lambda4( E, pT, 0.0, pz ); EvtVector4R q_proton1( E_proton, P * sin( theta ) * cos( phi ), P * sin( theta ) * sin( phi ), P * cos( theta ) ); EvtVector4R q_pion1( E_pion, -P * sin( theta ) * cos( phi ), -P * sin( theta ) * sin( phi ), -P * cos( theta ) ); - EvtVector4R q_proton3( - E_proton, - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( q_proton1.get( 1 ) ) * ( px ) * ( pz ) - - ( ( q_proton1.get( 2 ) ) * ( py ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) + - ( ( ( q_proton1.get( 3 ) ) ) * - ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * ( px ) ) ) ), - ( ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( ( q_proton1.get( 1 ) ) ) * ( py ) * ( pz ) + - ( ( q_proton1.get( 2 ) ) * ( px ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) + - ( ( ( q_proton1.get( 3 ) ) ) * - ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * ( py ) ) ) ), - ( ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) * - ( ( -( q_proton1.get( 1 ) ) ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) + - ( ( q_proton1.get( 3 ) ) * ( pz ) ) ) ) ); + const double qx_proton1 = q_proton1.get( 1 ); + const double qy_proton1 = q_proton1.get( 2 ); + const double qz_proton1 = q_proton1.get( 3 ); + + EvtVector4R q_proton3( E_proton, + invPSq * ( qx_proton1 * px * pz - qy_proton1 * py * p + + qz_proton1 * pT * px ), + invPSq * ( qx_proton1 * py * pz + qy_proton1 * px * p + + qz_proton1 * pT * py ), + invP * ( -qx_proton1 * pT + qz_proton1 * pz ) ); + + const double qx_pion1 = q_pion1.get( 1 ); + const double qy_pion1 = q_pion1.get( 2 ); + const double qz_pion1 = q_pion1.get( 3 ); EvtVector4R q_pion3( E_pion, - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( q_pion1.get( 1 ) ) * ( px ) * ( pz ) - - ( ( q_pion1.get( 2 ) ) * ( py ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) + - ( ( ( q_pion1.get( 3 ) ) ) * - ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * ( px ) ) ) ), - ( ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( q_pion1.get( 1 ) ) * ( py ) * ( pz ) + - ( ( q_pion1.get( 2 ) ) * ( px ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) + - ( ( ( q_pion1.get( 3 ) ) ) * - ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * ( py ) ) ) ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) * - ( ( -( q_pion1.get( 1 ) ) ) * ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) + - ( ( q_pion1.get( 3 ) ) * ( pz ) ) ) ) ); - - EvtVector4R q_proton5( q_proton3.get( 0 ), ( q_proton3.get( 2 ) ), - ( q_proton3.get( 3 ) ), ( q_proton3.get( 1 ) ) ); - - EvtVector4R q_pion5( q_pion3.get( 0 ), ( q_pion3.get( 2 ) ), - ( q_pion3.get( 3 ) ), ( q_pion3.get( 1 ) ) ); - - EvtVector4R q_proton( q_proton5.get( 0 ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( q_proton5.get( 1 ) ) ) - - ( py_M * ( q_proton5.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( py_M * ( q_proton5.get( 1 ) ) ) + - ( px_M * ( q_proton5.get( 2 ) ) ) ) ), - ( q_proton5.get( 3 ) ) ); + invPSq * ( qx_pion1 * px * pz - qy_pion1 * py * p + qz_pion1 * pT * px ), + invPSq * ( qx_pion1 * py * pz + qy_pion1 * px * p + qz_pion1 * pT * py ), + invP * ( -qx_pion1 * pT + qz_pion1 * pz ) ); + + EvtVector4R q_proton5( q_proton3.get( 0 ), q_proton3.get( 2 ), + q_proton3.get( 3 ), q_proton3.get( 1 ) ); + + EvtVector4R q_pion5( q_pion3.get( 0 ), q_pion3.get( 2 ), q_pion3.get( 3 ), + q_pion3.get( 1 ) ); + + EvtVector4R q_proton( + q_proton5.get( 0 ), + invPT_M * ( px_M * q_proton5.get( 1 ) - py_M * q_proton5.get( 2 ) ), + invPT_M * ( py_M * q_proton5.get( 1 ) + px_M * q_proton5.get( 2 ) ), + q_proton5.get( 3 ) ); EvtVector4R q_pion( q_pion5.get( 0 ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( q_pion5.get( 1 ) ) ) - ( py_M * ( q_pion5.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( py_M * ( q_pion5.get( 1 ) ) ) + ( px_M * ( q_pion5.get( 2 ) ) ) ) ), - ( q_pion5.get( 3 ) ) ); - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab px: " << px_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab py: " << py_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab pz: " << pz_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab E: " << E_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 px: " << q_lambdab2.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 py: " << q_lambdab2.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 pz: " << q_lambdab2.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 E: " << q_lambdab2.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 px: " << q_lambdab3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 py: " << q_lambdab3.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 pz: " << q_lambdab3.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 E: " << q_lambdab3.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 px: " << P_lambda.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 py: " << P_lambda.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 pz: " << P_lambda.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 0 E: " << P_lambda.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 px: " << q_lambda1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 py: " << q_lambda1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 pz: " << q_lambda1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 1 E: " << q_lambda1.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 2 px: " << q_lambda2.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 2 py: " << q_lambda2.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 2 pz: " << q_lambda2.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda 2 E: " << q_lambda2.get( 0 ) << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda px: " << px << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda py: " << py << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambda pz: " << pz << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 1 px: " << q_pion1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 1 py: " << q_pion1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 1 pz: " << q_pion1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 1 E: " << q_pion1.get( 0 ) << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 3 px: " << q_pion3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 3 px: " << q_pion3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 3 py: " << q_pion3.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 3 pz: " << q_pion3.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 3 E: " << q_pion3.get( 0 ) << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 5 px: " << q_pion5.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 5 py: " << q_pion5.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 5 pz: " << q_pion5.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion 5 E: " << q_pion5.get( 0 ) << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 1 px: " << q_proton1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 1 py: " << q_proton1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 1 pz: " << q_proton1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 1 E: " << q_proton1.get( 0 ) << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 3 px: " << q_proton3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 3 py: " << q_proton3.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 3 pz: " << q_proton3.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 3 E: " << q_proton3.get( 0 ) << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 5 px: " << q_proton5.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 5 py: " << q_proton5.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 5 pz: " << q_proton5.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton 5 E: " << q_proton5.get( 0 ) << std::endl; - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton px: " << q_proton.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " proton py: " << q_proton.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << "proton pz: " << q_proton.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion px: " << q_pion.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion py: " << q_pion.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " pion pz: " << q_pion.get( 3 ) << std::endl; - - ; - - ///////////*******NEW********////////////////////// - - //set quadrivectors to particles + invPT_M * ( px_M * q_pion5.get( 1 ) - py_M * q_pion5.get( 2 ) ), + invPT_M * ( py_M * q_pion5.get( 1 ) + px_M * q_pion5.get( 2 ) ), + q_pion5.get( 3 ) ); + + // Set particle 4 vectors proton->init( getDaugs()[0], q_proton ); pion->init( getDaugs()[1], q_pion ); - //computate pdf - //double pdf = 1 + A*B*cos(theta) - EvtConst::pi/2.0*C*A*real(D*EvtComplex(cos(phi),sin(phi)))*sin(theta); - double pdf = 1 + A * B * cos( theta ) + - 2 * A * real( D * EvtComplex( cos( phi ), sin( phi ) ) ) * + //compute pdf + double pdf = 1.0 + A * B * cos( theta ) + + 2.0 * A * real( D * EvtComplex( cos( phi ), sin( phi ) ) ) * sin( theta ); - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " Lambda decay pdf value : " << pdf << std::endl; //set probability setProb( pdf ); - return; + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " Angular angles : theta = " << theta << " ; phi = " << phi + << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab px: " << px_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab py: " << py_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab pz: " << pz_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab E: " << E_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 px: " << q_lambdab2.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 py: " << q_lambdab2.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 pz: " << q_lambdab2.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 E: " << q_lambdab2.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 px: " << q_lambdab3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 py: " << q_lambdab3.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 pz: " << q_lambdab3.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 E: " << q_lambdab3.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 px: " << P_lambda.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 py: " << P_lambda.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 pz: " << P_lambda.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 0 E: " << P_lambda.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 px: " << q_lambda1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 py: " << q_lambda1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 pz: " << q_lambda1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 1 E: " << q_lambda1.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 2 px: " << q_lambda2.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 2 py: " << q_lambda2.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 2 pz: " << q_lambda2.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda 2 E: " << q_lambda2.get( 0 ) << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda px: " << px << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda py: " << py << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambda pz: " << pz << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 1 px: " << q_pion1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 1 py: " << q_pion1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 1 pz: " << q_pion1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 1 E: " << q_pion1.get( 0 ) << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 3 px: " << q_pion3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 3 px: " << q_pion3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 3 py: " << q_pion3.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 3 pz: " << q_pion3.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 3 E: " << q_pion3.get( 0 ) << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 5 px: " << q_pion5.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 5 py: " << q_pion5.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 5 pz: " << q_pion5.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion 5 E: " << q_pion5.get( 0 ) << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 1 px: " << q_proton1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 1 py: " << q_proton1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 1 pz: " << q_proton1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 1 E: " << q_proton1.get( 0 ) << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 3 px: " << q_proton3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 3 py: " << q_proton3.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 3 pz: " << q_proton3.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 3 E: " << q_proton3.get( 0 ) << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 5 px: " << q_proton5.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 5 py: " << q_proton5.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 5 pz: " << q_proton5.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton 5 E: " << q_proton5.get( 0 ) << std::endl; + + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton px: " << q_proton.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " proton py: " << q_proton.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << "proton pz: " << q_proton.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion px: " << q_pion.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion py: " << q_pion.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " pion pz: " << q_pion.get( 3 ) << std::endl; + + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " Lambda decay pdf value : " << pdf << std::endl; + } } //************************************************************************ //* * -//* Class EvtLambda2PPiForLambdaB2LambdaV * +//* Class EvtV2VpVmForLambdaB2LambdaV * //* * //************************************************************************ //------------------------------------------------------------------------ // Constructor //------------------------------------------------------------------------ EvtV2VpVmForLambdaB2LambdaV::EvtV2VpVmForLambdaB2LambdaV() { //set facility name fname = "EvtGen.EvtV2VpVmForLambdaB2LambdaV"; } //------------------------------------------------------------------------ // Method 'getName' //------------------------------------------------------------------------ std::string EvtV2VpVmForLambdaB2LambdaV::getName() { return "V2VPVMFORLAMBDAB2LAMBDAV"; } //------------------------------------------------------------------------ // Method 'clone' //------------------------------------------------------------------------ EvtDecayBase* EvtV2VpVmForLambdaB2LambdaV::clone() { return new EvtV2VpVmForLambdaB2LambdaV; } //------------------------------------------------------------------------ // Method 'initProbMax' //------------------------------------------------------------------------ void EvtV2VpVmForLambdaB2LambdaV::initProbMax() { //maximum - double Max = 0; + double Max = 0.0; if ( Vtype == VID::JPSI ) { - if ( ( 1 - 3 * A ) > 0 ) - Max = 2 * ( 1 - A ); + if ( ( 1.0 - 3.0 * A ) > 0.0 ) + Max = 2.0 * ( 1.0 - A ); else - Max = 1 + A; + Max = 1.0 + A; } else { - if ( ( 3 * A - 1 ) >= 0 ) - Max = 2 * A; + if ( ( 3.0 * A - 1.0 ) >= 0.0 ) + Max = 2.0 * A; else - Max = 1 - A; + Max = 1.0 - A; } - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " PDF max value : " << Max << std::endl; + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " PDF max value : " << Max << std::endl; + } setProbMax( Max ); } //------------------------------------------------------------------------ // Method 'init' //------------------------------------------------------------------------ void EvtV2VpVmForLambdaB2LambdaV::init() { - //introduction - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " ***********************************************************" - << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " * Event Model Class : EvtV2VpVmForLambdaB2LambdaV *" - << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " ***********************************************************" - << std::endl; + if ( verbose() ) { + //introduction + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " ***********************************************************" + << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " * Event Model Class : EvtV2VpVmForLambdaB2LambdaV *" + << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " ***********************************************************" + << std::endl; + } //check the number of arguments checkNArg( 2 ); //check the number of daughters checkNDaug( 2 ); const EvtId Id_mother = getParentId(); const EvtId Id_daug1 = getDaug( 0 ); const EvtId Id_daug2 = getDaug( 1 ); //identification meson V if ( getArg( 1 ) == 1 ) Vtype = VID::JPSI; else if ( getArg( 1 ) == 2 ) Vtype = VID::RHO; else if ( getArg( 1 ) == 3 ) Vtype = VID::OMEGA; else if ( getArg( 1 ) == 4 ) Vtype = VID::RHO_OMEGA_MIXING; else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Vtype " << getArg( 1 ) << " is unknown" << std::endl; abort(); } //vector meson V if ( Id_mother == EvtPDL::getId( "J/psi" ) && Vtype == VID::JPSI ) { } else if ( Id_mother == EvtPDL::getId( "omega" ) && Vtype == VID::OMEGA ) { } else if ( Id_mother == EvtPDL::getId( "rho0" ) && Vtype == VID::RHO ) { } else if ( ( Id_mother == EvtPDL::getId( "rho0" ) || Id_mother == EvtPDL::getId( "omega" ) ) && Vtype == VID::RHO_OMEGA_MIXING ) { } else { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Mother is not a J/psi, phi or rho0 but a " << EvtPDL::name( Id_mother ) << std::endl; abort(); } //daughters for each V possibility switch ( Vtype ) { case VID::JPSI: if ( Id_daug1 != EvtPDL::getId( "mu+" ) ) { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter1 is not a mu+, but a " << EvtPDL::name( Id_daug1 ) << std::endl; abort(); } if ( Id_daug2 != EvtPDL::getId( "mu-" ) ) { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter2 is not a mu-, but a " << EvtPDL::name( Id_daug2 ) << std::endl; abort(); } EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : J/psi -> mu+ mu-" << std::endl; break; case VID::RHO: case VID::OMEGA: case VID::RHO_OMEGA_MIXING: if ( Id_daug1 != EvtPDL::getId( "pi+" ) ) { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter1 is not a pi+, but a " << EvtPDL::name( Id_daug1 ) << std::endl; abort(); } if ( Id_daug2 != EvtPDL::getId( "pi-" ) ) { EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << " Daughter2 is not a pi-, but a " << EvtPDL::name( Id_daug2 ) << std::endl; abort(); } if ( Vtype == VID::RHO ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : rho0 -> pi+ pi-" << std::endl; if ( Vtype == VID::OMEGA ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : omega -> pi+ pi-" << std::endl; if ( Vtype == VID::RHO_OMEGA_MIXING ) EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) << " Decay mode successfully initialized : rho-omega mixing -> pi+ pi-" << std::endl; break; default: EvtGenReport( EVTGEN_ERROR, fname.c_str() ) << "No decay mode chosen ! " << std::endl; abort(); break; } //fix dynamics parameters switch ( Vtype ) { case VID::JPSI: A = 0.66; break; case VID::RHO: case VID::OMEGA: case VID::RHO_OMEGA_MIXING: A = 0.79; break; default: A = 0; break; } - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " V decay parameters : " << std::endl; - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " - V density matrix rho00 A = " << A << std::endl; + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " V decay parameters : " << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " - V density matrix rho00 A = " << A << std::endl; + } } //------------------------------------------------------------------------ // Method 'decay' //------------------------------------------------------------------------ void EvtV2VpVmForLambdaB2LambdaV::decay( EvtParticle* V ) { V->makeDaughters( getNDaug(), getDaugs() ); //get Vp and Vm particles EvtParticle* Vp = V->getDaug( 0 ); EvtParticle* Vm = V->getDaug( 1 ); //get resonance masses // - V -> mass given by EvtLambdaB2LambdaV class // - Vp & Vm -> nominal mass double MASS_V = V->mass(); double MASS_VM = 0; switch ( Vtype ) { case VID::JPSI: MASS_VM = EvtPDL::getMeanMass( EvtPDL::getId( "mu-" ) ); break; case VID::RHO: case VID::OMEGA: case VID::RHO_OMEGA_MIXING: MASS_VM = EvtPDL::getMeanMass( EvtPDL::getId( "pi-" ) ); break; default: MASS_VM = 0; break; } double MASS_VP = MASS_VM; //generate random angles double phi = EvtRandom::Flat( 0, 2 * EvtConst::pi ); double theta = acos( EvtRandom::Flat( -1, +1 ) ); - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " Angular angles : theta = " << theta << " ; phi = " << phi - << std::endl; - //computate resonance quadrivectors + // Get resonance 4-vectors double E_Vp = ( MASS_V * MASS_V + MASS_VP * MASS_VP - MASS_VM * MASS_VM ) / ( 2 * MASS_V ); double E_Vm = ( MASS_V * MASS_V + MASS_VM * MASS_VM - MASS_VP * MASS_VP ) / ( 2 * MASS_V ); double P = sqrt( E_Vp * E_Vp - Vp->mass() * Vp->mass() ); EvtVector4R P_V = V->getP4(); EvtParticle* Mother_V = V->getParent(); EvtVector4R lambdab = Mother_V->getP4(); - double E_V = ( P_V.get( 0 ) ); - double px_M = lambdab.get( 1 ); - double py_M = lambdab.get( 2 ); - double pz_M = lambdab.get( 3 ); - double E_M = lambdab.get( 0 ); + const double E_V = ( P_V.get( 0 ) ); + const double px_M = lambdab.get( 1 ); + const double py_M = lambdab.get( 2 ); + const double pz_M = lambdab.get( 3 ); + const double E_M = lambdab.get( 0 ); + const double px_MSq = px_M * px_M; + const double py_MSq = py_M * py_M; + const double pT_MSq = px_MSq + py_MSq; + const double pT_M = sqrt( pT_MSq ); + const double invPT_M = pT_M > 0.0 ? 1.0 / pT_M : 0.0; - EvtVector4R q_lambdab2( - E_M, - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( px_M ) ) + ( py_M * ( py_M ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( -( ( py_M ) * ( px_M ) ) + ( px_M * ( py_M ) ) ) ), - ( pz_M ) ); + EvtVector4R q_lambdab2( E_M, pT_M, 0.0, pz_M ); EvtVector4R q_lambdab3( E_M, q_lambdab2.get( 3 ), q_lambdab2.get( 1 ), q_lambdab2.get( 2 ) ); - EvtVector4R q_V1( - E_V, - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( P_V.get( 1 ) ) ) + ( py_M * ( P_V.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( -( py_M * ( P_V.get( 1 ) ) ) + ( px_M * ( P_V.get( 2 ) ) ) ) ), - P_V.get( 3 ) ); + EvtVector4R q_V1( E_V, + invPT_M * ( px_M * P_V.get( 1 ) + py_M * P_V.get( 2 ) ), + invPT_M * ( -py_M * P_V.get( 1 ) + px_M * P_V.get( 2 ) ), + P_V.get( 3 ) ); EvtVector4R q_V2( E_V, q_V1.get( 3 ), q_V1.get( 1 ), q_V1.get( 2 ) ); - double px = -( q_V2.get( 1 ) ); - double py = -( q_V2.get( 2 ) ); - double pz = -( q_V2.get( 3 ) ); - - EvtVector4R q_V4( - q_V2.get( 0 ), - ( ( 1 / ( sqrt( pow( q_V2.get( 1 ), 2 ) + pow( q_V2.get( 2 ), 2 ) + - pow( q_V2.get( 3 ), 2 ) ) ) ) * - ( 1 / ( sqrt( pow( q_V2.get( 1 ), 2 ) + pow( q_V2.get( 2 ), 2 ) ) ) ) * - ( ( q_V2.get( 1 ) ) * ( q_V2.get( 1 ) ) * ( q_V2.get( 3 ) ) + - ( ( q_V2.get( 2 ) ) * ( q_V2.get( 2 ) ) * ( q_V2.get( 3 ) ) ) - - ( ( q_V2.get( 3 ) ) * - ( pow( q_V2.get( 1 ), 2 ) + pow( q_V2.get( 2 ), 2 ) ) ) ) ), - ( ( ( ( q_V2.get( 2 ) ) * ( q_V2.get( 1 ) ) ) - - ( ( q_V2.get( 1 ) ) * ( q_V2.get( 2 ) ) ) ) / - ( sqrt( pow( q_V2.get( 1 ), 2 ) + pow( q_V2.get( 2 ), 2 ) ) ) ), - ( ( ( 1 / sqrt( pow( q_V2.get( 1 ), 2 ) + pow( q_V2.get( 2 ), 2 ) + - pow( q_V2.get( 3 ), 2 ) ) ) * - ( ( ( q_V2.get( 1 ) ) * ( q_V2.get( 1 ) ) ) + - ( ( q_V2.get( 2 ) ) * ( q_V2.get( 2 ) ) ) + - ( ( q_V2.get( 3 ) ) * ( q_V2.get( 3 ) ) ) ) ) ) ); + const double px = -q_V2.get( 1 ); + const double py = -q_V2.get( 2 ); + const double pz = -q_V2.get( 3 ); + const double pxSq = px * px; + const double pySq = py * py; + const double pzSq = pz * pz; + const double pTSq = pxSq + pySq; + const double pSq = pTSq + pzSq; + const double p = sqrt( pSq ); + const double invP = p > 0.0 ? 1.0 / p : 0.0; + const double pT = sqrt( pTSq ); + const double invPT = pT > 0.0 ? 1.0 / pT : 0.0; + + EvtVector4R q_V4( q_V2.get( 0 ), 0.0, pT, p ); EvtVector4R q_Vp1( E_Vp, P * sin( theta ) * cos( phi ), P * sin( theta ) * sin( phi ), P * cos( theta ) ); EvtVector4R q_Vm1( E_Vm, -P * sin( theta ) * cos( phi ), -P * sin( theta ) * sin( phi ), -P * cos( theta ) ); - EvtVector4R q_Vp3( - q_Vp1.get( 0 ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( q_Vp1.get( 1 ) ) * ( px ) * ( pz ) + - ( ( q_Vp1.get( 2 ) ) * ( py ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) - - ( ( ( q_Vp1.get( 3 ) ) ) * ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * - ( px ) ) ) ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( ( q_Vp1.get( 1 ) ) ) * ( py ) * ( pz ) - - ( ( q_Vp1.get( 2 ) ) * ( px ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) - - ( ( ( q_Vp1.get( 3 ) ) ) * ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * - ( py ) ) ) ), - ( ( -( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) * - ( ( q_Vp1.get( 1 ) ) * ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) + - ( ( q_Vp1.get( 3 ) ) * ( pz ) ) ) ) ); - - EvtVector4R q_Vm3( - q_Vm1.get( 0 ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( q_Vm1.get( 1 ) ) * ( px ) * ( pz ) + - ( ( q_Vm1.get( 2 ) ) * ( py ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) - - ( ( ( q_Vm1.get( 3 ) ) ) * ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * - ( px ) ) ) ), - ( ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) * - ( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) * - ( ( ( q_Vm1.get( 1 ) ) ) * ( py ) * ( pz ) - - ( ( q_Vm1.get( 2 ) ) * ( px ) * - ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) - - ( ( ( q_Vm1.get( 3 ) ) ) * ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) * - ( py ) ) ) ), - ( ( -( 1 / ( sqrt( pow( px, 2 ) + pow( py, 2 ) + pow( pz, 2 ) ) ) ) ) * - ( ( q_Vm1.get( 1 ) ) * ( ( sqrt( pow( px, 2 ) + pow( py, 2 ) ) ) ) + - ( ( q_Vm1.get( 3 ) ) * ( pz ) ) ) ) ); - - EvtVector4R q_Vp5( q_Vp3.get( 0 ), ( q_Vp3.get( 2 ) ), ( q_Vp3.get( 3 ) ), - ( q_Vp3.get( 1 ) ) ); - - EvtVector4R q_Vm5( q_Vm3.get( 0 ), ( q_Vm3.get( 2 ) ), ( q_Vm3.get( 3 ) ), - ( q_Vm3.get( 1 ) ) ); - - EvtVector4R q_Vp( - q_Vp5.get( 0 ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( q_Vp5.get( 1 ) ) ) - ( py_M * ( q_Vp5.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( py_M * ( q_Vp5.get( 1 ) ) ) + ( px_M * ( q_Vp5.get( 2 ) ) ) ) ), - ( q_Vp5.get( 3 ) ) ); - - EvtVector4R q_Vm( - q_Vm5.get( 0 ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( px_M * ( q_Vm5.get( 1 ) ) ) - ( py_M * ( q_Vm5.get( 2 ) ) ) ) ), - ( ( 1 / ( sqrt( pow( px_M, 2 ) + pow( py_M, 2 ) ) ) ) * - ( ( py_M * ( q_Vm5.get( 1 ) ) ) + ( px_M * ( q_Vm5.get( 2 ) ) ) ) ), - ( q_Vm5.get( 3 ) ) ); - - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab px: " << px_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab py: " << py_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab pz: " << pz_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab E: " << E_M << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 px: " << q_lambdab2.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 py: " << q_lambdab2.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 pz: " << q_lambdab2.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab2 E: " << q_lambdab2.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 px: " << q_lambdab3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 py: " << q_lambdab3.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 pz: " << q_lambdab3.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Lambdab3 E: " << q_lambdab3.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 px: " << P_V.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 py: " << P_V.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 pz: " << P_V.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 0 E: " << P_V.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 px: " << q_V1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 py: " << q_V1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 pz: " << q_V1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 1 E: " << q_V1.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 2 px: " << q_V2.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 2 py: " << q_V2.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 2 pz: " << q_V2.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " V 2 E: " << q_V2.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) << " V px: " << px << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) << " V py: " << py << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) << " V pz: " << pz << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 1 px: " << q_Vm1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 1 py: " << q_Vm1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 1 pz: " << q_Vm1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 1 E: " << q_Vm1.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 3 px: " << q_Vm3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 3 px: " << q_Vm3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 3 py: " << q_Vm3.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 3 pz: " << q_Vm3.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 3 E: " << q_Vm3.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 5 px: " << q_Vm5.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 5 py: " << q_Vm5.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 5 pz: " << q_Vm5.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm 5 E: " << q_Vm5.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 1 px: " << q_Vp1.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 1 py: " << q_Vp1.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 1 pz: " << q_Vp1.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 1 E: " << q_Vp1.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 3 px: " << q_Vp3.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 3 py: " << q_Vp3.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 3 pz: " << q_Vp3.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 3 E: " << q_Vp3.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 5 px: " << q_Vp5.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 5 py: " << q_Vp5.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 5 pz: " << q_Vp5.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp 5 E: " << q_Vp5.get( 0 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp px: " << q_Vp.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vp py: " << q_Vp.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << "Vp pz: " << q_Vp.get( 3 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm px: " << q_Vm.get( 1 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm py: " << q_Vm.get( 2 ) << std::endl; - EvtGenReport( EVTGEN_INFO, fname.c_str() ) - << " Vm pz: " << q_Vm.get( 3 ) << std::endl; - - //set quadrivectors to particles + EvtVector4R q_Vp3( q_Vp1.get( 0 ), + invP * invPT * + ( q_Vp1.get( 1 ) * px * pz + q_Vp1.get( 2 ) * py * p - + q_Vp1.get( 3 ) * pT * px ), + invP * invPT * + ( q_Vp1.get( 1 ) * py * pz - q_Vp1.get( 2 ) * px * p - + q_Vp1.get( 3 ) * pT * py ), + -invP * ( q_Vp1.get( 1 ) * pT + q_Vp1.get( 3 ) * pz ) ); + + EvtVector4R q_Vm3( q_Vm1.get( 0 ), + invP * invPT * + ( q_Vm1.get( 1 ) * px * pz + q_Vm1.get( 2 ) * py * p - + q_Vm1.get( 3 ) * pT * px ), + invP * invPT * + ( q_Vm1.get( 1 ) * py * pz - q_Vm1.get( 2 ) * px * p - + q_Vm1.get( 3 ) * pT * py ), + -invP * ( q_Vm1.get( 1 ) * pT + q_Vm1.get( 3 ) * pz ) ); + + EvtVector4R q_Vp5( q_Vp3.get( 0 ), q_Vp3.get( 2 ), q_Vp3.get( 3 ), + q_Vp3.get( 1 ) ); + + EvtVector4R q_Vm5( q_Vm3.get( 0 ), q_Vm3.get( 2 ), q_Vm3.get( 3 ), + q_Vm3.get( 1 ) ); + + EvtVector4R q_Vp( q_Vp5.get( 0 ), + invPT_M * ( px_M * q_Vp5.get( 1 ) - py_M * q_Vp5.get( 2 ) ), + invPT_M * ( py_M * q_Vp5.get( 1 ) + px_M * q_Vp5.get( 2 ) ), + q_Vp5.get( 3 ) ); + + EvtVector4R q_Vm( q_Vm5.get( 0 ), + invPT_M * ( px_M * q_Vm5.get( 1 ) - py_M * q_Vm5.get( 2 ) ), + invPT_M * ( py_M * q_Vm5.get( 1 ) + px_M * q_Vm5.get( 2 ) ), + q_Vm5.get( 3 ) ); + + // Set particle 4-momenta Vp->init( getDaugs()[0], q_Vp ); Vm->init( getDaugs()[1], q_Vm ); - //computate pdf - double pdf = 0; + //compute pdf + double pdf = 0.0; if ( Vtype == VID::JPSI ) { //leptonic case - pdf = ( 1 - 3 * A ) * cos( theta ) * cos( theta ) + ( 1 + A ); + pdf = ( 1.0 - 3.0 * A ) * cos( theta ) * cos( theta ) + ( 1.0 + A ); } else { //hadronic case - pdf = ( 3 * A - 1 ) * cos( theta ) * cos( theta ) + ( 1 - A ); + pdf = ( 3.0 * A - 1.0 ) * cos( theta ) * cos( theta ) + ( 1.0 - A ); } - EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) - << " V decay pdf value : " << pdf << std::endl; //set probability setProb( pdf ); - return; + + if ( verbose() ) { + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " Angular angles : theta = " << theta << " ; phi = " << phi + << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab px: " << px_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab py: " << py_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab pz: " << pz_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab E: " << E_M << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 px: " << q_lambdab2.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 py: " << q_lambdab2.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 pz: " << q_lambdab2.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab2 E: " << q_lambdab2.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 px: " << q_lambdab3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 py: " << q_lambdab3.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 pz: " << q_lambdab3.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Lambdab3 E: " << q_lambdab3.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 px: " << P_V.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 py: " << P_V.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 pz: " << P_V.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 0 E: " << P_V.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 px: " << q_V1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 py: " << q_V1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 pz: " << q_V1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 1 E: " << q_V1.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 2 px: " << q_V2.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 2 py: " << q_V2.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 2 pz: " << q_V2.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V 2 E: " << q_V2.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V px: " << px << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V py: " << py << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " V pz: " << pz << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 1 px: " << q_Vm1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 1 py: " << q_Vm1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 1 pz: " << q_Vm1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 1 E: " << q_Vm1.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 3 px: " << q_Vm3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 3 px: " << q_Vm3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 3 py: " << q_Vm3.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 3 pz: " << q_Vm3.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 3 E: " << q_Vm3.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 5 px: " << q_Vm5.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 5 py: " << q_Vm5.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 5 pz: " << q_Vm5.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm 5 E: " << q_Vm5.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 1 px: " << q_Vp1.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 1 py: " << q_Vp1.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 1 pz: " << q_Vp1.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 1 E: " << q_Vp1.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 3 px: " << q_Vp3.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 3 py: " << q_Vp3.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 3 pz: " << q_Vp3.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 3 E: " << q_Vp3.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 5 px: " << q_Vp5.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 5 py: " << q_Vp5.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 5 pz: " << q_Vp5.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp 5 E: " << q_Vp5.get( 0 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp px: " << q_Vp.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vp py: " << q_Vp.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << "Vp pz: " << q_Vp.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm px: " << q_Vm.get( 1 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm py: " << q_Vm.get( 2 ) << std::endl; + EvtGenReport( EVTGEN_INFO, fname.c_str() ) + << " Vm pz: " << q_Vm.get( 3 ) << std::endl; + EvtGenReport( EVTGEN_DEBUG, fname.c_str() ) + << " V decay pdf value : " << pdf << std::endl; + } } diff --git a/src/EvtGenModels/EvtLb2Lll.cpp b/src/EvtGenModels/EvtLb2Lll.cpp index 5c4a2c7..058ba4c 100644 --- a/src/EvtGenModels/EvtLb2Lll.cpp +++ b/src/EvtGenModels/EvtLb2Lll.cpp @@ -1,903 +1,909 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtLb2Lll.hh" #include "EvtGenBase/EvtComplex.hh" #include "EvtGenBase/EvtDiracParticle.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtGammaMatrix.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include "EvtGenBase/EvtVector4R.hh" #include #include EvtDecayBase* EvtLb2Lll::clone() { return new EvtLb2Lll; } std::string EvtLb2Lll::getName() { return "Lb2Lll"; } void EvtLb2Lll::init() { if ( getNArg() > 8 ) { // Decay parameters EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll generator expected max. 8 arguments but found: " << getNArg() << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 1. Lambda_b0 polarization - zero is default" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 2. Model type - \"SM\" for Standard Model is default" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 3. Form-Factors - \"HQET\" is used by default" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 4. How to set polarization - \"ModifiedSpinors\" is default" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 5. Include long distance (LD) effects - \"SD\" (no) is default" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 6. NonFactorizable contribution (omega) to b->sg decay at q2=0 " << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 7. Note on every x-th decay" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " 8. Maximum probability - automatic by default" << std::endl; ::abort(); } if ( getNDaug() != 3 ) { // Check that there are 3 daughters only EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll generator expected 3 daughters but found: " << getNDaug() << std::endl; ::abort(); } EvtId LbID = EvtPDL::getId( std::string( "Lambda_b0" ) ); EvtId aLbID = EvtPDL::getId( std::string( "anti-Lambda_b0" ) ); EvtId eID = EvtPDL::getId( std::string( "e-" ) ); EvtId aeID = EvtPDL::getId( std::string( "e+" ) ); EvtId muID = EvtPDL::getId( std::string( "mu-" ) ); EvtId amuID = EvtPDL::getId( std::string( "mu+" ) ); EvtId tauID = EvtPDL::getId( std::string( "tau-" ) ); EvtId atauID = EvtPDL::getId( std::string( "tau+" ) ); // TODO: better check based on spin and falvour is needed to allow usage of aliases ! if ( getParentId() == LbID ) { // Check daughters of Lambda_b0 EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found Lambda_b0" << std::endl; //if(EvtPDL::name(getDaug(0))!="Lambda0"){ // EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtLb2Lll generator expected Lambda0 daughter but found: " << EvtPDL::name(getDaug(0)) << std::endl; // ::abort(); //} if ( getDaug( 1 ) == eID && getDaug( 2 ) == aeID ) { m_decayName = "Lambda_b0 -> Lambda0 e- e+"; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found decay: Lambda_b0 -> Lambda0 e- e+" << std::endl; } else if ( getDaug( 1 ) == muID && getDaug( 2 ) == amuID ) { m_decayName = "Lambda_b0 -> Lambda0 mu- mu+"; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found decay: Lambda_b0 -> Lambda0 mu- mu+" << std::endl; } else if ( getDaug( 1 ) == tauID && getDaug( 2 ) == atauID ) { m_decayName = "Lambda_b0 -> Lambda0 tau- tau+"; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found decay: Lambda_b0 -> Lambda0 tau- tau+" << std::endl; } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll generator expected lepton pair daughters but found: " << EvtPDL::name( getDaug( 1 ) ) << " " << EvtPDL::name( getDaug( 2 ) ) << std::endl; ::abort(); } //TODO: The model is known not to work correctly for anti-Lambda_b0 (A_FB does not change its sign) } else if ( getParentId() == aLbID ) { // Check daughters of anti-Lambda_b0 EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found anti-Lambda_b0" << std::endl; //if(EvtPDL::name(getDaug(0))!="anti-Lambda0"){ // EvtGenReport(EVTGEN_ERROR,"EvtGen") << " ERROR: EvtLb2Lll generator expected anti-Lambda0 daughter but found: " << EvtPDL::name(getDaug(0)) << std::endl; // ::abort(); //} if ( getDaug( 1 ) == aeID && getDaug( 2 ) == eID ) { m_decayName = "anti-Lambda_b0 -> anti-Lambda0 e+ e-"; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found decay: anti-Lambda_b0 -> anti-Lambda0 e+ e-" << std::endl; } else if ( getDaug( 1 ) == amuID && getDaug( 2 ) == muID ) { m_decayName = "anti-Lambda_b0 -> anti-Lambda0 mu+ mu-"; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found decay: anti-Lambda_b0 -> anti-Lambda0 mu+ mu-" << std::endl; } else if ( getDaug( 1 ) == atauID && getDaug( 2 ) == tauID ) { m_decayName = "anti-Lambda_b0 -> anti-Lambda0 tau+ tau-"; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll generator found decay: anti-Lambda_b0 -> anti-Lambda0 tau+ tau-" << std::endl; } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll generator expected lepton pair daughters but found: " << EvtPDL::name( getDaug( 1 ) ) << " " << EvtPDL::name( getDaug( 2 ) ) << std::endl; ::abort(); } } else { // This model is not intended for decay of anything else than (anti-)Lambda_b0 EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll generator expected (anti-)Lambda_b0 parent but found: " << EvtPDL::name( getParentId() ) << std::endl; ::abort(); } // Read and check all parameters if ( getNArg() > 0 ) { if ( getArg( 0 ) > 1. || getArg( 0 ) < -1. ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll expects polarization to be in interval <-1,1>, not " << getArg( 0 ) << std::endl; ::abort(); } m_polarizationLambdab0 = getArg( 0 ); } else { m_polarizationLambdab0 = 0; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll set Lambda_b0 polarization to " << m_polarizationLambdab0 << std::endl; if ( getNArg() > 1 ) { if ( getArgStr( 1 ).substr( 1, getArgStr( 1 ).size() - 2 ) != "SM" && getArgStr( 1 ).substr( 1, getArgStr( 1 ).size() - 2 ) != "-C7_SM" && getArgStr( 1 ).substr( 1, getArgStr( 1 ).size() - 2 ) != "SUSY-ChenGeng" ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll doesn't know this physics model: " << getArgStr( 1 ) << std::endl; ::abort(); } m_HEPmodel = getArgStr( 1 ).substr( 1, getArgStr( 1 ).size() - 2 ); } else { m_HEPmodel = "SM"; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll will use this physics model: " << m_HEPmodel << std::endl; if ( getNArg() > 2 ) { if ( getArgStr( 2 ).substr( 1, getArgStr( 2 ).size() - 2 ) != "HQET" && getArgStr( 2 ).substr( 1, getArgStr( 2 ).size() - 2 ) != "HQET-noF2" && getArgStr( 2 ).substr( 1, 11 ) != "HQET-delta=" ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll doesn't know this Form-Factors model: " << getArgStr( 2 ) << std::endl; ::abort(); } m_FFtype = getArgStr( 2 ).substr( 1, getArgStr( 2 ).size() - 2 ); } else { m_FFtype = "HQET"; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll will use this Form-Factors model: " << m_FFtype << std::endl; if ( getNArg() > 3 ) { if ( getArgStr( 3 ).substr( 1, getArgStr( 3 ).size() - 2 ) != "Unpolarized" ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll doesn't know kind of introducing polarization: " << getArgStr( 3 ) << std::endl; ::abort(); } m_polarizationIntroduction = getArgStr( 3 ).substr( 1, getArgStr( 3 ).size() - 2 ); } else { m_polarizationIntroduction = "Unpolarized"; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll will use this kind of introducing polarization: " << m_polarizationIntroduction << std::endl; if ( getNArg() > 4 ) { if ( getArgStr( 4 ).substr( 1, getArgStr( 4 ).size() - 2 ) != "SD" && getArgStr( 4 ).substr( 1, getArgStr( 4 ).size() - 2 ) != "LD" ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll didn't find SD or LD parameter: " << getArgStr( 4 ) << std::endl; ::abort(); } m_effectContribution = getArgStr( 5 ).substr( 1, getArgStr( 4 ).size() - 2 ); } else { m_effectContribution = "SD"; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll will include contribution from these effects: " << m_effectContribution << std::endl; if ( getNArg() > 5 ) { if ( fabs( getArg( 5 ) ) > 0.15 ) { EvtGenReport( EVTGEN_WARNING, "EvtGen" ) << " WARNING: EvtLb2Lll found very high contribution to b->sg decay at q2=0: " << getArg( 5 ) << std::endl; } m_omega = getArg( 5 ); } else { m_omega = 0; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll will use this contribution to b->sg decay at q2=0: " << m_omega << std::endl; if ( getNArg() > 6 ) m_noTries = (long)( getArg( 6 ) ); else m_noTries = 0; if ( getNArg() > 7 ) { if ( getArg( 7 ) < 0. ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll expects positive maximum probability not : " << getArg( 7 ) << std::endl; ::abort(); } m_maxProbability = getArg( 7 ); } else { m_maxProbability = 0.; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll maximum probability was set to " << m_maxProbability << std::endl; m_poleSize = 0; // Initialize Wilson coefficients by Buras and Munz // TODO: should have common W.C. source for all decays in EvtGen m_WC.CalculateAllCoefficients(); } void EvtLb2Lll::initProbMax() { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll is finding maximum probability ... " << std::endl; - if ( m_maxProbability == 0 ) { + if ( m_maxProbability < 1e-10 ) { EvtDiracParticle* parent = new EvtDiracParticle; parent->noLifeTime(); parent->init( getParentId(), EvtVector4R( EvtPDL::getMass( getParentId() ), 0, 0, 0 ) ); parent->setDiagonalSpinDensity(); EvtAmp amp; EvtId daughters[3] = {getDaug( 0 ), getDaug( 1 ), getDaug( 2 )}; amp.init( getParentId(), 3, daughters ); parent->makeDaughters( 3, daughters ); EvtParticle* lambda = parent->getDaug( 0 ); EvtParticle* lep1 = parent->getDaug( 1 ); EvtParticle* lep2 = parent->getDaug( 2 ); lambda->noLifeTime(); lep1->noLifeTime(); lep2->noLifeTime(); EvtSpinDensity rho; rho.setDiag( parent->getSpinStates() ); double M0 = EvtPDL::getMass( getParentId() ); double mL = EvtPDL::getMass( getDaug( 0 ) ); double m1 = EvtPDL::getMass( getDaug( 1 ) ); double m2 = EvtPDL::getMass( getDaug( 2 ) ); double q2, pstar, elambda, theta; double q2min = ( m1 + m2 ) * ( m1 + m2 ); double q2max = ( M0 - mL ) * ( M0 - mL ); EvtVector4R p4lambda, p4lep1, p4lep2, boost; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll is probing whole phase space ..." << std::endl; int i, j; double prob = 0; for ( i = 0; i <= 100; i++ ) { q2 = q2min + i * ( q2max - q2min ) / 100.; elambda = ( M0 * M0 + mL * mL - q2 ) / 2 / M0; if ( i == 0 ) pstar = 0; else pstar = sqrt( q2 - ( m1 + m2 ) * ( m1 + m2 ) ) * sqrt( q2 - ( m1 - m2 ) * ( m1 - m2 ) ) / 2 / sqrt( q2 ); boost.set( M0 - elambda, 0, 0, +sqrt( elambda * elambda - mL * mL ) ); if ( i != 100 ) { p4lambda.set( elambda, 0, 0, -sqrt( elambda * elambda - mL * mL ) ); } else { p4lambda.set( mL, 0, 0, 0 ); } for ( j = 0; j <= 45; j++ ) { theta = j * EvtConst::pi / 45; p4lep1.set( sqrt( pstar * pstar + m1 * m1 ), 0, +pstar * sin( theta ), +pstar * cos( theta ) ); p4lep2.set( sqrt( pstar * pstar + m2 * m2 ), 0, -pstar * sin( theta ), -pstar * cos( theta ) ); if ( i != 100 ) // At maximal q2 we are already in correct frame as Lambda and W/Zvirtual are at rest { p4lep1 = boostTo( p4lep1, boost ); p4lep2 = boostTo( p4lep2, boost ); } calcAmp( &, parent ); prob = rho.normalizedProb( amp.getSpinDensity() ); //std::cout << "q2: " << q2 << " \t theta: " << theta << " \t prob: " << prob << std::endl; //std::cout << "p1: " << p4lep1 << " p2: " << p4lep2 << " q2-q2min: " << q2-(m1+m2)*(m1+m2) << std::endl; if ( prob > m_maxProbability ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " - probability " << prob << " found at q2 = " << q2 << " (" << 100 * ( q2 - q2min ) / ( q2max - q2min ) << " %) and theta = " << theta * 180 / EvtConst::pi << std::endl; m_maxProbability = prob; } } //::abort(); } //m_poleSize = 0.04*q2min; m_maxProbability *= 1.2; delete parent; } + if (m_maxProbability < 1e-10) { + EvtGenReport( EVTGEN_INFO, "EvtLb2Lll") + << "EvtLb2Lll found zero max prob, setting to 1.5e6" << std::endl; + m_maxProbability = 1.5e6; + } + setProbMax( m_maxProbability ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtLb2Lll set up maximum probability to " << m_maxProbability << std::endl; } void EvtLb2Lll::decay( EvtParticle* parent ) { //setWeight(parent->initializePhaseSpace(getNDaug(),getDaugs(),m_poleSize,1,2)); parent->initializePhaseSpace( getNDaug(), getDaugs() ); calcAmp( &_amp2, parent ); } void EvtLb2Lll::calcAmp( EvtAmp* amp, EvtParticle* parent ) { static long noTries = 0; static double delta = 0; EvtComplex Matrix[2][2][2][2]; EvtComplex i1( 0, 1 ); int i, j, spins[4]; char ch; double r, M_L, M_Lb, M_s, M_c, M_b, q2, alpha, M_W, M_t; double M_psi[2] = {0, 0}, Gamma_psi[2] = {0, 0}, k_psi[2] = {0, 0}; double F0_1, F0_2, a_F1, a_F2, b_F1, b_F2, F1, F2; double f_1, f_2, f_3, g_1, g_2, g_3, f_1T, f_2T, f_3T, g_1T, g_2T, g_3T, f_TV, f_TS, g_TV( 0.0 ), g_TS, f_T, g_T; EvtComplex A1, A2, A3, B1, B2, B3, D1, D2, D3, E1, E2, E3, N1, N2, H1, H2; EvtComplex C_SL, C_BR, C_LLtot, C_LRtot, C_LL, C_LR, C_RL, C_RR, C_LRLR, C_RLLR, C_LRRL, C_RLRL, C_T, C_TE; EvtComplex Yld, C_7eff, C_9eff; EvtComplex V_ts, V_tb; EvtVector4C lbar_Gmu_l[2][2], lbar_GmuG5_l[2][2], hbar_GmuPlusG5_h[2][2], hbar_GmuMinusG5_h[2][2], hbar_Gmu_h[2][2]; EvtComplex lbar_l[2][2], lbar_G5_l[2][2], hbar_1PlusG5_h[2][2], hbar_1MinusG5_h[2][2], hbar_G5_h[2][2], hbar_h[2][2]; EvtTensor4C lbar_Smunu_l[2][2], lbar_ESmunu_l[2][2], hbar_SmunuPlusG5_h[2][2], hbar_SmunuMinusG5_h[2][2], hbar_Smunu_h[2][2]; EvtVector4R q_mu, P_mu; EvtDiracSpinor parent__spParent[2]; M_Lb = parent->mass(); M_L = parent->getDaug( 0 )->mass(); M_s = 0.13; M_c = 1.35; M_b = 4.8; alpha = 1. / 137.036; M_W = 80.425; M_t = 174.3; M_psi[0] = 3.096916; M_psi[1] = 3.686093; if ( m_decayName == "Lambda_b0 -> Lambda0 e- e+" || m_decayName == "anti-Lambda_b0 -> anti-Lambda0 e+ e-" ) { Gamma_psi[0] = 5.40; Gamma_psi[1] = 2.12; } if ( m_decayName == "Lambda_b0 -> Lambda0 mu- mu+" || m_decayName == "anti-Lambda_b0 -> anti-Lambda0 mu+ mu-" ) { Gamma_psi[0] = 5.35; Gamma_psi[1] = 2.05; } if ( m_decayName == "Lambda_b0 -> Lambda0 tau- tau+" || m_decayName == "anti-Lambda_b0 -> anti-Lambda0 tau+ tau-" ) { Gamma_psi[0] = 0.00; Gamma_psi[1] = 0.79; } if ( m_effectContribution == "LD" ) { k_psi[0] = 1.65; k_psi[1] = 1.65; } //G_F = 1.16637e-5; //V_tb = sqrt(1-pow(0.0413,2))*sqrt(1-pow(0.0037,2)); //V_ts = -sqrt(1-pow(0.2243,2))*0.0413-0.2243*sqrt(1-pow(0.0413,2))*0.0037*(cos(60*EvtConst::pi/180)+i1*sin(60*EvtConst::pi/180)); P_mu = parent->getP4Restframe() + parent->getDaug( 0 )->getP4(); q_mu = parent->getP4Restframe() - parent->getDaug( 0 )->getP4(); q2 = q_mu.mass2(); if ( m_noTries > 0 ) if ( !( ( ++noTries ) % m_noTries ) ) EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << " EvtLb2Lll already finished " << noTries << " matrix element calculations" << std::endl; if ( m_FFtype == "HQET" ) { r = M_L * M_L / M_Lb / M_Lb; F0_1 = +0.462; F0_2 = -0.077; a_F1 = -0.0182; a_F2 = -0.0685; b_F1 = -0.000176; b_F2 = +0.001460; F1 = F0_1 / ( 1.0 - ( q2 / M_Lb / M_Lb ) * ( a_F1 - b_F1 * ( q2 / M_Lb / M_Lb ) ) ); F2 = F0_2 / ( 1.0 - ( q2 / M_Lb / M_Lb ) * ( a_F2 - b_F2 * ( q2 / M_Lb / M_Lb ) ) ); g_1 = f_1 = f_2T = g_2T = F1 + sqrt( r ) * F2; //std::cout << " F1: " << F1 << " F2: " << F2 << " r: " << r << " M_L: " << M_L << " M_Lb: " << M_Lb << std::endl; //std::cout << " sqrt(q2): " << sqrt(q2) << " q2: " << q2 << " M_Lb^2" << M_Lb*M_Lb << std::endl; g_2 = f_2 = g_3 = f_3 = g_TV = f_TV = F2 / M_Lb; g_TS = f_TS = 0; g_1T = f_1T = F2 / M_Lb * q2; g_3T = +F2 / M_Lb * ( M_Lb + M_L ); f_3T = -F2 / M_Lb * ( M_Lb - M_L ); f_T = f_2T - f_TS * q2; g_T = g_2T - g_TS * q2; } else if ( strstr( m_FFtype.c_str(), "HQET-delta=" ) == m_FFtype.c_str() ) { //EvtGenReport(EVTGEN_WARNING,"EvtGen") << " WARNING: HQET-delta FF model should be checked for correctness" << std::endl; if ( delta == 0 ) sscanf( m_FFtype.c_str(), "%c%c%c%c%c%c%c%c%c%c%c%lf", &ch, &ch, &ch, &ch, &ch, &ch, &ch, &ch, &ch, &ch, &ch, &delta ); r = M_L * M_L / M_Lb / M_Lb; F0_1 = +0.462; F0_2 = -0.077; a_F1 = -0.0182; a_F2 = -0.0685; b_F1 = -0.000176; b_F2 = +0.001460; F1 = F0_1 / ( 1.0 - ( q2 / M_Lb / M_Lb ) * ( a_F1 - b_F1 * ( q2 / M_Lb / M_Lb ) ) ); F2 = F0_2 / ( 1.0 - ( q2 / M_Lb / M_Lb ) * ( a_F2 - b_F2 * ( q2 / M_Lb / M_Lb ) ) ); g_1 = f_1 = f_2T = g_2T = F1 + sqrt( r ) * F2; g_1 += delta * g_1; f_1 -= delta * f_1; g_2 = f_2 = g_3 = f_3 = g_TV = f_TV = F2 / M_Lb; g_TS = f_TS = 0; g_1T = f_1T = F2 / M_Lb * q2; g_3T = +F2 / M_Lb * ( M_Lb + M_L ); f_3T = -F2 / M_Lb * ( M_Lb - M_L ); f_T = f_2T - f_TS * q2; g_T = g_2T - g_TS * q2; } else if ( m_FFtype == "HQET-noF2" ) { //EvtGenReport(EVTGEN_WARNING,"EvtGen") << " WARNING: HQET-noF2 FF model should be checked for correctness" << std::endl; r = M_L * M_L / M_Lb / M_Lb; F0_1 = +0.462; a_F1 = -0.0182; b_F1 = -0.000176; F1 = F0_1 / ( 1.0 - ( q2 / M_Lb / M_Lb ) * ( a_F1 - b_F1 * ( q2 / M_Lb / M_Lb ) ) ); g_1 = f_1 = f_2T = g_2T = F1; g_2 = f_2 = g_3 = f_3 = g_TV = f_TV = 0; g_TS = f_TS = 0; g_1T = f_1T = 0; g_3T = 0; f_3T = 0; f_T = f_2T - f_TS * q2; g_T = g_2T - g_TS * q2; } else { // general relations for Form-Factors f_1 = f_2 = f_3 = g_1 = g_2 = g_3 = f_3T = g_3T = f_TS = g_TS = f_T = g_T = f_TV = 0; f_2T = f_T + f_TS * q2; f_1T = ( f_TV + f_TS * ( M_L + M_Lb ) ) * q2; f_1T = -q2 / ( M_Lb - M_L ) * f_3T; g_2T = g_T + g_TS * q2; g_1T = ( g_TV - g_TS * ( M_L - M_Lb ) ) * q2; g_1T = +q2 / ( M_Lb + M_L ) * g_3T; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll - unknown Form-Factors model: " << m_FFtype << " - this should never happen !" << std::endl; ::abort(); } if ( m_HEPmodel == "SM" ) { C_LL = C_LR = C_RL = C_RR = C_LRLR = C_RLLR = C_LRRL = C_RLRL = C_T = C_TE = EvtComplex( 0, 0 ); Yld = m_WC.Yld( q2, k_psi, Gamma_psi, M_psi, 2, m_WC.GetC1(), m_WC.GetC2(), m_WC.GetC3(), m_WC.GetC4(), m_WC.GetC5(), m_WC.GetC6(), 1. / alpha ); C_7eff = m_WC.GetC7eff0() + m_WC.C7b2sg( m_WC.GetStrongCouplingConst(), m_WC.GetEta(), m_WC.GetC2(), M_t, M_W ) + m_omega * ( m_WC.hzs( M_c / M_b, q2 / M_b / M_b, M_b, M_b ) + Yld ); C_9eff = Yld + m_WC.C9efftilda( M_c / M_b, q2 / M_b / M_b, m_WC.GetStrongCouplingConst(), m_WC.GetC1(), m_WC.GetC2(), m_WC.GetC3(), m_WC.GetC4(), m_WC.GetC5(), m_WC.GetC6(), m_WC.GetC9tilda(), m_WC.GetRenormSchemePar() ); C_SL = -2 * M_s * C_7eff; C_BR = -2 * M_b * C_7eff; C_LLtot = C_9eff - m_WC.GetC10tilda() + C_LL; C_LRtot = C_9eff + m_WC.GetC10tilda() + C_LR; //std::cout << "Yld: " << Yld << " C7eff: " << C_7eff << " C_9eff: " << C_9eff << " Diff7: " << C_7eff-m_WC.GetC7eff0() << " Diff9: " << C_9eff-m_WC.GetC9tilda() << std::endl; } else if ( m_HEPmodel == "-C7_SM" ) { C_LL = C_LR = C_RL = C_RR = C_LRLR = C_RLLR = C_LRRL = C_RLRL = C_T = C_TE = EvtComplex( 0, 0 ); Yld = m_WC.Yld( q2, k_psi, Gamma_psi, M_psi, 2, m_WC.GetC1(), m_WC.GetC2(), m_WC.GetC3(), m_WC.GetC4(), m_WC.GetC5(), m_WC.GetC6(), 1. / alpha ); C_7eff = m_WC.GetC7eff0() + m_WC.C7b2sg( m_WC.GetStrongCouplingConst(), m_WC.GetEta(), m_WC.GetC2(), M_t, M_W ) + m_omega * ( m_WC.hzs( M_c / M_b, q2 / M_b / M_b, M_b, M_b ) + Yld ); C_9eff = Yld + m_WC.C9efftilda( M_c / M_b, q2 / M_b / M_b, m_WC.GetStrongCouplingConst(), m_WC.GetC1(), m_WC.GetC2(), m_WC.GetC3(), m_WC.GetC4(), m_WC.GetC5(), m_WC.GetC6(), m_WC.GetC9tilda(), m_WC.GetRenormSchemePar() ); C_SL = +2 * M_s * C_7eff; C_BR = +2 * M_b * C_7eff; C_LLtot = C_9eff - m_WC.GetC10tilda() + C_LL; C_LRtot = C_9eff + m_WC.GetC10tilda() + C_LR; //std::cout << "Yld: " << Yld << " C7eff: " << C_7eff << " C_9eff: " << C_9eff << " Diff7: " << C_7eff-m_WC.GetC7eff0() << " Diff9: " << C_9eff-m_WC.GetC9tilda() << std::endl; } else if ( m_HEPmodel == "SUSY-ChenGeng" ) { //EvtGenReport(EVTGEN_WARNING,"EvtGen") << " WARNING: SUSY-ChenGeng model should be checked for correctness" << std::endl; C_LL = C_LR = C_RL = C_RR = C_LRLR = C_RLLR = C_LRRL = C_RLRL = C_T = C_TE = EvtComplex( 0, 0 ); EvtComplex d_u23LL = 0.1; EvtComplex d_u33RL = 0.65; EvtComplex d_d23LR = 0.03 * exp( i1 * EvtConst::pi * 2 / 5 ); EvtComplex d_u23LR = -0.8 * exp( i1 * EvtConst::pi / 4 ); EvtComplex C_7susy = -1.75 * d_u23LL - 0.25 * d_u23LR - 10.3 * d_d23LR; EvtComplex C_9susy = 0.82 * d_u23LR; EvtComplex C_10susy = -9.37 * d_u23LR + 1.4 * d_u23LR * d_u33RL + 2.7 * d_u23LL; Yld = m_WC.Yld( q2, k_psi, Gamma_psi, M_psi, 2, m_WC.GetC1(), m_WC.GetC2(), m_WC.GetC3(), m_WC.GetC4(), m_WC.GetC5(), m_WC.GetC6(), 1. / alpha ); C_7eff = m_WC.GetC7eff0() + C_7susy * pow( m_WC.GetEta(), 16. / 23. ) + m_WC.C7b2sg( m_WC.GetStrongCouplingConst(), m_WC.GetEta(), m_WC.GetC2(), M_t, M_W ) + m_omega * ( m_WC.hzs( M_c / M_b, q2 / M_b / M_b, M_b, M_b ) + Yld ); C_9eff = Yld + m_WC.C9efftilda( M_c / M_b, q2 / M_b / M_b, m_WC.GetStrongCouplingConst(), m_WC.GetC1(), m_WC.GetC2(), m_WC.GetC3(), m_WC.GetC4(), m_WC.GetC5(), m_WC.GetC6(), m_WC.GetC9tilda() + C_9susy, m_WC.GetRenormSchemePar() ); C_SL = -2 * M_s * C_7eff; C_BR = -2 * M_b * C_7eff; C_LLtot = C_9eff - m_WC.GetC10tilda() - C_10susy + C_LL; C_LRtot = C_9eff + m_WC.GetC10tilda() + C_10susy + C_LR; //std::cout << "Yld: " << Yld << " C7eff: " << C_7eff << " C_9eff: " << C_9eff << " Diff7: " << C_7eff-m_WC.GetC7eff0() << " Diff9: " << C_9eff-m_WC.GetC9tilda() << std::endl; } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll - unknown physics model: " << m_HEPmodel << " - this should never happen !" << std::endl; ::abort(); } A1 = ( f_1T - g_1T ) * C_SL / q2 + ( f_1T + g_1T ) * C_BR / q2 + 0.5 * ( f_1 - g_1 ) * ( C_LLtot + C_LRtot ) + 0.5 * ( f_1 + g_1 ) * ( C_RL + C_RR ); //std::cout << "f_1T: " << f_1T << " g_1T: " << g_1T << " C_SL: " << C_SL << " C_BR: " << C_BR << " f_1: " << f_1 << " g_1: " << g_1 << " C_LLtot: " << C_LLtot << " C_LRtot: " << C_LRtot << " C_RL: " << C_RL << " C_RR: " << C_RR << std::endl; A2 = ( f_2T - g_2T ) * C_SL / q2 + ( f_2T + g_2T ) * C_BR / q2 + 0.5 * ( f_2 - g_2 ) * ( C_LLtot + C_LRtot ) + 0.5 * ( f_2 + g_2 ) * ( C_RL + C_RR ); A3 = ( f_3T - g_3T ) * C_SL / q2 + ( f_3T + g_3T ) * C_BR / q2 + 0.5 * ( f_3 - g_3 ) * ( C_LLtot + C_LRtot ) + 0.5 * ( f_3 + g_3 ) * ( C_RL + C_RR ); B1 = ( f_1T + g_1T ) * C_SL / q2 + ( f_1T - g_1T ) * C_BR / q2 + 0.5 * ( f_1 + g_1 ) * ( C_LLtot + C_LRtot ) + 0.5 * ( f_1 - g_1 ) * ( C_RL + C_RR ); B2 = ( f_2T + g_2T ) * C_SL / q2 + ( f_2T - g_2T ) * C_BR / q2 + 0.5 * ( f_2 + g_2 ) * ( C_LLtot + C_LRtot ) + 0.5 * ( f_2 - g_2 ) * ( C_RL + C_RR ); B3 = ( f_3T + g_3T ) * C_SL / q2 + ( f_3T - g_3T ) * C_BR / q2 + 0.5 * ( f_3 + g_3 ) * ( C_LLtot + C_LRtot ) + 0.5 * ( f_3 - g_3 ) * ( C_RL + C_RR ); D1 = 0.5 * ( C_RR - C_RL ) * ( f_1 + g_1 ) + 0.5 * ( C_LRtot - C_LLtot ) * ( f_1 - g_1 ); D2 = 0.5 * ( C_RR - C_RL ) * ( f_2 + g_2 ) + 0.5 * ( C_LRtot - C_LLtot ) * ( f_2 - g_2 ); D3 = 0.5 * ( C_RR - C_RL ) * ( f_3 + g_3 ) + 0.5 * ( C_LRtot - C_LLtot ) * ( f_3 - g_3 ); E1 = 0.5 * ( C_RR - C_RL ) * ( f_1 - g_1 ) + 0.5 * ( C_LRtot - C_LLtot ) * ( f_1 + g_1 ); E2 = 0.5 * ( C_RR - C_RL ) * ( f_2 - g_2 ) + 0.5 * ( C_LRtot - C_LLtot ) * ( f_2 + g_2 ); E3 = 0.5 * ( C_RR - C_RL ) * ( f_3 - g_3 ) + 0.5 * ( C_LRtot - C_LLtot ) * ( f_3 + g_3 ); N1 = ( f_1 * ( M_Lb - M_L ) + f_3 * q2 ) / M_b * ( C_LRLR + C_RLLR + C_LRRL + C_RLRL ); // Should be mLb - mL N2 = ( f_1 * ( M_Lb - M_L ) + f_3 * q2 ) / M_b * ( C_LRLR + C_RLLR - C_LRRL - C_RLRL ); H1 = ( g_1 * ( M_Lb + M_L ) - g_3 * q2 ) / M_b * ( C_LRLR - C_RLLR + C_LRRL - C_RLRL ); H2 = ( g_1 * ( M_Lb + M_L ) - g_3 * q2 ) / M_b * ( C_LRLR - C_RLLR - C_LRRL + C_RLRL ); for ( i = 0; i < 4; i++ ) { lbar_Gmu_l[i / 2][i % 2] = EvtLeptonVCurrent( parent->getDaug( 1 )->spParent( i / 2 ), parent->getDaug( 2 )->spParent( i % 2 ) ); lbar_GmuG5_l[i / 2][i % 2] = EvtLeptonACurrent( parent->getDaug( 1 )->spParent( i / 2 ), parent->getDaug( 2 )->spParent( i % 2 ) ); lbar_l[i / 2][i % 2] = EvtLeptonSCurrent( parent->getDaug( 1 )->spParent( i / 2 ), parent->getDaug( 2 )->spParent( i % 2 ) ); lbar_G5_l[i / 2][i % 2] = EvtLeptonPCurrent( parent->getDaug( 1 )->spParent( i / 2 ), parent->getDaug( 2 )->spParent( i % 2 ) ); lbar_Smunu_l[i / 2][i % 2] = EvtLeptonTCurrent( parent->getDaug( 1 )->spParent( i / 2 ), parent->getDaug( 2 )->spParent( i % 2 ) ); lbar_ESmunu_l[i / 2][i % 2] = dual( EvtLeptonTCurrent( parent->getDaug( 1 )->spParent( i / 2 ), parent->getDaug( 2 )->spParent( i % 2 ) ) ); } // TODO: polarization not yet introduced if ( m_polarizationIntroduction == "SpinDensityMatrix" ) { //parent->setSpinDensityForward(); parent__spParent[0] = parent->sp( 0 ); parent__spParent[1] = parent->sp( 1 ); } else if ( m_polarizationIntroduction == "ModifiedSpinors" ) { parent__spParent[0] = parent->sp( 0 ); parent__spParent[1] = parent->sp( 1 ); } else if ( m_polarizationIntroduction == "Unpolarized" ) { parent__spParent[0] = parent->sp( 0 ); parent__spParent[1] = parent->sp( 1 ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " ERROR: EvtLb2Lll - unknown polarization: " << m_polarizationIntroduction << " - this should never happen !" << std::endl; ::abort(); } for ( i = 0; i < 4; i++ ) { hbar_GmuPlusG5_h[i / 2][i % 2] = EvtLeptonVCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ) + EvtLeptonACurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_GmuMinusG5_h[i / 2][i % 2] = EvtLeptonVACurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_SmunuPlusG5_h[i / 2][i % 2] = EvtLeptonTCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ) + EvtLeptonTG5Current( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_SmunuMinusG5_h[i / 2][i % 2] = EvtLeptonTCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ) - EvtLeptonTG5Current( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_1PlusG5_h[i / 2][i % 2] = EvtLeptonSCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ) + EvtLeptonPCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_1MinusG5_h[i / 2][i % 2] = EvtLeptonSCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ) - EvtLeptonPCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_G5_h[i / 2][i % 2] = EvtLeptonPCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_h[i / 2][i % 2] = EvtLeptonSCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_Smunu_h[i / 2][i % 2] = EvtLeptonTCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); hbar_Gmu_h[i / 2][i % 2] = EvtLeptonVCurrent( parent->getDaug( 0 )->spParent( i / 2 ), parent__spParent[i % 2] ); } for ( i = 0; i < 4; i++ ) for ( j = 0; j < 4; j++ ) { //std::cout << "--------------------------------------------------" << std::endl; //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_Gmu_l[i / 2][i % 2] * ( A1 * hbar_GmuPlusG5_h[j / 2][j % 2] + B1 * hbar_GmuMinusG5_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; //std::cout << "A1: " << A1 << " B1: " << B1 << " lbar_Gmu_l: " << lbar_Gmu_l[i/2][i%2] << // " hbar_GmuPlusG5_h: " << hbar_GmuPlusG5_h[j/2][j%2] << " hbar_GmuMinusG5_h: " << hbar_GmuMinusG5_h[j/2][j%2] << // " sp1: " << parent->getDaug(1)->spParent(i/2) << " sp2: " << parent->getDaug(1)->spParent(i%2) << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_Gmu_l[i / 2][i % 2] * ( i1 * A2 * ( hbar_SmunuPlusG5_h[j / 2][j % 2].cont2( q_mu ) ) + B2 * ( hbar_SmunuMinusG5_h[j / 2][j % 2].cont2( q_mu ) ) ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_Gmu_l[i / 2][i % 2] * ( ( A3 * hbar_1PlusG5_h[j / 2][j % 2] + B3 * hbar_1MinusG5_h[j / 2][j % 2] ) * q_mu ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_GmuG5_l[i / 2][i % 2] * ( D1 * hbar_GmuPlusG5_h[j / 2][j % 2] + E1 * hbar_GmuMinusG5_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_GmuG5_l[i / 2][i % 2] * ( i1 * D2 * ( hbar_SmunuPlusG5_h[j / 2][j % 2].cont2( q_mu ) ) + E2 * ( hbar_SmunuMinusG5_h[j / 2][j % 2].cont2( q_mu ) ) ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_GmuG5_l[i / 2][i % 2] * ( ( D3 * hbar_1PlusG5_h[j / 2][j % 2] + E3 * hbar_1MinusG5_h[j / 2][j % 2] ) * q_mu ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_l[i / 2][i % 2] * ( N1 * hbar_h[j / 2][j % 2] + H1 * hbar_G5_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += lbar_G5_l[i / 2][i % 2] * ( N2 * hbar_h[j / 2][j % 2] + H2 * hbar_G5_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += cont( lbar_Smunu_l[i / 2][i % 2], 4 * C_T * f_T * hbar_Smunu_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += cont( lbar_Smunu_l[i / 2][i % 2], -4 * C_T * f_TV * i1 * ( EvtGenFunctions::directProd( q_mu, hbar_Gmu_h[j / 2][j % 2] ) - EvtGenFunctions::directProd( hbar_Gmu_h[j / 2][j % 2], q_mu ) ) ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += cont( lbar_Smunu_l[i / 2][i % 2], -4 * C_T * f_TS * i1 * ( EvtGenFunctions::directProd( P_mu, q_mu ) - EvtGenFunctions::directProd( q_mu, P_mu ) ) * hbar_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += cont( lbar_ESmunu_l[i / 2][i % 2], 4 * C_TE * f_T * i1 * hbar_Smunu_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += cont( lbar_ESmunu_l[i / 2][i % 2], 4 * C_TE * f_TV * ( EvtGenFunctions::directProd( q_mu, hbar_Gmu_h[j / 2][j % 2] ) - EvtGenFunctions::directProd( hbar_Gmu_h[j / 2][j % 2], q_mu ) ) ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; Matrix[j / 2][j % 2][i / 2][i % 2] += cont( lbar_ESmunu_l[i / 2][i % 2], 4 * C_TE * f_TS * ( EvtGenFunctions::directProd( P_mu, q_mu ) - EvtGenFunctions::directProd( q_mu, P_mu ) ) * hbar_h[j / 2][j % 2] ); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; //Matrix[j/2][j%2][i/2][i%2] *= G_F*alpha/4/sqrt(2)/EvtConst::pi*V_tb*conj(V_ts); //std::cout << "Matrix = " << Matrix[j/2][j%2][i/2][i%2] << std::endl; //std::cout << "--------------------------------------------------" << std::endl; spins[0] = j % 2; spins[1] = j / 2; spins[2] = i / 2; spins[3] = i % 2; amp->vertex( spins, Matrix[j / 2][j % 2][i / 2][i % 2] ); } //std::cout << "==================================================" << std::endl; //std::cout << "Lambda_b0: " << parent->getP4Restframe() << std::endl; //std::cout << "Lambda0: " << parent->getDaug(0)->getP4() << std::endl; //std::cout << "mu-: " << parent->getDaug(1)->getP4() << std::endl; //std::cout << "mu+: " << parent->getDaug(2)->getP4() << std::endl; //std::cout << "P_mu: " << P_mu << std::endl; //std::cout << "q_mu: " << q_mu << std::endl; //std::cout << "q2: " << q2 << std::endl; //std::cout << "==================================================" << std::endl; return; } EvtTensor4C EvtLb2Lll::EvtLeptonTG5Current( const EvtDiracSpinor& d, const EvtDiracSpinor& dp ) { // EvtTensor4C temp; temp.zero(); EvtComplex i2( 0, 0.5 ); static EvtGammaMatrix mat01 = EvtGammaMatrix::g0() * ( EvtGammaMatrix::g0() * EvtGammaMatrix::g1() - EvtGammaMatrix::g1() * EvtGammaMatrix::g0() ) * EvtGammaMatrix::g5(); static EvtGammaMatrix mat02 = EvtGammaMatrix::g0() * ( EvtGammaMatrix::g0() * EvtGammaMatrix::g2() - EvtGammaMatrix::g2() * EvtGammaMatrix::g0() ) * EvtGammaMatrix::g5(); static EvtGammaMatrix mat03 = EvtGammaMatrix::g0() * ( EvtGammaMatrix::g0() * EvtGammaMatrix::g3() - EvtGammaMatrix::g3() * EvtGammaMatrix::g0() ) * EvtGammaMatrix::g5(); static EvtGammaMatrix mat12 = EvtGammaMatrix::g0() * ( EvtGammaMatrix::g1() * EvtGammaMatrix::g2() - EvtGammaMatrix::g2() * EvtGammaMatrix::g1() ) * EvtGammaMatrix::g5(); static EvtGammaMatrix mat13 = EvtGammaMatrix::g0() * ( EvtGammaMatrix::g1() * EvtGammaMatrix::g3() - EvtGammaMatrix::g3() * EvtGammaMatrix::g1() ) * EvtGammaMatrix::g5(); static EvtGammaMatrix mat23 = EvtGammaMatrix::g0() * ( EvtGammaMatrix::g2() * EvtGammaMatrix::g3() - EvtGammaMatrix::g3() * EvtGammaMatrix::g2() ) * EvtGammaMatrix::g5(); temp.set( 0, 1, i2 * ( d * ( mat01 * dp ) ) ); temp.set( 1, 0, -temp.get( 0, 1 ) ); temp.set( 0, 2, i2 * ( d * ( mat02 * dp ) ) ); temp.set( 2, 0, -temp.get( 0, 2 ) ); temp.set( 0, 3, i2 * ( d * ( mat03 * dp ) ) ); temp.set( 3, 0, -temp.get( 0, 3 ) ); temp.set( 1, 2, i2 * ( d * ( mat12 * dp ) ) ); temp.set( 2, 1, -temp.get( 1, 2 ) ); temp.set( 1, 3, i2 * ( d * ( mat13 * dp ) ) ); temp.set( 3, 1, -temp.get( 1, 3 ) ); temp.set( 2, 3, i2 * ( d * ( mat23 * dp ) ) ); temp.set( 3, 2, -temp.get( 2, 3 ) ); return temp; } diff --git a/src/EvtGenModels/EvtMelikhov.cpp b/src/EvtGenModels/EvtMelikhov.cpp index 3ca2ebe..23c8b90 100644 --- a/src/EvtGenModels/EvtMelikhov.cpp +++ b/src/EvtGenModels/EvtMelikhov.cpp @@ -1,67 +1,72 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtMelikhov.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtSemiLeptonicVectorAmp.hh" #include "EvtGenModels/EvtMelikhovFF.hh" #include #include std::string EvtMelikhov::getName() { return "MELIKHOV"; } EvtDecayBase* EvtMelikhov::clone() { return new EvtMelikhov; } void EvtMelikhov::decay( EvtParticle* p ) { p->initializePhaseSpace( getNDaug(), getDaugs() ); calcamp->CalcAmp( p, _amp2, Melikhovffmodel.get() ); } void EvtMelikhov::init() { checkNArg( 1 ); checkNDaug( 3 ); //We expect the parent to be a scalar //and the daughters to be X lepton neutrino checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::VECTOR ); checkSpinDaughter( 1, EvtSpinType::DIRAC ); checkSpinDaughter( 2, EvtSpinType::NEUTRINO ); Melikhovffmodel = std::make_unique( getArg( 0 ) ); calcamp = std::make_unique(); } + +void EvtMelikhov::initProbMax() +{ + setProbMax( 10000.0 ); +} diff --git a/src/EvtGenModels/EvtMultibody.cpp b/src/EvtGenModels/EvtMultibody.cpp index 612359d..2defab6 100644 --- a/src/EvtGenModels/EvtMultibody.cpp +++ b/src/EvtGenModels/EvtMultibody.cpp @@ -1,97 +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 . * ***********************************************************************/ #include "EvtGenModels/EvtMultibody.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtResonance.hh" #include "EvtGenBase/EvtResonance2.hh" #include "EvtGenBase/EvtdFunction.hh" EvtMultibody::~EvtMultibody() { if ( _decayTree != NULL ) delete _decayTree; _decayTree = NULL; if ( _ilist != NULL ) delete[] _ilist; _ilist = NULL; } std::string EvtMultibody::getName() { return "D_MULTIBODY"; } EvtDecayBase* EvtMultibody::clone() { return new EvtMultibody; } void EvtMultibody::init() { int N = getNArg(); _decayTree = new EvtMTree( getDaugs(), getNDaug() ); _ilist = new int[getNDaug() + 1]; for ( int i = 0; i < N - 1; ++i ) { if ( getArgStr( i ) == "RESONANCE" ) { _decayTree->addtree( getArgStr( ++i ) ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Syntax error at " << getArgStr( i ) << std::endl; ::abort(); } } } -// Set the maximum probability amplitude - if function is left blank then the -// program will search for it. This however is not deterministic and therefore -// in the release cannot be in place. void EvtMultibody::initProbMax() { - // setProbMax(1.0); + setProbMax(1.0); } void EvtMultibody::decay( EvtParticle* p ) { // Initialize the phase space before doing anything else! p->initializePhaseSpace( getNDaug(), getDaugs() ); EvtSpinAmp amp = _decayTree->amplitude( p ); vector index = amp.iterallowedinit(); vector spins = amp.dims(); do { for ( size_t i = 0; i < index.size(); ++i ) { _ilist[i] = index[i] + spins[i]; } vertex( _ilist, amp( index ) ); } while ( amp.iterateallowed( index ) ); } diff --git a/src/EvtGenModels/EvtPhiDalitz.cpp b/src/EvtGenModels/EvtPhiDalitz.cpp index 91ae650..5c72b0d 100644 --- a/src/EvtGenModels/EvtPhiDalitz.cpp +++ b/src/EvtGenModels/EvtPhiDalitz.cpp @@ -1,163 +1,168 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtPhiDalitz.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtVector4R.hh" #include #include #include // Implementation of KLOE measurement // PL B561: 55-60 (2003) + Erratum B609:449-450 (2005) // or hep-ex/0303016v2 std::string EvtPhiDalitz::getName() { return "PHI_DALITZ"; } EvtDecayBase* EvtPhiDalitz::clone() { return new EvtPhiDalitz; } void EvtPhiDalitz::init() { // check that there are 0 arguments checkNArg( 0 ); checkNDaug( 3 ); checkSpinParent( EvtSpinType::VECTOR ); checkSpinDaughter( 0, EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::SCALAR ); checkSpinDaughter( 2, EvtSpinType::SCALAR ); _mRho = 0.7758; _gRho = 0.1439; _aD = 0.78; _phiD = -2.47; _aOmega = 0.0071; _phiOmega = -0.22; _locPip = -1; _locPim = -1; _locPi0 = -1; for ( int i = 0; i < 3; i++ ) { if ( getDaug( i ) == EvtPDL::getId( "pi+" ) ) _locPip = i; if ( getDaug( i ) == EvtPDL::getId( "pi-" ) ) _locPim = i; if ( getDaug( i ) == EvtPDL::getId( "pi0" ) ) _locPi0 = i; } if ( _locPip == -1 || _locPim == -1 || _locPi0 == -1 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << getModelName() << "generator expects daughters to be pi+ pi- pi0\n"; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Found " << EvtPDL::name( getDaug( 0 ) ) << " " << EvtPDL::name( getDaug( 1 ) ) << " " << EvtPDL::name( getDaug( 2 ) ) << std::endl; } } +void EvtPhiDalitz::initProbMax() +{ + setProbMax( 150.0 ); +} + void EvtPhiDalitz::decay( EvtParticle* p ) { EvtId PIP = EvtPDL::getId( "pi+" ); EvtId PIM = EvtPDL::getId( "pi-" ); EvtId PIZ = EvtPDL::getId( "pi0" ); EvtId OMEGA = EvtPDL::getId( "omega" ); p->initializePhaseSpace( getNDaug(), getDaugs() ); EvtVector4R Ppip = p->getDaug( _locPip )->getP4(); EvtVector4R Ppim = p->getDaug( _locPim )->getP4(); EvtVector4R Ppi0 = p->getDaug( _locPi0 )->getP4(); EvtVector4R Qp = ( Ppim + Ppi0 ); EvtVector4R Qm = ( Ppip + Ppi0 ); EvtVector4R Q0 = ( Ppip + Ppim ); double m2_pip = pow( EvtPDL::getMeanMass( PIP ), 2 ); double m2_pim = pow( EvtPDL::getMeanMass( PIM ), 2 ); double m2_pi0 = pow( EvtPDL::getMeanMass( PIZ ), 2 ); double M2rhop = pow( _mRho, 2 ); double M2rhom = pow( _mRho, 2 ); double M2rho0 = pow( _mRho, 2 ); double M2omega = pow( EvtPDL::getMeanMass( OMEGA ), 2 ); double Wrhop = _gRho; double Wrhom = _gRho; double Wrho0 = _gRho; double Womega = EvtPDL::getWidth( OMEGA ); EvtComplex Atot( 0, 0 ); //Rho+ Risonance Amplitude double Gp = Wrhop * pow( ( ( Qp.mass2() - m2_pim - m2_pi0 ) / 2 - M2rhop / 4 ) / ( M2rhop / 4 - ( m2_pim + m2_pi0 ) / 2 ), 3 / 2 ) * ( M2rhop / Qp.mass2() ); EvtComplex Drhop( ( Qp.mass2() - M2rhop ), Qp.mass() * Gp ); EvtComplex A1( M2rhop / Drhop ); //Rho- Risonance Amplitude double Gm = Wrhom * pow( ( ( Qm.mass2() - m2_pip - m2_pi0 ) / 2 - M2rhom / 4 ) / ( M2rhom / 4 - ( m2_pip + m2_pi0 ) / 2 ), 3 / 2 ) * ( M2rhom / Qm.mass2() ); EvtComplex Drhom( ( Qm.mass2() - M2rhom ), Qm.mass() * Gm ); EvtComplex A2( M2rhom / Drhom ); //Rho0 Risonance Amplitude double G0 = Wrho0 * pow( ( ( Q0.mass2() - m2_pip - m2_pim ) / 2 - M2rho0 / 4 ) / ( M2rho0 / 4 - ( m2_pip + m2_pim ) / 2 ), 3 / 2 ) * ( M2rho0 / Q0.mass2() ); EvtComplex Drho0( ( Q0.mass2() - M2rho0 ), Q0.mass() * G0 ); EvtComplex A3( M2rho0 / Drho0 ); //Omega Risonance Amplitude EvtComplex OmegaPhase( 0, _phiOmega ); EvtComplex DOmega( ( Q0.mass2() - M2omega ), Q0.mass() * Womega ); EvtComplex A4( _aOmega * M2omega * exp( OmegaPhase ) / DOmega ); //Direct Decay Amplitude EvtComplex DirPhase( 0, _phiD ); EvtComplex A5( _aD * exp( DirPhase ) ); Atot = A1 + A2 + A3 + A4 + A5; vertex( 0, Atot ); vertex( 1, Atot ); vertex( 2, Atot ); return; } diff --git a/src/EvtGenModels/EvtRareLbToLll.cpp b/src/EvtGenModels/EvtRareLbToLll.cpp index a6a8081..121a02e 100644 --- a/src/EvtGenModels/EvtRareLbToLll.cpp +++ b/src/EvtGenModels/EvtRareLbToLll.cpp @@ -1,503 +1,506 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtRareLbToLll.hh" #include "EvtGenBase/EvtComplex.hh" #include "EvtGenBase/EvtDiracParticle.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtRaritaSchwinger.hh" #include "EvtGenBase/EvtSpinDensity.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include "EvtGenBase/EvtVector4R.hh" #include "EvtGenModels/EvtRareLbToLllFF.hh" #include "EvtGenModels/EvtRareLbToLllFFGutsche.hh" #include "EvtGenModels/EvtRareLbToLllFFlQCD.hh" #include // The module name specification std::string EvtRareLbToLll::getName() { return "RareLbToLll"; } // The implementation of the clone() method EvtDecayBase* EvtRareLbToLll::clone() { return new EvtRareLbToLll; } void EvtRareLbToLll::init() { - checkNArg( 1 ); + checkNArg( 0, 1 ); // check that there are 3 daughters checkNDaug( 3 ); // Parent should be spin 1/2 Lambda_b0 const EvtSpinType::spintype spin = EvtPDL::getSpinType( getDaug( 0 ) ); if ( !( spin == EvtSpinType::DIRAC || spin == EvtSpinType::RARITASCHWINGER ) ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " EvtRareLbToLll expects DIRAC or RARITASWINGER daughter " << std::endl; } // We expect that the second and third daughters // are the ell+ and ell- checkSpinDaughter( 1, EvtSpinType::DIRAC ); checkSpinDaughter( 2, EvtSpinType::DIRAC ); // Work out whether we have electron mode const EvtIdSet leptons{ "e-", "e+" }; if ( leptons.contains( getDaug( 1 ) ) ) { m_electronMode = true; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " EvtRareLbToLll has dielectron final state" << std::endl; } - std::string model = getArgStr( 0 ); + std::string model{ "LQCD" }; + if ( getNArg() == 1) { + model = getArgStr( 0 ); + } if ( model == "Gutsche" ) { ffmodel_ = std::make_unique(); } else if ( model == "LQCD" ) { ffmodel_ = std::make_unique(); } else if ( model == "MR" ) { ffmodel_ = std::make_unique(); } else { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " Unknown form-factor model, valid options are MR, LQCD, Gutsche." - << std::endl; - ::abort(); + << " Assuming LQCD form-factors... " << std::endl; + ffmodel_ = std::make_unique(); } wcmodel_ = std::make_unique(); ffmodel_->init(); return; } void EvtRareLbToLll::initProbMax() { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtRareLbToLll is finding maximum probability ... " << std::endl; m_maxProbability = 0; if ( m_maxProbability == 0 ) { EvtDiracParticle parent{}; parent.noLifeTime(); parent.init( getParentId(), EvtVector4R( EvtPDL::getMass( getParentId() ), 0, 0, 0 ) ); parent.setDiagonalSpinDensity(); EvtAmp amp; EvtId daughters[3] = {getDaug( 0 ), getDaug( 1 ), getDaug( 2 )}; amp.init( getParentId(), 3, daughters ); parent.makeDaughters( 3, daughters ); EvtParticle* lambda = parent.getDaug( 0 ); EvtParticle* lep1 = parent.getDaug( 1 ); EvtParticle* lep2 = parent.getDaug( 2 ); lambda->noLifeTime(); lep1->noLifeTime(); lep2->noLifeTime(); EvtSpinDensity rho; rho.setDiag( parent.getSpinStates() ); const double M0 = EvtPDL::getMass( getParentId() ); const double mL = EvtPDL::getMass( getDaug( 0 ) ); const double m1 = EvtPDL::getMass( getDaug( 1 ) ); const double m2 = EvtPDL::getMass( getDaug( 2 ) ); const double q2min = ( m1 + m2 ) * ( m1 + m2 ); const double q2max = ( M0 - mL ) * ( M0 - mL ); EvtVector4R p4lambda, p4lep1, p4lep2, boost; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtRareLbToLll is probing whole phase space ..." << std::endl; double prob = 0; const int nsteps = 5000; for ( int i = 0; i <= nsteps; i++ ) { const double q2 = q2min + i * ( q2max - q2min ) / nsteps; const double elambda = ( M0 * M0 + mL * mL - q2 ) / 2 / M0; double pstar{0}; if ( i != 0 ) { pstar = sqrt( q2 - ( m1 + m2 ) * ( m1 + m2 ) ) * sqrt( q2 - ( m1 - m2 ) * ( m1 - m2 ) ) / 2 / sqrt( q2 ); } boost.set( M0 - elambda, 0, 0, +sqrt( elambda * elambda - mL * mL ) ); if ( i != nsteps ) { p4lambda.set( elambda, 0, 0, -sqrt( elambda * elambda - mL * mL ) ); } else { p4lambda.set( mL, 0, 0, 0 ); } for ( int j = 0; j <= 45; j++ ) { const double theta = j * EvtConst::pi / 45; p4lep1.set( sqrt( pstar * pstar + m1 * m1 ), 0, +pstar * sin( theta ), +pstar * cos( theta ) ); p4lep2.set( sqrt( pstar * pstar + m2 * m2 ), 0, -pstar * sin( theta ), -pstar * cos( theta ) ); if ( i != nsteps) // At maximal q2 we are already in correct frame as Lambda and W/Zvirtual are at rest { p4lep1 = boostTo( p4lep1, boost ); p4lep2 = boostTo( p4lep2, boost ); } lambda->init( getDaug( 0 ), p4lambda ); lep1->init( getDaug( 1 ), p4lep1 ); lep2->init( getDaug( 2 ), p4lep2 ); calcAmp( amp, parent ); prob = rho.normalizedProb( amp.getSpinDensity() ); // In case of electron mode add pole if ( m_electronMode ) { prob /= 1.0 + m_poleSize / ( q2*q2 ); } if ( prob > m_maxProbability ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " - probability " << prob << " found at q2 = " << q2 << " (" << nsteps * ( q2 - q2min ) / ( q2max - q2min ) << " %) and theta = " << theta * 180 / EvtConst::pi << std::endl; m_maxProbability = prob; } } } m_maxProbability *= 1.05; } setProbMax( m_maxProbability ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << " EvtRareLbToLll set up maximum probability to " << m_maxProbability << std::endl; } void EvtRareLbToLll::decay( EvtParticle* parent ) { // Phase space initialization depends on what leptons are if ( m_electronMode ) { setWeight( parent->initializePhaseSpace( getNDaug(), getDaugs(), false, m_poleSize, 1, 2 ) ); } else { parent->initializePhaseSpace( getNDaug(), getDaugs() ); } calcAmp( _amp2, *parent ); } bool EvtRareLbToLll::isParticle( const EvtParticle& parent ) const { const EvtIdSet partlist{ "Lambda_b0" }; return partlist.contains( parent.getId() ); } void EvtRareLbToLll::calcAmp( EvtAmp& amp, const EvtParticle& parent ) { //parent->setDiagonalSpinDensity(); const EvtParticle* lambda = parent.getDaug( 0 ); const EvtIdSet leptons{ "e-", "mu-", "tau-" }; const bool isparticle = isParticle( parent ); const EvtParticle* lp = 0; const EvtParticle* lm = 0; if ( leptons.contains( parent.getDaug( 1 )->getId() ) ) { lp = parent.getDaug( 1 ); lm = parent.getDaug( 2 ); } else { lp = parent.getDaug( 2 ); lm = parent.getDaug( 1 ); } EvtVector4R P; P.set( parent.mass(), 0.0, 0.0, 0.0 ); EvtVector4R q = lp->getP4() + lm->getP4(); const double qsq = q.mass2(); // Leptonic currents EvtVector4C LV[2][2]; // \bar{\ell} \gamma^{\mu} \ell EvtVector4C LA[2][2]; // \bar{\ell} \gamma^{\mu} \gamma^{5} \ell for ( int i = 0; i < 2; ++i ) { for ( int j = 0; j < 2; ++j ) { if ( isparticle ) { LV[i][j] = EvtLeptonVCurrent( lp->spParent( i ), lm->spParent( j ) ); LA[i][j] = EvtLeptonACurrent( lp->spParent( i ), lm->spParent( j ) ); } else { LV[i][j] = EvtLeptonVCurrent( lp->spParent( 1 - i ), lm->spParent( 1 - j ) ); LA[i][j] = EvtLeptonACurrent( lp->spParent( 1 - i ), lm->spParent( 1 - j ) ); } } } EvtRareLbToLllFF::FormFactors FF; //F, G, FT and GT ffmodel_->getFF( parent, *lambda, FF ); EvtComplex C7eff = wcmodel_->GetC7Eff( qsq ); EvtComplex C9eff = wcmodel_->GetC9Eff( qsq ); EvtComplex C10eff = wcmodel_->GetC10Eff( qsq ); EvtComplex AC[4]; EvtComplex BC[4]; EvtComplex DC[4]; EvtComplex EC[4]; // check to see if particle is same or opposite parity to Lb const int parity = ffmodel_->isNatural( *lambda ) ? 1 : -1; // Lambda spin type const EvtSpinType::spintype spin = EvtPDL::getSpinType( lambda->getId() ); const double mb = 5.209; // Eq. 48 + 49 for ( unsigned int i = 0; i < 4; ++i ) { if ( parity > 0 ) { AC[i] = -2. * mb * C7eff * FF.FT_[i] / qsq + C9eff * FF.F_[i]; BC[i] = -2. * mb * C7eff * FF.GT_[i] / qsq - C9eff * FF.G_[i]; DC[i] = C10eff * FF.F_[i]; EC[i] = -C10eff * FF.G_[i]; } else { AC[i] = -2. * mb * C7eff * FF.GT_[i] / qsq - C9eff * FF.G_[i]; BC[i] = -2. * mb * C7eff * FF.FT_[i] / qsq + C9eff * FF.F_[i]; DC[i] = -C10eff * FF.G_[i]; EC[i] = C10eff * FF.F_[i]; } } // handle particle -> antiparticle in Hadronic currents const double cv = ( isparticle > 0 ) ? 1.0 : -1.0 * parity; const double ca = ( isparticle > 0 ) ? 1.0 : +1.0 * parity; const double cs = ( isparticle > 0 ) ? 1.0 : +1.0 * parity; const double cp = ( isparticle > 0 ) ? 1.0 : -1.0 * parity; if ( EvtSpinType::DIRAC == spin ) { EvtVector4C H1[2][2]; // vector current EvtVector4C H2[2][2]; // axial-vector EvtVector4C T[6]; // Hadronic currents for ( int i = 0; i < 2; ++i ) { for ( int j = 0; j < 2; ++j ) { HadronicAmp( parent, *lambda, T, i, j ); H1[i][j] = ( cv * AC[0] * T[0] + ca * BC[0] * T[1] + cs * AC[1] * T[2] + cp * BC[1] * T[3] + cs * AC[2] * T[4] + cp * BC[2] * T[5] ); H2[i][j] = ( cv * DC[0] * T[0] + ca * EC[0] * T[1] + cs * DC[1] * T[2] + cp * EC[1] * T[3] + cs * DC[2] * T[4] + cp * EC[2] * T[5] ); } } // Spin sums int spins[4]; for ( int i = 0; i < 2; ++i ) { for ( int ip = 0; ip < 2; ++ip ) { for ( int j = 0; j < 2; ++j ) { for ( int jp = 0; jp < 2; ++jp ) { spins[0] = i; spins[1] = ip; spins[2] = j; spins[3] = jp; EvtComplex M = H1[i][ip] * LV[j][jp] + H2[i][ip] * LA[j][jp]; amp.vertex( spins, M ); } } } } } else if ( EvtSpinType::RARITASCHWINGER == spin ) { EvtVector4C T[8]; EvtVector4C H1[2][4]; // vector current // swaped EvtVector4C H2[2][4]; // axial-vector // Build hadronic amplitude for ( int i = 0; i < 2; ++i ) { for ( int j = 0; j < 4; ++j ) { HadronicAmpRS( parent, *lambda, T, i, j ); H1[i][j] = ( cv * AC[0] * T[0] + ca * BC[0] * T[1] + cs * AC[1] * T[2] + cp * BC[1] * T[3] + cs * AC[2] * T[4] + cp * BC[2] * T[5] + cs * AC[3] * T[6] + cp * BC[3] * T[7] ); H2[i][j] = ( cv * DC[0] * T[0] + ca * EC[0] * T[1] + cs * DC[1] * T[2] + cp * EC[1] * T[3] + cs * DC[2] * T[4] + cp * EC[2] * T[5] + cs * DC[3] * T[6] + cp * EC[3] * T[7] ); } } // Spin sums int spins[4]; for ( int i = 0; i < 2; ++i ) { for ( int ip = 0; ip < 4; ++ip ) { for ( int j = 0; j < 2; ++j ) { for ( int jp = 0; jp < 2; ++jp ) { spins[0] = i; spins[1] = ip; spins[2] = j; spins[3] = jp; EvtComplex M = H1[i][ip] * LV[j][jp] + H2[i][ip] * LA[j][jp]; amp.vertex( spins, M ); } } } } } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << " EvtRareLbToLll expects DIRAC or RARITASWINGER daughter " << std::endl; } return; } // spin 1/2 daughters void EvtRareLbToLll::HadronicAmp( const EvtParticle& parent, const EvtParticle& lambda, EvtVector4C* T, const int i, const int j ) { const EvtDiracSpinor Sfinal = lambda.spParent( j ); const EvtDiracSpinor Sinit = parent.sp( i ); const EvtVector4R L = lambda.getP4(); EvtVector4R P; P.set( parent.mass(), 0.0, 0.0, 0.0 ); const double Pm = parent.mass(); const double Lm = lambda.mass(); // \bar{u} \gamma^{\mu} u T[0] = EvtLeptonVCurrent( Sfinal, Sinit ); // \bar{u} \gamma^{\mu}\gamma^{5} u T[1] = EvtLeptonACurrent( Sfinal, Sinit ); // \bar{u} v^{\mu} u T[2] = EvtLeptonSCurrent( Sfinal, Sinit ) * ( P / Pm ); // \bar{u} v^{\mu} \gamma^{5} u T[3] = EvtLeptonPCurrent( Sfinal, Sinit ) * ( P / Pm ); // \bar{u} v^{\prime\mu} u T[4] = EvtLeptonSCurrent( Sfinal, Sinit ) * ( L / Lm ); // \bar{u} v^{\prime\mu} \gamma^{5} T[5] = EvtLeptonPCurrent( Sfinal, Sinit ) * ( L / Lm ); // Where: // v = p_{\Lambda_b}/m_{\Lambda_b} // v^{\prime} = p_{\Lambda}/m_{\Lambda} return; } // spin 3/2 daughters void EvtRareLbToLll::HadronicAmpRS( const EvtParticle& parent, const EvtParticle& lambda, EvtVector4C* T, const int i, const int j ) { const EvtRaritaSchwinger Sfinal = lambda.spRSParent( j ); const EvtDiracSpinor Sinit = parent.sp( i ); EvtVector4R P; P.set( parent.mass(), 0.0, 0.0, 0.0 ); const EvtVector4R L = lambda.getP4(); EvtTensor4C ID; ID.setdiag( 1.0, 1.0, 1.0, 1.0 ); EvtDiracSpinor Sprime; for ( int i = 0; i < 4; i++ ) { Sprime.set_spinor( i, Sfinal.getVector( i ) * P ); } const double Pmsq = P.mass2(); const double Pm = parent.mass(); const double PmLm = Pm * lambda.mass(); EvtVector4C V1, V2; for ( int i = 0; i < 4; i++ ) { V1.set( i, EvtLeptonSCurrent( Sfinal.getSpinor( i ), Sinit ) ); V2.set( i, EvtLeptonPCurrent( Sfinal.getSpinor( i ), Sinit ) ); } // \bar{u}_{alpha} v^{\alpha} \gamma^{\mu} u T[0] = EvtLeptonVCurrent( Sprime, Sinit ) * ( 1 / Pm ); // \bar{u}_{alpha} v^{\alpha} \gamma^{\mu} \gamma^{5} u T[1] = EvtLeptonACurrent( Sprime, Sinit ) * ( 1 / Pm ); // \bar{u}_{\alpha} v^{\alpha} v^{\mu} u T[2] = EvtLeptonSCurrent( Sprime, Sinit ) * ( P / Pmsq ); // \bar{u}_{\alpha} v^{\alpha} v^{\mu} \gamma^{5} u T[3] = EvtLeptonPCurrent( Sprime, Sinit ) * ( P / Pmsq ); // \bar{u}_{\alpha} v^{\alpha} v^{\prime \mu} u T[4] = EvtLeptonSCurrent( Sprime, Sinit ) * ( L / PmLm ); // \bar{u}_{\alpha} v^{\alpha} v^{\prime \mu} \gamma^{5} u T[5] = EvtLeptonPCurrent( Sprime, Sinit ) * ( L / PmLm ); // \bar{u}_{\alpha} g^{\alpha\mu} u T[6] = ID.cont2( V1 ); // \bar{u}_{\alpha} g^{\alpha\mu} \gamma^{5} u T[7] = ID.cont2( V2 ); // Where: // v = p_{\Lambda_b}/m_{\Lambda_b} // v^{\prime} = p_{\Lambda}/m_{\Lambda} return; } diff --git a/src/EvtGenModels/EvtSSSCPT.cpp b/src/EvtGenModels/EvtSSSCPT.cpp index 7a2b351..d34b486 100644 --- a/src/EvtGenModels/EvtSSSCPT.cpp +++ b/src/EvtGenModels/EvtSSSCPT.cpp @@ -1,95 +1,104 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtSSSCPT.hh" #include "EvtGenBase/EvtCPUtil.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include #include std::string EvtSSSCPT::getName() { return "SSS_CPT"; } EvtDecayBase* EvtSSSCPT::clone() { return new EvtSSSCPT; } void EvtSSSCPT::init() { // check that there are 8 arguments checkNArg( 8 ); checkNDaug( 2 ); + + // Set amplitude coeffs + setAmpCoeffs(); +} + +void EvtSSSCPT::setAmpCoeffs() +{ + P = EvtComplex( cos( -getArg( 0 ) ), sin( -getArg( 0 ) ) ); + Q = EvtComplex( cos( getArg( 0 ) ), sin( getArg( 0 ) ) ); + D = EvtComplex( getArg( 6 ) * cos( getArg( 7 ) ), + getArg( 6 ) * sin( getArg( 7 ) ) ); + Im = EvtComplex( 0.0, 1.0 ); + + A = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ), + getArg( 2 ) * sin( getArg( 3 ) ) ); + Abar = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ), + getArg( 4 ) * sin( getArg( 5 ) ) ); +} + +void EvtSSSCPT::initProbMax() +{ + const double maxProb = 2.0 * abs2( A ) + 4.0 * abs2( Abar ) * abs2( D ); + setProbMax( maxProb ); } void EvtSSSCPT::decay( EvtParticle* p ) { //added by Lange Jan4,2000 static EvtId B0 = EvtPDL::getId( "B0" ); static EvtId B0B = EvtPDL::getId( "anti-B0" ); double t; EvtId other_b; EvtCPUtil::getInstance()->OtherB( p, t, other_b, 0.5 ); p->initializePhaseSpace( getNDaug(), getDaugs() ); EvtComplex amp; - EvtComplex A, Abar; - EvtComplex P, Q, D, Im; - - P = EvtComplex( cos( -getArg( 0 ) ), sin( -getArg( 0 ) ) ); - Q = EvtComplex( cos( getArg( 0 ) ), sin( getArg( 0 ) ) ); - D = EvtComplex( getArg( 6 ) * cos( getArg( 7 ) ), - getArg( 6 ) * sin( getArg( 7 ) ) ); - Im = EvtComplex( 0.0, 1.0 ); - - A = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ), - getArg( 2 ) * sin( getArg( 3 ) ) ); - Abar = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ), - getArg( 4 ) * sin( getArg( 5 ) ) ); - if ( other_b == B0B ) { amp = A * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + Im * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) * ( Q / P * A + 2.0 * D * Abar ); } if ( other_b == B0 ) { amp = Abar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + Im * sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) * ( P / Q * A - 2.0 * D * Abar ); } vertex( amp ); return; } diff --git a/src/EvtGenModels/EvtSSSCPpng.cpp b/src/EvtGenModels/EvtSSSCPpng.cpp index 3a94c53..850fb19 100644 --- a/src/EvtGenModels/EvtSSSCPpng.cpp +++ b/src/EvtGenModels/EvtSSSCPpng.cpp @@ -1,163 +1,167 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtSSSCPpng.hh" #include "EvtGenBase/EvtCPUtil.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include #include std::string EvtSSSCPpng::getName() { return "SSS_CP_PNG"; } EvtDecayBase* EvtSSSCPpng::clone() { return new EvtSSSCPpng; } void EvtSSSCPpng::init() { // check that there are 7 arguments checkNArg( 7 ); checkNDaug( 2 ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::SCALAR ); } void EvtSSSCPpng::initProbMax() { - setProbMax( getArg( 5 ) * getArg( 5 ) * ( 1 + getArg( 6 ) * getArg( 6 ) ) ); + const double ASq = getArg( 5 ) * getArg( 5 ) + getArg( 6 ) * getArg( 6 ); + const double max = ASq * ( 1.0 + getArg( 4 ) * getArg( 4 ) ); + setProbMax( max ); } void EvtSSSCPpng::decay( EvtParticle* p ) { //added by Lange Jan4,2000 static EvtId B0 = EvtPDL::getId( "B0" ); static EvtId B0B = EvtPDL::getId( "anti-B0" ); double t; EvtId other_b; p->initializePhaseSpace( getNDaug(), getDaugs() ); EvtComplex amp; EvtComplex A, Abar; //EvtComplex ACC, AbarCC; // assume single (top) quark dominance for the penguin. // old: a0=alpha, a1=dm, a2=1, a3=1, a4=0, a5=1, a6=0 // new: a0=beta, a1=gamma, a2=delta, a3=dm, a4=1, a5=1=A_{T}, a6=A_{P}/A_{T} // e.g., for B -> pi pi // A_{T} = |V_{ub} V_{ud}| T // A_{P} = |V_{tb} V_{td}| P // P and T are purely hadronic matrix elements // P/T = 0.055, A_{P}/A_{T} = 0.2 (see Marrocchesi and Paver, hep-ph/9702353) // A = A_{T}( exp(i(beta+gamma)) + (A_{P}/A_{T}) exp(i(delta)) // A_bar = same, except for the sign of the weak phases // here, delta = delta_{p}-delta_{t} (rel. strong phase) A = getArg( 5 ) * ( EvtComplex( cos( -getArg( 0 ) - getArg( 1 ) ), sin( -getArg( 0 ) - getArg( 1 ) ) ) + getArg( 6 ) * EvtComplex( cos( getArg( 2 ) ), sin( getArg( 2 ) ) ) ); Abar = getArg( 5 ) * ( EvtComplex( cos( getArg( 0 ) + getArg( 1 ) ), sin( getArg( 0 ) + getArg( 1 ) ) ) + getArg( 6 ) * EvtComplex( cos( getArg( 2 ) ), sin( getArg( 2 ) ) ) ); // get fraction of B0 tags with these amplitudes //double xd = 0.65; - double ratio = 1 / ( 1 + 0.65 * 0.65 ); + const double ratio = 1 / ( 1 + 0.65 * 0.65 ); EvtComplex rf, rbarf; rf = EvtComplex( cos( 2.0 * getArg( 0 ) ), sin( 2.0 * getArg( 0 ) ) ) * Abar / A; rbarf = EvtComplex( 1.0 ) / rf; - double A2 = real( A ) * real( A ) + imag( A ) * imag( A ); - double Abar2 = real( Abar ) * real( Abar ) + imag( Abar ) * imag( Abar ); + const double A2 = real( A ) * real( A ) + imag( A ) * imag( A ); + const double Abar2 = real( Abar ) * real( Abar ) + + imag( Abar ) * imag( Abar ); - double rf2 = real( rf ) * real( rf ) + imag( rf ) * imag( rf ); - double rbarf2 = real( rbarf ) * real( rbarf ) + imag( rbarf ) * imag( rbarf ); + const double rf2 = real( rf ) * real( rf ) + imag( rf ) * imag( rf ); + const double rbarf2 = real( rbarf ) * real( rbarf ) + + imag( rbarf ) * imag( rbarf ); //fraction of B0 _tags_ - double fract = ( Abar2 * ( 1 + rbarf2 + ( 1 - rbarf2 ) * ratio ) ) / - ( Abar2 * ( 1 + rbarf2 + ( 1 - rbarf2 ) * ratio ) + - A2 * ( 1 + rf2 + ( 1 - rf2 ) * ratio ) ); + const double fract = ( Abar2 * ( 1 + rbarf2 + ( 1 - rbarf2 ) * ratio ) ) / + ( Abar2 * ( 1 + rbarf2 + ( 1 - rbarf2 ) * ratio ) + + A2 * ( 1 + rf2 + ( 1 - rf2 ) * ratio ) ); EvtCPUtil::getInstance()->OtherB( p, t, other_b, fract ); //this method works just as well -- NK //randomly generate the tag (B0 or B0B) // double tag = EvtRandom::Flat(0.0,1.0); // if (tag < 0.5) { // // EvtCPUtil::OtherB(p,t,other_b,1.0); // other_b = B0; // } // else { // // EvtCPUtil::OtherB(p,t,other_b,0.0); // other_b = B0B; // } //mixing angle = -beta if ( other_b == B0B ) { amp = A * cos( getArg( 3 ) * t / ( 2 * EvtConst::c ) ) + EvtComplex( cos( 2.0 * getArg( 0 ) ), sin( 2.0 * getArg( 0 ) ) ) * getArg( 4 ) * EvtComplex( 0.0, 1.0 ) * Abar * sin( getArg( 3 ) * t / ( 2 * EvtConst::c ) ); } if ( other_b == B0 ) { amp = A * EvtComplex( cos( -2.0 * getArg( 0 ) ), sin( -2.0 * getArg( 0 ) ) ) * EvtComplex( 0.0, 1.0 ) * sin( getArg( 3 ) * t / ( 2 * EvtConst::c ) ) + getArg( 4 ) * Abar * cos( getArg( 3 ) * t / ( 2 * EvtConst::c ) ); } vertex( amp ); return; } diff --git a/src/EvtGenModels/EvtSVSCPiso.cpp b/src/EvtGenModels/EvtSVSCPiso.cpp index bf6e0e3..bdd3846 100644 --- a/src/EvtGenModels/EvtSVSCPiso.cpp +++ b/src/EvtGenModels/EvtSVSCPiso.cpp @@ -1,322 +1,274 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtSVSCPiso.hh" #include "EvtGenBase/EvtCPUtil.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtVector4C.hh" #include #include std::string EvtSVSCPiso::getName() { return "SVS_CP_ISO"; } EvtDecayBase* EvtSVSCPiso::clone() { return new EvtSVSCPiso; } void EvtSVSCPiso::init() { // check that there are 27 arguments checkNArg( 27 ); checkNDaug( 2 ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::VECTOR ); checkSpinDaughter( 1, EvtSpinType::SCALAR ); + + // Set amplitude coefficients + setAmpCoeffs(); + // Calculate amplitude terms + calcAmpTerms(); } -void EvtSVSCPiso::initProbMax() +void EvtSVSCPiso::setAmpCoeffs() { - //this might need some revision.. - - if ( ( EvtPDL::chg3( getDaug( 0 ) ) > 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) == 0 ) ) { - setProbMax( 2.0 * ( getArg( 3 ) * getArg( 3 ) + - 4.0 * getArg( 23 ) * getArg( 23 ) ) ); - } - - if ( ( EvtPDL::chg3( getDaug( 0 ) ) < 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) == 0 ) ) { - setProbMax( 2.0 * ( getArg( 5 ) * getArg( 5 ) + - 4.0 * getArg( 25 ) * getArg( 25 ) ) ); - } - - if ( ( EvtPDL::chg3( getDaug( 0 ) ) == 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) > 0 ) ) { - setProbMax( 2.0 * ( getArg( 7 ) * getArg( 7 ) + - 4.0 * getArg( 23 ) * getArg( 23 ) ) ); - } - - if ( ( EvtPDL::chg3( getDaug( 0 ) ) == 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) < 0 ) ) { - setProbMax( 2.0 * ( getArg( 9 ) * getArg( 9 ) + - 4.0 * getArg( 25 ) * getArg( 25 ) ) ); - } - - if ( ( EvtPDL::chg3( getDaug( 0 ) ) > 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) < 0 ) ) { - setProbMax( - 2.0 * ( getArg( 11 ) * getArg( 11 ) + getArg( 23 ) * getArg( 23 ) + - getArg( 19 ) * getArg( 19 ) + getArg( 13 ) * getArg( 13 ) + - getArg( 25 ) * getArg( 25 ) + getArg( 21 ) * getArg( 21 ) ) ); - } - - if ( ( EvtPDL::chg3( getDaug( 0 ) ) < 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) > 0 ) ) { - setProbMax( - 2.0 * ( getArg( 15 ) * getArg( 15 ) + getArg( 23 ) * getArg( 23 ) + - getArg( 19 ) * getArg( 19 ) + getArg( 17 ) * getArg( 17 ) + - getArg( 25 ) * getArg( 25 ) + getArg( 21 ) * getArg( 21 ) ) ); - } + Tp0 = EvtComplex( getArg( 3 ) * cos( getArg( 4 ) ), + getArg( 3 ) * sin( getArg( 4 ) ) ); + Tp0_bar = EvtComplex( getArg( 5 ) * cos( getArg( 6 ) ), + getArg( 5 ) * sin( getArg( 6 ) ) ); + T0p = EvtComplex( getArg( 7 ) * cos( getArg( 8 ) ), + getArg( 7 ) * sin( getArg( 8 ) ) ); + T0p_bar = EvtComplex( getArg( 9 ) * cos( getArg( 10 ) ), + getArg( 9 ) * sin( getArg( 10 ) ) ); + Tpm = EvtComplex( getArg( 11 ) * cos( getArg( 12 ) ), + getArg( 11 ) * sin( getArg( 12 ) ) ); + Tpm_bar = EvtComplex( getArg( 13 ) * cos( getArg( 14 ) ), + getArg( 13 ) * sin( getArg( 14 ) ) ); + Tmp = EvtComplex( getArg( 15 ) * cos( getArg( 16 ) ), + getArg( 15 ) * sin( getArg( 16 ) ) ); + Tmp_bar = EvtComplex( getArg( 17 ) * cos( getArg( 18 ) ), + getArg( 17 ) * sin( getArg( 18 ) ) ); + P0 = EvtComplex( getArg( 19 ) * cos( getArg( 20 ) ), + getArg( 19 ) * sin( getArg( 20 ) ) ); + P0_bar = EvtComplex( getArg( 21 ) * cos( getArg( 22 ) ), + getArg( 21 ) * sin( getArg( 22 ) ) ); + P1 = EvtComplex( getArg( 23 ) * cos( getArg( 24 ) ), + getArg( 23 ) * sin( getArg( 24 ) ) ); + P1_bar = EvtComplex( getArg( 25 ) * cos( getArg( 26 ) ), + getArg( 25 ) * sin( getArg( 26 ) ) ); +} - if ( ( EvtPDL::chg3( getDaug( 0 ) ) == 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) == 0 ) ) { - setProbMax( - 2.0 * ( getArg( 7 ) * getArg( 7 ) + getArg( 3 ) * getArg( 3 ) + - getArg( 11 ) * getArg( 11 ) + getArg( 15 ) * getArg( 15 ) + - 4.0 * getArg( 19 ) * getArg( 19 ) + - getArg( 9 ) * getArg( 9 ) + getArg( 5 ) * getArg( 5 ) + - getArg( 13 ) * getArg( 13 ) + getArg( 17 ) * getArg( 17 ) + - 4.0 * getArg( 21 ) * getArg( 21 ) ) ); - } +void EvtSVSCPiso::initProbMax() +{ + const double max1 = abs2( A_f ) + abs2( Abar_f ); + const double max2 = abs2( A_fbar ) + abs2( Abar_fbar ); + // Amplitude has momentum normalisation that roughly scales with (parent mass)/2 + // so probability will scale with 0.25 * parenMassSq. Use 0.3 * parMassSq + // in case we get larger normalisation values + const double parMass = EvtPDL::getMeanMass( getParentId() ); + const double max = 0.3 * parMass * parMass * ( max1 + max2 ); + setProbMax( max ); } void EvtSVSCPiso::decay( EvtParticle* p ) { //added by Lange Jan4,2000 static EvtId B0 = EvtPDL::getId( "B0" ); static EvtId B0B = EvtPDL::getId( "anti-B0" ); double t; EvtId other_b; - int charged( 0 ); int first_time = 0; int flip = 0; EvtId ds[2]; - //randomly generate the tag (B0 or B0B) - - double tag = EvtRandom::Flat( 0.0, 1.0 ); + // Randomly generate the tag (B0 or B0B) + const double tag = EvtRandom::Flat( 0.0, 1.0 ); if ( tag < 0.5 ) { EvtCPUtil::getInstance()->OtherB( p, t, other_b, 1.0 ); other_b = B0; } else { EvtCPUtil::getInstance()->OtherB( p, t, other_b, 0.0 ); other_b = B0B; } if ( p->getNDaug() == 0 ) first_time = 1; if ( first_time ) { if ( EvtRandom::Flat( 0.0, 1.0 ) < getArg( 2 ) ) flip = 1; } else { if ( getDaug( 0 ) != p->getDaug( 0 )->getId() ) flip = 1; } if ( !flip ) { ds[0] = getDaug( 0 ); ds[1] = getDaug( 1 ); } else { ds[0] = EvtPDL::chargeConj( getDaug( 0 ) ); ds[1] = EvtPDL::chargeConj( getDaug( 1 ) ); } p->initializePhaseSpace( getNDaug(), ds ); EvtParticle *v, *s; v = p->getDaug( 0 ); s = p->getDaug( 1 ); EvtComplex amp; - EvtComplex A_f, Abar_f; - EvtComplex A_fbar, Abar_fbar; - EvtComplex Apm, Apm_bar, Amp, Amp_bar; + if ( charged == 0 ) { + if ( !flip ) { + if ( other_b == B0B ) { + amp = A_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + + EvtComplex( cos( -2.0 * getArg( 0 ) ), + sin( -2.0 * getArg( 0 ) ) ) * + EvtComplex( 0.0, 1.0 ) * Abar_f * + sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); + } + if ( other_b == B0 ) { + amp = A_f * + EvtComplex( cos( 2.0 * getArg( 0 ) ), + sin( 2.0 * getArg( 0 ) ) ) * + EvtComplex( 0.0, 1.0 ) * + sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + + Abar_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); + } + } else { + if ( other_b == B0B ) { + amp = A_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + + EvtComplex( cos( -2.0 * getArg( 0 ) ), + sin( -2.0 * getArg( 0 ) ) ) * + EvtComplex( 0.0, 1.0 ) * Abar_fbar * + sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); + } + if ( other_b == B0 ) { + amp = A_fbar * + EvtComplex( cos( 2.0 * getArg( 0 ) ), + sin( 2.0 * getArg( 0 ) ) ) * + EvtComplex( 0.0, 1.0 ) * + sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + + Abar_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); + } + } - EvtComplex Tp0, Tp0_bar, T0p, T0p_bar, Tpm, Tpm_bar, Tmp, Tmp_bar; - EvtComplex P1, P1_bar, P0, P0_bar; + } else { + amp = A_f; + } - Tp0 = EvtComplex( getArg( 3 ) * cos( getArg( 4 ) ), - getArg( 3 ) * sin( getArg( 4 ) ) ); - Tp0_bar = EvtComplex( getArg( 5 ) * cos( getArg( 6 ) ), - getArg( 5 ) * sin( getArg( 6 ) ) ); - T0p = EvtComplex( getArg( 7 ) * cos( getArg( 8 ) ), - getArg( 7 ) * sin( getArg( 8 ) ) ); - T0p_bar = EvtComplex( getArg( 9 ) * cos( getArg( 10 ) ), - getArg( 9 ) * sin( getArg( 10 ) ) ); - Tpm = EvtComplex( getArg( 11 ) * cos( getArg( 12 ) ), - getArg( 11 ) * sin( getArg( 12 ) ) ); - Tpm_bar = EvtComplex( getArg( 13 ) * cos( getArg( 14 ) ), - getArg( 13 ) * sin( getArg( 14 ) ) ); - Tmp = EvtComplex( getArg( 15 ) * cos( getArg( 16 ) ), - getArg( 15 ) * sin( getArg( 16 ) ) ); - Tmp_bar = EvtComplex( getArg( 17 ) * cos( getArg( 18 ) ), - getArg( 17 ) * sin( getArg( 18 ) ) ); - P0 = EvtComplex( getArg( 19 ) * cos( getArg( 20 ) ), - getArg( 19 ) * sin( getArg( 20 ) ) ); - P0_bar = EvtComplex( getArg( 21 ) * cos( getArg( 22 ) ), - getArg( 21 ) * sin( getArg( 22 ) ) ); - P1 = EvtComplex( getArg( 23 ) * cos( getArg( 24 ) ), - getArg( 23 ) * sin( getArg( 24 ) ) ); - P1_bar = EvtComplex( getArg( 25 ) * cos( getArg( 26 ) ), - getArg( 25 ) * sin( getArg( 26 ) ) ); + const EvtVector4R p4_parent = v->getP4() + s->getP4(); + const double norm = 1.0 / v->getP4().d3mag(); + + vertex( 0, amp * norm * p4_parent * ( v->epsParent( 0 ) ) ); + vertex( 1, amp * norm * p4_parent * ( v->epsParent( 1 ) ) ); + vertex( 2, amp * norm * p4_parent * ( v->epsParent( 2 ) ) ); + + return; +} + +void EvtSVSCPiso::calcAmpTerms() +{ + const int Q1 = EvtPDL::chg3( getDaug( 0 ) ); + const int Q2 = EvtPDL::chg3( getDaug( 1 ) ); //***********************charged modes**************************** - if ( ( EvtPDL::chg3( getDaug( 0 ) ) > 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) == 0 ) ) { + if ( Q1 > 0 && Q2 == 0 ) { //V+ S0, so T+0 + 2 P1 charged = 1; A_f = Tp0 + 2.0 * P1; } - if ( ( EvtPDL::chg3( getDaug( 0 ) ) < 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) == 0 ) ) { + if ( Q1 < 0 && Q2 == 0 ) { //V- S0, so T+0_bar + 2P1_bar charged = 1; A_f = Tp0_bar + 2.0 * P1_bar; } - if ( ( EvtPDL::chg3( getDaug( 0 ) ) == 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) > 0 ) ) { + if ( Q1 == 0 && Q2 > 0 ) { //V0 S+, so T0+ - 2 P1 charged = 1; A_f = T0p - 2.0 * P1; } - if ( ( EvtPDL::chg3( getDaug( 0 ) ) == 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) < 0 ) ) { + if ( Q1 == 0 && Q2 < 0 ) { //V0 S-, so T0+_bar - 2 P1_bar charged = 1; A_f = T0p_bar - 2.0 * P1_bar; } //***********************neutral modes*************************** //V+ S-, so Af = T+- + P1 + P0 Apm = Tpm + P1 + P0; Apm_bar = Tpm_bar + P1_bar + P0_bar; //V- S+, so Af = T-+ - P1 + P0 Amp = Tmp - P1 + P0; Amp_bar = Tmp_bar - P1_bar + P0; - if ( ( EvtPDL::chg3( getDaug( 0 ) ) > 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) < 0 ) ) { + if ( Q1 > 0 && Q2 < 0 ) { //V+ S- charged = 0; A_f = Apm; Abar_f = Apm_bar; A_fbar = Amp; Abar_fbar = Amp_bar; } - if ( ( EvtPDL::chg3( getDaug( 0 ) ) < 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) > 0 ) ) { + if ( Q1 < 0 && Q2 > 0 ) { //V- S+ charged = 0; A_f = Amp; Abar_f = Amp_bar; A_fbar = Apm; Abar_fbar = Apm_bar; } - if ( ( EvtPDL::chg3( getDaug( 0 ) ) == 0 ) && - ( EvtPDL::chg3( getDaug( 1 ) ) == 0 ) ) { + if ( Q1 == 0 && Q2 == 0 ) { //V0 S0 charged = 0; A_f = T0p + Tp0 - Tpm - Tmp - 2.0 * P0; Abar_f = T0p_bar + Tp0_bar - Tpm_bar - Tmp_bar - 2.0 * P0_bar; A_fbar = A_f; Abar_fbar = Abar_f; } - - if ( charged == 0 ) { - if ( !flip ) { - if ( other_b == B0B ) { - amp = A_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + - EvtComplex( cos( -2.0 * getArg( 0 ) ), - sin( -2.0 * getArg( 0 ) ) ) * - EvtComplex( 0.0, 1.0 ) * Abar_f * - sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); - } - if ( other_b == B0 ) { - amp = A_f * - EvtComplex( cos( 2.0 * getArg( 0 ) ), - sin( 2.0 * getArg( 0 ) ) ) * - EvtComplex( 0.0, 1.0 ) * - sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + - Abar_f * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); - } - } else { - if ( other_b == B0B ) { - amp = A_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + - EvtComplex( cos( -2.0 * getArg( 0 ) ), - sin( -2.0 * getArg( 0 ) ) ) * - EvtComplex( 0.0, 1.0 ) * Abar_fbar * - sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); - } - if ( other_b == B0 ) { - amp = A_fbar * - EvtComplex( cos( 2.0 * getArg( 0 ) ), - sin( 2.0 * getArg( 0 ) ) ) * - EvtComplex( 0.0, 1.0 ) * - sin( getArg( 1 ) * t / ( 2 * EvtConst::c ) ) + - Abar_fbar * cos( getArg( 1 ) * t / ( 2 * EvtConst::c ) ); - } - } - - } else - amp = A_f; - - EvtVector4R p4_parent; - - p4_parent = v->getP4() + s->getP4(); - - double norm = 1.0 / v->getP4().d3mag(); - - vertex( 0, amp * norm * p4_parent * ( v->epsParent( 0 ) ) ); - vertex( 1, amp * norm * p4_parent * ( v->epsParent( 1 ) ) ); - vertex( 2, amp * norm * p4_parent * ( v->epsParent( 2 ) ) ); - - return; } diff --git a/src/EvtGenModels/EvtSVVHelCPMix.cpp b/src/EvtGenModels/EvtSVVHelCPMix.cpp index e383da3..43e6993 100644 --- a/src/EvtGenModels/EvtSVVHelCPMix.cpp +++ b/src/EvtGenModels/EvtSVVHelCPMix.cpp @@ -1,304 +1,294 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtSVVHelCPMix.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtId.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtTensor3C.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector3C.hh" #include "EvtGenBase/EvtVector3R.hh" #include "EvtGenBase/EvtVector4C.hh" #include #include #include #include #include std::string EvtSVVHelCPMix::getName() { return "SVVHELCPMIX"; } EvtDecayBase* EvtSVVHelCPMix::clone() { return new EvtSVVHelCPMix; } void EvtSVVHelCPMix::init() { // check that there are 12 arguments checkNArg( 12 ); checkNDaug( 2 ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::VECTOR ); checkSpinDaughter( 1, EvtSpinType::VECTOR ); hp = EvtComplex( getArg( 0 ) * cos( getArg( 1 ) ), getArg( 0 ) * sin( getArg( 1 ) ) ); h0 = EvtComplex( getArg( 2 ) * cos( getArg( 3 ) ), getArg( 2 ) * sin( getArg( 3 ) ) ); hm = EvtComplex( getArg( 4 ) * cos( getArg( 5 ) ), getArg( 4 ) * sin( getArg( 5 ) ) ); averageM = getArg( 6 ); deltaM = getArg( 7 ); gamma = getArg( 8 ); deltagamma = getArg( 9 ); weakmixingphase = EvtComplex( cos( getArg( 10 ) ), sin( getArg( 10 ) ) ); weakdirectphase = EvtComplex( cos( getArg( 11 ) ), sin( getArg( 11 ) ) ); } void EvtSVVHelCPMix::initProbMax() { setProbMax( getArg( 0 ) * getArg( 0 ) + getArg( 2 ) * getArg( 2 ) + getArg( 4 ) * getArg( 4 ) ); } void EvtSVVHelCPMix::decay( EvtParticle* p ) { EvtParticle* parent = p; EvtAmp& amp = _amp2; EvtId n_v1 = getDaug( 0 ); EvtId n_v2 = getDaug( 1 ); // Routine to decay a vector into a vector and scalar. Started // by ryd on Oct 17, 1996. // Modified by J.Catmore to take account of CP-violation and mixing int tndaug = 2; EvtId tdaug[2]; EvtId Bs = EvtPDL::getId( "B_s0" ); EvtId antiBs = EvtPDL::getId( "anti-B_s0" ); tdaug[0] = n_v1; tdaug[1] = n_v2; // Phase space and kinematics parent->initializePhaseSpace( tndaug, tdaug ); EvtParticle *v1, *v2; v1 = parent->getDaug( 0 ); v2 = parent->getDaug( 1 ); EvtVector4R momv1 = v1->getP4(); EvtVector3R v1dir( momv1.get( 1 ), momv1.get( 2 ), momv1.get( 3 ) ); v1dir = v1dir / v1dir.d3mag(); // Definition of quantities used in construction of complex amplitudes: EvtTensor3C M; // Tensor as defined in EvtGen manual, equ 117 EvtComplex a, b, c; // Helicity amplitudes; EvtGen manual eqns 126-128, also see Phys Lett B 369 p144-150 eqn 15 //EvtComplex deltamu = EvtComplex(deltaM, -0.5*deltagamma); // See Phys Rev D 34 p1404 // conversion from times in mm/c to natural units [GeV]^-1 double t = ( ( parent->getLifetime() ) / 2.998e11 ) * 6.58e-25; // The following two quantities defined in Phys Rev D 34 p1404 EvtComplex fplus = EvtComplex( cos( averageM * t ), -1. * sin( averageM * t ) ) * exp( -( gamma / 2.0 ) * t ) * ( cos( 0.5 * deltaM * t ) * cosh( 0.25 * deltagamma * t ) + EvtComplex( 0.0, sin( 0.5 * deltaM * t ) * sinh( 0.25 * deltagamma * t ) ) ); EvtComplex fminus = EvtComplex( cos( averageM * t ), -1. * sin( averageM * t ) ) * exp( -( gamma / 2.0 ) * t ) * EvtComplex( 0.0, 1.0 ) * ( sin( 0.5 * deltaM * t ) * cosh( 0.25 * deltagamma * t ) - EvtComplex( 0.0, 1.0 ) * sinh( 0.25 * deltagamma * t ) * cos( 0.5 * deltaM * t ) ); // See EvtGen manual pp 106-107 a = -0.5 * ( hp + hm ); b = EvtComplex( 0.0, 0.5 ) * ( hp - hm ); c = ( h0 + 0.5 * ( hp + hm ) ); M = a * EvtTensor3C::id() + b * EvtGenFunctions::eps( v1dir ) + c * EvtGenFunctions::directProd( v1dir, v1dir ); EvtVector3C t0 = M.cont1( v1->eps( 0 ).vec().conj() ); EvtVector3C t1 = M.cont1( v1->eps( 1 ).vec().conj() ); EvtVector3C t2 = M.cont1( v1->eps( 2 ).vec().conj() ); EvtVector3C eps0 = v2->eps( 0 ).vec().conj(); EvtVector3C eps1 = v2->eps( 1 ).vec().conj(); EvtVector3C eps2 = v2->eps( 2 ).vec().conj(); // We need two sets of equations, one for mesons which were in the Bs state at t=0, and another // for those which were in the antiBs state. Each equation consists of a sum of amplitudes - mod-squaring gives the interference terms. EvtComplex amplSum00, amplSum01, amplSum02; EvtComplex amplSum10, amplSum11, amplSum12; EvtComplex amplSum20, amplSum21, amplSum22; // First the Bs state: if ( parent->getId() == Bs ) { amplSum00 = ( fplus * weakdirectphase * t0 * eps0 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t0 * eps0 ); amplSum01 = ( fplus * weakdirectphase * t0 * eps1 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t0 * eps1 ); amplSum02 = ( fplus * weakdirectphase * t0 * eps2 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t0 * eps2 ); amplSum10 = ( fplus * weakdirectphase * t1 * eps0 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t1 * eps0 ); amplSum11 = ( fplus * weakdirectphase * t1 * eps1 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t1 * eps1 ); amplSum12 = ( fplus * weakdirectphase * t1 * eps2 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t1 * eps2 ); amplSum20 = ( fplus * weakdirectphase * t2 * eps0 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t2 * eps0 ); amplSum21 = ( fplus * weakdirectphase * t2 * eps1 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t2 * eps1 ); amplSum22 = ( fplus * weakdirectphase * t2 * eps2 ) + ( fminus * ( 1.0 / weakdirectphase ) * weakmixingphase * t2 * eps2 ); } // Now the anti-Bs state: if ( parent->getId() == antiBs ) { amplSum00 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t0 * eps0 ) + ( fplus * ( 1.0 / weakdirectphase ) * t0 * eps0 ); amplSum01 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t0 * eps1 ) + ( fplus * ( 1.0 / weakdirectphase ) * t0 * eps1 ); amplSum02 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t0 * eps2 ) + ( fplus * ( 1.0 / weakdirectphase ) * t0 * eps2 ); amplSum10 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t1 * eps0 ) + ( fplus * ( 1.0 / weakdirectphase ) * t1 * eps0 ); amplSum11 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t1 * eps1 ) + ( fplus * ( 1.0 / weakdirectphase ) * t1 * eps1 ); amplSum12 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t1 * eps2 ) + ( fplus * ( 1.0 / weakdirectphase ) * t1 * eps2 ); amplSum20 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t2 * eps0 ) + ( fplus * ( 1.0 / weakdirectphase ) * t2 * eps0 ); amplSum21 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t2 * eps1 ) + ( fplus * ( 1.0 / weakdirectphase ) * t2 * eps1 ); amplSum22 = ( fminus * weakdirectphase * ( 1.0 / weakmixingphase ) * t2 * eps2 ) + ( fplus * ( 1.0 / weakdirectphase ) * t2 * eps2 ); } - // Now set the amplitude - + // Now set the amplitudes amp.vertex( 0, 0, amplSum00 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "00: " << amplSum00 << std::endl; amp.vertex( 0, 1, amplSum01 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "01: " << amplSum01 << std::endl; amp.vertex( 0, 2, amplSum02 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "02: " << amplSum02 << std::endl; amp.vertex( 1, 0, amplSum10 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "10: " << amplSum10 << std::endl; amp.vertex( 1, 1, amplSum11 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "11: " << amplSum11 << std::endl; amp.vertex( 1, 2, amplSum12 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "12: " << amplSum12 << std::endl; amp.vertex( 2, 0, amplSum20 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "20: " << amplSum20 << std::endl; amp.vertex( 2, 1, amplSum21 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "21: " << amplSum21 << std::endl; amp.vertex( 2, 2, amplSum22 ); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "22: " << amplSum22 << std::endl; return; } std::string EvtSVVHelCPMix::getParamName( int i ) { switch ( i ) { case 0: return "plusHelAmp"; case 1: return "plusHelAmpPhase"; case 2: return "zeroHelAmp"; case 3: return "zeroHelAmpPhase"; case 4: return "minusHelAmp"; case 5: return "minusHelAmpPhase"; case 6: return "averageM"; case 7: return "deltaM"; case 8: return "gamma"; case 9: return "deltaGamma"; case 10: return "weakMixPhase"; case 11: return "weakDirectPhase"; default: return ""; } } std::string EvtSVVHelCPMix::getParamDefault( int i ) { switch ( i ) { case 0: return "1.0"; case 1: return "0.0"; case 2: return "1.0"; case 3: return "0.0"; case 4: return "1.0"; case 5: return "0.0"; default: return ""; } } diff --git a/src/EvtGenModels/EvtSingleParticle.cpp b/src/EvtGenModels/EvtSingleParticle.cpp index d4eed40..8ef0114 100644 --- a/src/EvtGenModels/EvtSingleParticle.cpp +++ b/src/EvtGenModels/EvtSingleParticle.cpp @@ -1,141 +1,146 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtSingleParticle.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include #include using std::endl; std::string EvtSingleParticle::getName() { return "SINGLE"; } EvtDecayBase* EvtSingleParticle::clone() { return new EvtSingleParticle(); } +void EvtSingleParticle::initProbMax() +{ + noProbMax(); +} + void EvtSingleParticle::init() { //turn off checks for charge conservation disableCheckQ(); if ( ( getNArg() == 6 ) || ( getNArg() == 4 ) || ( getNArg() == 2 ) ) { if ( getNArg() == 6 ) { //copy the arguments into eaiser to remember names! pmin = getArg( 0 ); pmax = getArg( 1 ); cthetamin = getArg( 2 ); cthetamax = getArg( 3 ); phimin = getArg( 4 ); phimax = getArg( 5 ); } if ( getNArg() == 4 ) { //copy the arguments into eaiser to remember names! pmin = getArg( 0 ); pmax = getArg( 1 ); cthetamin = getArg( 2 ); cthetamax = getArg( 3 ); phimin = 0.0; phimax = EvtConst::twoPi; } if ( getNArg() == 2 ) { //copy the arguments into eaiser to remember names! pmin = getArg( 0 ); pmax = getArg( 1 ); cthetamin = -1.0; cthetamax = 1.0; phimin = 0.0; phimax = EvtConst::twoPi; } } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtSingleParticle generator expected " << " 6, 4, or 2 arguments but found:" << getNArg() << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate execution!" << endl; ::abort(); } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "The single particle generator has been configured:" << endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << pmax << " > p > " << pmin << endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << cthetamax << " > costheta > " << cthetamin << endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << phimax << " > phi > " << phimin << endl; } void EvtSingleParticle::decay( EvtParticle* p ) { EvtParticle* d; EvtVector4R p4; double mass = EvtPDL::getMass( getDaug( 0 ) ); p->makeDaughters( getNDaug(), getDaugs() ); d = p->getDaug( 0 ); //generate flat distribution in p //we are now in the parents restframe! This means the //restframe of the e+e- collison. double pcm = EvtRandom::Flat( pmin, pmax ); //generate flat distribution in phi. double phi = EvtRandom::Flat( phimin, phimax ); double cthetalab; do { //generate flat distribution in costheta double ctheta = EvtRandom::Flat( cthetamin, cthetamax ); double stheta = sqrt( 1.0 - ctheta * ctheta ); p4.set( sqrt( mass * mass + pcm * pcm ), pcm * cos( phi ) * stheta, pcm * sin( phi ) * stheta, pcm * ctheta ); d->init( getDaug( 0 ), p4 ); //get 4 vector in the lab frame! EvtVector4R p4lab = d->getP4Lab(); cthetalab = p4lab.get( 3 ) / p4lab.d3mag(); } while ( cthetalab > cthetamax || cthetalab < cthetamin ); return; } diff --git a/src/EvtGenModels/EvtSll.cpp b/src/EvtGenModels/EvtSll.cpp index cecb16c..f94fb1d 100644 --- a/src/EvtGenModels/EvtSll.cpp +++ b/src/EvtGenModels/EvtSll.cpp @@ -1,80 +1,115 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtSll.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtVector4C.hh" #include #include #include std::string EvtSll::getName() { return "SLL"; } EvtDecayBase* EvtSll::clone() { return new EvtSll; } void EvtSll::init() { // check that there are 0 arguments checkNArg( 0 ); checkNDaug( 2 ); checkSpinParent( EvtSpinType::SCALAR ); checkSpinDaughter( 0, EvtSpinType::DIRAC ); checkSpinDaughter( 1, EvtSpinType::DIRAC ); } +void EvtSll::initProbMax() +{ + const int eID = abs( EvtPDL::getStdHep( EvtPDL::getId( "e-" ) ) ); + const int muID = abs( EvtPDL::getStdHep( EvtPDL::getId( "mu-" ) ) ); + const int tauID = abs( EvtPDL::getStdHep( EvtPDL::getId( "tau-" ) ) ); + + const int lep1 = abs( EvtPDL::getStdHep( getDaug( 0 ) ) ); + const int lep2 = abs( EvtPDL::getStdHep( getDaug( 1 ) ) ); + + // tau tau mode + double maxProb{ 1000.0 }; + + // Modify probability based on lepton pair (including lepton violation modes) + if ( ( lep1 == tauID && lep2 == muID ) || ( lep1 == muID && lep2 == tauID ) ) { + // tau mu or mu tau + maxProb = 400.0; + } else if ( ( lep1 == tauID && lep2 == eID ) || + ( lep1 == eID && lep2 == tauID ) ) { + // tau e or e tau + maxProb = 400.0; + } else if ( lep1 == muID && lep2 == muID ) { + // mu mu + maxProb = 4.0; + } else if ( ( lep1 == muID && lep2 == eID ) || + ( lep1 == eID && lep2 == muID ) ) { + // mu e or e mu + maxProb = 2.0; + } else if ( lep1 == eID && lep2 == eID ) { + // e e + maxProb = 1e-4; + } + + setProbMax( maxProb ); +} + void EvtSll::decay( EvtParticle* p ) { p->initializePhaseSpace( getNDaug(), getDaugs() ); EvtParticle *l1, *l2; l1 = p->getDaug( 0 ); l2 = p->getDaug( 1 ); EvtVector4R p4_p; p4_p.set( p->mass(), 0.0, 0.0, 0.0 ); EvtVector4C l11, l12, l21, l22; l11 = EvtLeptonVACurrent( l1->spParent( 0 ), l2->spParent( 0 ) ); l12 = EvtLeptonVACurrent( l1->spParent( 0 ), l2->spParent( 1 ) ); l21 = EvtLeptonVACurrent( l1->spParent( 1 ), l2->spParent( 0 ) ); l22 = EvtLeptonVACurrent( l1->spParent( 1 ), l2->spParent( 1 ) ); vertex( 0, 0, p4_p * l11 ); vertex( 0, 1, p4_p * l12 ); vertex( 1, 0, p4_p * l21 ); vertex( 1, 1, p4_p * l22 ); return; } diff --git a/src/EvtGenModels/EvtTVP.cpp b/src/EvtGenModels/EvtTVP.cpp index 91c962d..a55650a 100644 --- a/src/EvtGenModels/EvtTVP.cpp +++ b/src/EvtGenModels/EvtTVP.cpp @@ -1,216 +1,216 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtTVP.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtSpinType.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include std::string EvtTVP::getName() { return "TVP"; } EvtDecayBase* EvtTVP::clone() { return new EvtTVP; } void EvtTVP::decay( EvtParticle* root ) { if ( getNDaug() == 2 ) { decay_2body( root ); } else if ( getNDaug() == 3 ) { decay_3body( root ); } } void EvtTVP::init() { checkSpinParent( EvtSpinType::TENSOR ); if ( getNDaug() == 2 ) { // chi -> gamma psi radiative mode checkNArg( 0 ); checkSpinDaughter( 0, EvtSpinType::PHOTON ); checkSpinDaughter( 1, EvtSpinType::VECTOR ); } else if ( getNDaug() == 3 ) { // chi -> psi lepton lepton checkNDaug( 3 ); checkSpinDaughter( 0, EvtSpinType::VECTOR ); checkSpinDaughter( 1, EvtSpinType::DIRAC ); checkSpinDaughter( 2, EvtSpinType::DIRAC ); checkNArg( 1 ); delta = getArg( 0 ); } } void EvtTVP::initProbMax() { if ( getNDaug() == 2 ) { const EvtId parId = getParentId(); if ( parId == EvtPDL::getId( "chi_b2" ) ) { setProbMax( 15.0 ); } else { - setProbMax( 2.0 ); + setProbMax( 2.5 ); } } else if ( getNDaug() == 3 ) { double dSq = delta * delta; double denom = dSq - 0.2; double ratio( 1.0 ); if ( fabs( denom ) > 1e-10 ) { ratio = dSq / denom; } double ffCor = ratio * ratio; const EvtId daugId = getDaug( 1 ); const EvtId parId = getParentId(); if ( daugId == EvtPDL::getId( "mu+" ) || daugId == EvtPDL::getId( "mu-" ) ) { if ( parId == EvtPDL::getId( "chi_c2" ) ) { setProbMax( ffCor * 85.0 ); // tested on 1e6 events } else if ( parId == EvtPDL::getId( "chi_b2" ) ) { setProbMax( ffCor * 750.0 ); // tested on 1e6 events } } else if ( daugId == EvtPDL::getId( "e+" ) || daugId == EvtPDL::getId( "e-" ) ) { if ( parId == EvtPDL::getId( "chi_c2" ) ) { setProbMax( ffCor * 3.5e3 ); // tested on 1e5 events } else if ( parId == EvtPDL::getId( "chi_b2" ) ) { setProbMax( ffCor * 2.6e4 ); } } } } void EvtTVP::decay_2body( EvtParticle* root ) { root->initializePhaseSpace( getNDaug(), getDaugs() ); // Photon is the first particle and psi is the second // to ensure decay file backwards compatibility EvtParticle* photon = root->getDaug( 0 ); EvtParticle* psi = root->getDaug( 1 ); EvtVector4R p = psi->getP4(), // psi momentum k = photon->getP4(); // Photon momentum for ( int iPsi = 0; iPsi < 3; iPsi++ ) { EvtVector4C epsPsi = psi->epsParent( iPsi ).conj(); for ( int iGamma = 0; iGamma < 2; iGamma++ ) { EvtVector4C epsGamma = photon->epsParentPhoton( iGamma ).conj(); for ( int iChi = 0; iChi < 5; iChi++ ) { EvtTensor4C epsChi = root->epsTensor( iChi ); // Baranov PRD 85,014034 (2012), Eq 11 // amp = p^mu epsPsi^a epsChi_{a b} [k_mu epsGamma_b - k_b epsGamma_mu] EvtVector4C eee = epsChi.cont1( epsPsi ); EvtVector4C vvv = ( p * k ) * eee - ( k * eee ) * p; EvtComplex amp = vvv * epsGamma; vertex( iChi, iGamma, iPsi, amp ); } } } } void EvtTVP::decay_3body( EvtParticle* root ) { root->initializePhaseSpace( getNDaug(), getDaugs() ); EvtParticle* psi = root->getDaug( 0 ); EvtParticle* mup = root->getDaug( 1 ); EvtParticle* mum = root->getDaug( 2 ); EvtVector4R p = psi->getP4(), // psi momentum k1 = mup->getP4(), // mu+ momentum k2 = mum->getP4(), // mu- momentum k = k1 + k2; // photon momentum double kSq = k * k; // The decay amplitude needs four-vector products. Make sure we have // valid values for these, otherwise set the amplitude to zero. // We need to set _amp2 (EvtDecayAmp) via the vertex() function call // even when the amplitude is zero, otherwise the amplitude from the // previous accepted event will be used, potentially leading to biases // Selection on k^2 to avoid inefficient generation for the electron modes bool validAmp( true ); if ( kSq < 1e-3 ) { validAmp = false; } double dSq = delta * delta; double dSqDenom = dSq - kSq; if ( fabs( dSqDenom ) < 1e-10 ) { validAmp = false; } double factor( 1.0 ); if ( validAmp ) { factor = dSq / ( dSqDenom * kSq ); } // Calculate the amplitude terms, looping over the psi and lepton states int iPols[4] = {0, 0, 0, 0}; for ( int iChi = 0; iChi < 5; iChi++ ) { iPols[0] = iChi; EvtTensor4C epsChi = root->epsTensor( iChi ); for ( int iPsi = 0; iPsi < 3; iPsi++ ) { iPols[1] = iPsi; EvtVector4C epsPsi = psi->epsParent( iPsi ).conj(); for ( int iMplus = 0; iMplus < 2; iMplus++ ) { iPols[2] = iMplus; EvtDiracSpinor spMplus = mup->spParent( iMplus ); for ( int iMminus = 0; iMminus < 2; iMminus++ ) { iPols[3] = iMminus; EvtDiracSpinor spMminus = mum->spParent( iMminus ); EvtVector4C epsGamma = EvtLeptonVCurrent( spMplus, spMminus ); // Based on Baranov PRD 85,014034 (2012), Eq 11 // amp = p^mu epsPsi^a epsChi_{a b} [k_mu epsGamma_b - k_b epsGamma_mu]/k^2 EvtVector4C eee = epsChi.cont1( epsPsi ); EvtVector4C vvv = ( p * k ) * eee - ( k * eee ) * p; EvtComplex amp( 0.0, 0.0 ); if ( validAmp ) { amp = vvv * epsGamma; } amp *= factor; // Set the amplitude matrix element using the vertex function vertex( iPols, amp ); } } } } } diff --git a/src/EvtGenModels/EvtVtoSll.cpp b/src/EvtGenModels/EvtVtoSll.cpp index a640aa5..b6d7cb2 100644 --- a/src/EvtGenModels/EvtVtoSll.cpp +++ b/src/EvtGenModels/EvtVtoSll.cpp @@ -1,111 +1,111 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtVtoSll.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include #include #include std::string EvtVtoSll::getName() { return "VTOSLL"; } EvtDecayBase* EvtVtoSll::clone() { return new EvtVtoSll; } void EvtVtoSll::init() { // check that there are 0 arguments checkNArg( 0 ); checkNDaug( 3 ); checkSpinParent( EvtSpinType::VECTOR ); checkSpinDaughter( 0, EvtSpinType::SCALAR ); checkSpinDaughter( 1, EvtSpinType::DIRAC ); checkSpinDaughter( 2, EvtSpinType::DIRAC ); } void EvtVtoSll::initProbMax() { - //setProbMax(1.0); + setProbMax(10.0); } void EvtVtoSll::decay( EvtParticle* p ) { p->initializePhaseSpace( getNDaug(), getDaugs() ); EvtParticle *l1, *l2; l1 = p->getDaug( 1 ); l2 = p->getDaug( 2 ); EvtVector4C l11, l12, l21, l22; l11 = EvtLeptonVCurrent( l1->spParent( 0 ), l2->spParent( 0 ) ); l12 = EvtLeptonVCurrent( l1->spParent( 0 ), l2->spParent( 1 ) ); l21 = EvtLeptonVCurrent( l1->spParent( 1 ), l2->spParent( 0 ) ); l22 = EvtLeptonVCurrent( l1->spParent( 1 ), l2->spParent( 1 ) ); EvtVector4C eps0 = p->eps( 0 ); EvtVector4C eps1 = p->eps( 1 ); EvtVector4C eps2 = p->eps( 2 ); EvtVector4R P = p->getP4Restframe(); EvtVector4R k = l1->getP4() + l2->getP4(); double k2 = k * k; EvtTensor4C T( dual( EvtGenFunctions::directProd( P, ( 1.0 / k2 ) * k ) ) ); double M2 = p->mass(); M2 *= M2; double m2 = l1->mass(); m2 *= m2; double norm = 1.0 / sqrt( 2 * M2 + 4 * m2 - 4 * m2 * m2 / M2 ); vertex( 0, 0, 0, norm * ( eps0 * T.cont2( l11 ) ) ); vertex( 0, 0, 1, norm * ( eps0 * T.cont2( l12 ) ) ); vertex( 0, 1, 0, norm * ( eps0 * T.cont2( l21 ) ) ); vertex( 0, 1, 1, norm * ( eps0 * T.cont2( l22 ) ) ); vertex( 1, 0, 0, norm * ( eps1 * T.cont2( l11 ) ) ); vertex( 1, 0, 1, norm * ( eps1 * T.cont2( l12 ) ) ); vertex( 1, 1, 0, norm * ( eps1 * T.cont2( l21 ) ) ); vertex( 1, 1, 1, norm * ( eps1 * T.cont2( l22 ) ) ); vertex( 2, 0, 0, norm * ( eps2 * T.cont2( l11 ) ) ); vertex( 2, 0, 1, norm * ( eps2 * T.cont2( l12 ) ) ); vertex( 2, 1, 0, norm * ( eps2 * T.cont2( l21 ) ) ); vertex( 2, 1, 1, norm * ( eps2 * T.cont2( l22 ) ) ); return; } diff --git a/src/EvtGenModels/EvtVubBLNPHybrid.cpp b/src/EvtGenModels/EvtVubBLNPHybrid.cpp index 504e973..cf95cdb 100644 --- a/src/EvtGenModels/EvtVubBLNPHybrid.cpp +++ b/src/EvtGenModels/EvtVubBLNPHybrid.cpp @@ -1,1182 +1,1182 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtVubBLNPHybrid.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtVector4R.hh" #include "EvtGenModels/EvtItgPtrFunction.hh" #include "EvtGenModels/EvtItgSimpsonIntegrator.hh" #include "EvtGenModels/EvtPFermi.hh" #include #include // For incomplete gamma function #include "math.h" #include "signal.h" #define ITMAX 100 #define EPS 3.0e-7 #define FPMIN 1.0e-30 using std::cout; using std::endl; std::string EvtVubBLNPHybrid::getName() { return "VUB_BLNPHYBRID"; } EvtDecayBase* EvtVubBLNPHybrid::clone() { return new EvtVubBLNPHybrid; } void EvtVubBLNPHybrid::init() { - // check that there are at least 3 arguments + // check number of arguments if ( getNArg() < EvtVubBLNPHybrid::nParameters ) { EvtGenReport( EVTGEN_ERROR, "EvtVubBLNPHybrid" ) << "EvtVubBLNPHybrid generator expected " << "at least " << EvtVubBLNPHybrid::nParameters << " arguments but found: " << getNArg() << "\nWill terminate execution!" << endl; ::abort(); } else if ( getNArg() == EvtVubBLNPHybrid::nParameters ) { EvtGenReport( EVTGEN_WARNING, "EvtVubBLNPHybrid" ) << "EvtVubBLNPHybrid: generate B -> Xu l nu events " << "without using the hybrid reweighting." << endl; _noHybrid = true; } else if ( getNArg() < EvtVubBLNPHybrid::nParameters + EvtVubBLNPHybrid::nVariables ) { EvtGenReport( EVTGEN_ERROR, "EvtVubBLNPHybrid" ) << "EvtVubBLNPHybrid could not read number of bins for " << "all variables used in the reweighting\n" << "Will terminate execution!" << endl; ::abort(); } // get parameters (declared in the header file) // Input parameters mBB = 5.2792; lambda2 = 0.12; // Shape function parameters b = getArg( 0 ); Lambda = getArg( 1 ); Ecut = 1.8; wzero = mBB - 2 * Ecut; // SF and SSF modes itype = (int)getArg( 5 ); dtype = getArg( 5 ); isubl = (int)getArg( 6 ); // flags flag1 = (int)getArg( 7 ); flag2 = (int)getArg( 8 ); flag3 = (int)getArg( 9 ); // Quark mass mb = 4.61; // hidden parameter what and SF stuff const double xlow = 0; const double xhigh = mBB; const int aSize = 10000; EvtPFermi pFermi( Lambda, b ); // pf is the cumulative distribution normalized to 1. _pf.resize( aSize ); for ( int i = 0; i < aSize; i++ ) { double what = xlow + (double)( i + 0.5 ) / ( (double)aSize ) * ( xhigh - xlow ); if ( i == 0 ) _pf[i] = pFermi.getSFBLNP( what ); else _pf[i] = _pf[i - 1] + pFermi.getSFBLNP( what ); } for ( size_t i = 0; i < _pf.size(); i++ ) { _pf[i] /= _pf[_pf.size() - 1]; } // Matching scales muh = mBB * getArg( 2 ); // 0.5 mui = getArg( 3 ); // 1.5 mubar = getArg( 4 ); // 1.5 // Perturbative quantities CF = 4.0 / 3.0; CA = 3.0; double nf = 4.0; beta0 = 11.0 / 3.0 * CA - 2.0 / 3.0 * nf; beta1 = 34.0 / 3.0 * CA * CA - 10.0 / 3.0 * CA * nf - 2.0 * CF * nf; beta2 = 2857.0 / 54.0 * CA * CA * CA + ( CF * CF - 205.0 / 18.0 * CF * CA - 1415.0 / 54.0 * CA * CA ) * nf + ( 11.0 / 9.0 * CF + 79.0 / 54.0 * CA ) * nf * nf; zeta3 = 1.0 + 1 / 8.0 + 1 / 27.0 + 1 / 64.0; Gamma0 = 4 * CF; Gamma1 = CF * ( ( 268.0 / 9.0 - 4.0 * M_PI * M_PI / 3.0 ) * CA - 40.0 / 9.0 * nf ); Gamma2 = 16 * CF * ( ( 245.0 / 24.0 - 67.0 / 54.0 * M_PI * M_PI + +11.0 / 180.0 * pow( M_PI, 4 ) + 11.0 / 6.0 * zeta3 ) * CA * CA * +( -209.0 / 108.0 + 5.0 / 27.0 * M_PI * M_PI - 7.0 / 3.0 * zeta3 ) * CA * nf + ( -55.0 / 24.0 + 2 * zeta3 ) * CF * nf - nf * nf / 27.0 ); gp0 = -5.0 * CF; gp1 = -8.0 * CF * ( ( 3.0 / 16.0 - M_PI * M_PI / 4.0 + 3 * zeta3 ) * CF + ( 1549.0 / 432.0 + 7.0 / 48.0 * M_PI * M_PI - 11.0 / 4.0 * zeta3 ) * CA - ( 125.0 / 216.0 + M_PI * M_PI / 24.0 ) * nf ); // Lbar and mupisq Lbar = Lambda; // all models mupisq = 3 * Lambda * Lambda / b; if ( itype == 1 ) mupisq = 3 * Lambda * Lambda / b; if ( itype == 2 ) mupisq = 3 * Lambda * Lambda * ( Gamma( 1 + 0.5 * b ) * Gamma( 0.5 * b ) / pow( Gamma( 0.5 + 0.5 * b ), 2 ) - 1 ); // moment2 for SSFs moment2 = pow( 0.3, 3 ); // inputs for total rate (T for Total); use BLNP notebook defaults flagpower = 1; flag2loop = 1; // stuff for the integrator maxLoop = 20; //precision = 1.0e-3; precision = 2.0e-2; // vector of global variables, to pass to static functions (which can't access globals); gvars.push_back( 0.0 ); // 0 gvars.push_back( 0.0 ); // 1 gvars.push_back( mui ); // 2 gvars.push_back( b ); // 3 gvars.push_back( Lambda ); // 4 gvars.push_back( mBB ); // 5 gvars.push_back( mb ); // 6 gvars.push_back( wzero ); // 7 gvars.push_back( beta0 ); // 8 gvars.push_back( beta1 ); // 9 gvars.push_back( beta2 ); // 10 gvars.push_back( dtype ); // 11 // check that there are 3 daughters and 10 arguments checkNDaug( 3 ); // A. Volk: check for number of arguments is not necessary //checkNArg(10); if ( _noHybrid ) return; // Without hybrid weighting, nothing else to do _bins_mX = std::vector( abs( (int)getArg( 10 ) ) ); _bins_q2 = std::vector( abs( (int)getArg( 11 ) ) ); _bins_El = std::vector( abs( (int)getArg( 12 ) ) ); int nextArg = EvtVubBLNPHybrid::nParameters + EvtVubBLNPHybrid::nVariables; _nbins = _bins_mX.size() * _bins_q2.size() * _bins_El.size(); // Binning of weight table int expectArgs = nextArg + _bins_mX.size() + _bins_q2.size() + _bins_El.size() + _nbins; if ( getNArg() < expectArgs ) { EvtGenReport( EVTGEN_ERROR, "EvtVubBLNPHybrid" ) << " finds " << getNArg() << " arguments, expected " << expectArgs << ". Something is wrong with the tables of weights or thresholds." << "\nWill terminate execution!" << endl; ::abort(); } // read bin boundaries from decay.dec for ( auto& b : _bins_mX ) b = getArg( nextArg++ ); _masscut = _bins_mX[0]; for ( auto& b : _bins_q2 ) b = getArg( nextArg++ ); for ( auto& b : _bins_El ) b = getArg( nextArg++ ); // read in weights (and rescale to range 0..1) readWeights( nextArg ); } void EvtVubBLNPHybrid::initProbMax() { noProbMax(); } void EvtVubBLNPHybrid::decay( EvtParticle* Bmeson ) { int j; EvtParticle *xuhad( nullptr ), *lepton( nullptr ), *neutrino( nullptr ); EvtVector4R p4; double EX( 0. ), sh( 0. ), El( 0. ), ml( 0. ); double Pp, Pm, Pl, pdf, qsq, mpi, ratemax; double xhigh, xlow, what; double mX; bool rew( true ); while ( rew ) { Bmeson->initializePhaseSpace( getNDaug(), getDaugs() ); xuhad = Bmeson->getDaug( 0 ); lepton = Bmeson->getDaug( 1 ); neutrino = Bmeson->getDaug( 2 ); mBB = Bmeson->mass(); ml = lepton->mass(); // get SF value xlow = 0; xhigh = mBB; // the case for alphas = 0 is not considered what = 2 * xhigh; while ( what > xhigh || what < xlow ) { what = findBLNPWhat(); what = xlow + what * ( xhigh - xlow ); } bool tryit = true; while ( tryit ) { // generate pp between 0 and // Flat(min, max) gives R(max - min) + min, where R = random btwn 0 and 1 Pp = EvtRandom::Flat( 0, mBB ); // P+ = EX - |PX| Pl = EvtRandom::Flat( 0, mBB ); // mBB - 2El Pm = EvtRandom::Flat( 0, mBB ); // P- = EX + |PX| sh = Pm * Pp; EX = 0.5 * ( Pm + Pp ); qsq = ( mBB - Pp ) * ( mBB - Pm ); El = 0.5 * ( mBB - Pl ); // Need maximum rate. Waiting for Mr. Paz to give it to me. // Meanwhile, use this. ratemax = 3.0; // From trial and error - most events below 3.0 // kinematic bounds (Eq. 2) mpi = 0.14; if ( ( Pp > 0 ) && ( Pp <= Pl ) && ( Pl <= Pm ) && ( Pm < mBB ) && ( El > ml ) && ( sh > 4 * mpi * mpi ) ) { // Probability of pass proportional to PDF pdf = rate3( Pp, Pl, Pm ); double testRan = EvtRandom::Flat( 0., ratemax ); if ( pdf >= testRan ) tryit = false; } } // compute all kinematic variables needed for reweighting mX = sqrt( sh ); // Reweighting in bins of mX, q2, El if ( _nbins > 0 ) { double xran1 = EvtRandom::Flat(); double w = 1.0; if ( !_noHybrid ) w = getWeight( mX, qsq, El ); if ( w >= xran1 ) rew = false; } else { rew = false; } } // o.k. we have the three kineamtic variables // now calculate a flat cos Theta_H [-1,1] distribution of the // hadron flight direction w.r.t the B flight direction // because the B is a scalar and should decay isotropic. // Then chose a flat Phi_H [0,2Pi] w.r.t the B flight direction // and and a flat Phi_L [0,2Pi] in the W restframe w.r.t the // W flight direction. double ctH = EvtRandom::Flat( -1, 1 ); double phH = EvtRandom::Flat( 0, 2 * M_PI ); double phL = EvtRandom::Flat( 0, 2 * M_PI ); // now compute the four vectors in the B Meson restframe double ptmp, sttmp; // calculate the hadron 4 vector in the B Meson restframe sttmp = sqrt( 1 - ctH * ctH ); ptmp = sqrt( EX * EX - sh ); double pHB[4] = {EX, ptmp * sttmp * cos( phH ), ptmp * sttmp * sin( phH ), ptmp * ctH}; p4.set( pHB[0], pHB[1], pHB[2], pHB[3] ); xuhad->init( getDaug( 0 ), p4 ); if ( _storeWhat ) { // cludge to store the hidden parameter what with the decay; // the lifetime of the Xu is abused for this purpose. // tau = 1 ps corresponds to ctau = 0.3 mm -> in order to // stay well below BaBars sensitivity we take what/(10000 GeV). // To extract what back from the StdHepTrk its necessary to get // delta_ctau = Xu->decayVtx()->point().distanceTo(XuDaughter->decayVtx()->point()); // // what = delta_ctau * 100000 * Mass_Xu/Momentum_Xu // xuhad->setLifetime( what / 10000. ); } // calculate the W 4 vector in the B Meson restrframe double apWB = ptmp; double pWB[4] = {mBB - EX, -pHB[1], -pHB[2], -pHB[3]}; // first go in the W restframe and calculate the lepton and // the neutrino in the W frame double mW2 = mBB * mBB + sh - 2 * mBB * EX; double beta = ptmp / pWB[0]; double gamma = pWB[0] / sqrt( mW2 ); double pLW[4]; ptmp = ( mW2 - ml * ml ) / 2 / sqrt( mW2 ); pLW[0] = sqrt( ml * ml + ptmp * ptmp ); double ctL = ( El - gamma * pLW[0] ) / beta / gamma / ptmp; if ( ctL < -1 ) ctL = -1; if ( ctL > 1 ) ctL = 1; sttmp = sqrt( 1 - ctL * ctL ); // eX' = eZ x eW double xW[3] = {-pWB[2], pWB[1], 0}; // eZ' = eW double zW[3] = {pWB[1] / apWB, pWB[2] / apWB, pWB[3] / apWB}; double lx = sqrt( xW[0] * xW[0] + xW[1] * xW[1] ); for ( j = 0; j < 2; j++ ) xW[j] /= lx; // eY' = eZ' x eX' double yW[3] = {-pWB[1] * pWB[3], -pWB[2] * pWB[3], pWB[1] * pWB[1] + pWB[2] * pWB[2]}; double ly = sqrt( yW[0] * yW[0] + yW[1] * yW[1] + yW[2] * yW[2] ); for ( j = 0; j < 3; j++ ) yW[j] /= ly; // p_lep = |p_lep| * ( sin(Theta) * cos(Phi) * eX' // + sin(Theta) * sin(Phi) * eY' // + cos(Theta) * eZ') for ( j = 0; j < 3; j++ ) pLW[j + 1] = sttmp * cos( phL ) * ptmp * xW[j] + sttmp * sin( phL ) * ptmp * yW[j] + ctL * ptmp * zW[j]; double apLW = ptmp; // boost them back in the B Meson restframe double appLB = beta * gamma * pLW[0] + gamma * ctL * apLW; ptmp = sqrt( El * El - ml * ml ); double ctLL = appLB / ptmp; if ( ctLL > 1 ) ctLL = 1; if ( ctLL < -1 ) ctLL = -1; double pLB[4] = {El, 0, 0, 0}; double pNB[4] = {pWB[0] - El, 0, 0, 0}; for ( j = 1; j < 4; j++ ) { pLB[j] = pLW[j] + ( ctLL * ptmp - ctL * apLW ) / apWB * pWB[j]; pNB[j] = pWB[j] - pLB[j]; } p4.set( pLB[0], pLB[1], pLB[2], pLB[3] ); lepton->init( getDaug( 1 ), p4 ); p4.set( pNB[0], pNB[1], pNB[2], pNB[3] ); neutrino->init( getDaug( 2 ), p4 ); } double EvtVubBLNPHybrid::rate3( double Pp, double Pl, double Pm ) { // rate3 in units of GF^2*Vub^2/pi^3 double factor = 1.0 / 16 * ( mBB - Pp ) * U1lo( muh, mui ) * pow( ( Pm - Pp ) / ( mBB - Pp ), alo( muh, mui ) ); double doneJS = DoneJS( Pp, Pm, mui ); double done1 = Done1( Pp, Pm, mui ); double done2 = Done2( Pp, Pm, mui ); double done3 = Done3( Pp, Pm, mui ); // The EvtSimpsonIntegrator returns zero for bad integrals. // So if any of the integrals are zero (ie bad), return zero. // This will cause pdf = 0, so the event will not pass. // I hope this will not introduce a bias. if ( doneJS * done1 * done2 * done3 == 0.0 ) { //cout << "Integral failed: (Pp, Pm, Pl) = (" << Pp << ", " << Pm << ", " << Pl << ")" << endl; return 0.0; } // if (doneJS*done1*done2*done3 != 0.0) { // cout << "Integral OK: (Pp, Pm, Pl) = (" << Pp << ", " << Pm << ", " << Pl << ")" << endl; //} double f1 = F1( Pp, Pm, muh, mui, mubar, doneJS, done1 ); double f2 = F2( Pp, Pm, muh, mui, mubar, done3 ); double f3 = F3( Pp, Pm, muh, mui, mubar, done2 ); double answer = factor * ( ( mBB + Pl - Pp - Pm ) * ( Pm - Pl ) * f1 + 2 * ( Pl - Pp ) * ( Pm - Pl ) * f2 + ( mBB - Pm ) * ( Pm - Pp ) * f3 ); return answer; } double EvtVubBLNPHybrid::F1( double Pp, double Pm, double muh, double mui, double mubar, double doneJS, double done1 ) { std::vector vars( 12 ); vars[0] = Pp; vars[1] = Pm; for ( int j = 2; j < 12; j++ ) { vars[j] = gvars[j]; } double y = ( Pm - Pp ) / ( mBB - Pp ); double ah = CF * alphas( muh, vars ) / 4 / M_PI; double ai = CF * alphas( mui, vars ) / 4 / M_PI; double abar = CF * alphas( mubar, vars ) / 4 / M_PI; double lambda1 = -mupisq; double t1 = -4 * ai / ( Pp - Lbar ) * ( 2 * log( ( Pp - Lbar ) / mui ) + 1 ); double t2 = 1 + dU1nlo( muh, mui ) + anlo( muh, mui ) * log( y ); double t3 = -4.0 * pow( log( y * mb / muh ), 2 ) + 10.0 * log( y * mb / muh ) - 4.0 * log( y ) - 2.0 * log( y ) / ( 1 - y ) - 4.0 * PolyLog( 2, 1 - y ) - M_PI * M_PI / 6.0 - 12.0; double t4 = 2 * pow( log( y * mb * Pp / ( mui * mui ) ), 2 ) - 3 * log( y * mb * Pp / ( mui * mui ) ) + 7 - M_PI * M_PI; double t5 = -wS( Pp ) + 2 * t( Pp ) + ( 1.0 / y - 1.0 ) * ( u( Pp ) - v( Pp ) ); double t6 = -( lambda1 + 3.0 * lambda2 ) / 3.0 + 1.0 / pow( y, 2 ) * ( 4.0 / 3.0 * lambda1 - 2.0 * lambda2 ); double shapePp = Shat( Pp, vars ); double answer = ( t2 + ah * t3 + ai * t4 ) * shapePp + ai * doneJS + 1 / ( mBB - Pp ) * ( flag2 * abar * done1 + flag1 * t5 ) + 1 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t6; if ( Pp > Lbar + mui / exp( 0.5 ) ) answer = answer + t1; return answer; } double EvtVubBLNPHybrid::F2( double Pp, double Pm, double muh, double /* mui */, double mubar, double done3 ) { std::vector vars( 12 ); vars[0] = Pp; vars[1] = Pm; for ( int j = 2; j < 12; j++ ) { vars[j] = gvars[j]; } double y = ( Pm - Pp ) / ( mBB - Pp ); double lambda1 = -mupisq; double ah = CF * alphas( muh, vars ) / 4 / M_PI; double abar = CF * alphas( mubar, vars ) / 4 / M_PI; double t6 = -wS( Pp ) - 2 * t( Pp ) + 1.0 / y * ( t( Pp ) + v( Pp ) ); double t7 = 1 / pow( y, 2 ) * ( 2.0 / 3.0 * lambda1 + 4.0 * lambda2 ) - 1 / y * ( 2.0 / 3.0 * lambda1 + 3.0 / 2.0 * lambda2 ); double shapePp = Shat( Pp, vars ); double answer = ah * log( y ) / ( 1 - y ) * shapePp + 1 / ( mBB - Pp ) * ( flag2 * abar * 0.5 * done3 + flag1 / y * t6 ) + 1.0 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t7; return answer; } double EvtVubBLNPHybrid::F3( double Pp, double Pm, double /*muh*/, double /* mui */, double mubar, double done2 ) { std::vector vars( 12 ); vars[0] = Pp; vars[1] = Pm; for ( int j = 2; j < 12; j++ ) { vars[j] = gvars[j]; } double y = ( Pm - Pp ) / ( mBB - Pp ); double lambda1 = -mupisq; double abar = CF * alphas( mubar, vars ) / 4 / M_PI; double t7 = 1.0 / pow( y, 2 ) * ( -2.0 / 3.0 * lambda1 + lambda2 ); double shapePp = Shat( Pp, vars ); double answer = 1.0 / ( Pm - Pp ) * flag2 * 0.5 * y * abar * done2 + 1.0 / pow( mBB - Pp, 2 ) * flag3 * shapePp * t7; return answer; } double EvtVubBLNPHybrid::DoneJS( double Pp, double Pm, double /* mui */ ) { std::vector vars( 12 ); vars[0] = Pp; vars[1] = Pm; for ( int j = 2; j < 12; j++ ) { vars[j] = gvars[j]; } double lowerlim = 0.001 * Pp; double upperlim = ( 1.0 - 0.001 ) * Pp; auto func = EvtItgPtrFunction{&IntJS, lowerlim, upperlim, vars}; auto integ = EvtItgSimpsonIntegrator{func, precision, maxLoop}; return integ.evaluate( lowerlim, upperlim ); } double EvtVubBLNPHybrid::Done1( double Pp, double Pm, double /* mui */ ) { std::vector vars( 12 ); vars[0] = Pp; vars[1] = Pm; for ( int j = 2; j < 12; j++ ) { vars[j] = gvars[j]; } double lowerlim = 0.001 * Pp; double upperlim = ( 1.0 - 0.001 ) * Pp; auto func = EvtItgPtrFunction{&Int1, lowerlim, upperlim, vars}; auto integ = EvtItgSimpsonIntegrator{func, precision, maxLoop}; return integ.evaluate( lowerlim, upperlim ); } double EvtVubBLNPHybrid::Done2( double Pp, double Pm, double /* mui */ ) { std::vector vars( 12 ); vars[0] = Pp; vars[1] = Pm; for ( int j = 2; j < 12; j++ ) { vars[j] = gvars[j]; } double lowerlim = 0.001 * Pp; double upperlim = ( 1.0 - 0.001 ) * Pp; auto func = EvtItgPtrFunction{&Int2, lowerlim, upperlim, vars}; auto integ = EvtItgSimpsonIntegrator{func, precision, maxLoop}; return integ.evaluate( lowerlim, upperlim ); } double EvtVubBLNPHybrid::Done3( double Pp, double Pm, double /* mui */ ) { std::vector vars( 12 ); vars[0] = Pp; vars[1] = Pm; for ( int j = 2; j < 12; j++ ) { vars[j] = gvars[j]; } double lowerlim = 0.001 * Pp; double upperlim = ( 1.0 - 0.001 ) * Pp; auto func = EvtItgPtrFunction{&Int3, lowerlim, upperlim, vars}; auto integ = EvtItgSimpsonIntegrator{func, precision, maxLoop}; return integ.evaluate( lowerlim, upperlim ); } double EvtVubBLNPHybrid::Int1( double what, const std::vector& vars ) { return Shat( what, vars ) * g1( what, vars ); } double EvtVubBLNPHybrid::Int2( double what, const std::vector& vars ) { return Shat( what, vars ) * g2( what, vars ); } double EvtVubBLNPHybrid::Int3( double what, const std::vector& vars ) { return Shat( what, vars ) * g3( what, vars ); } double EvtVubBLNPHybrid::IntJS( double what, const std::vector& vars ) { double Pp = vars[0]; double Pm = vars[1]; double mui = vars[2]; double mBB = vars[5]; double mb = vars[6]; double y = ( Pm - Pp ) / ( mBB - Pp ); return 1 / ( Pp - what ) * ( Shat( what, vars ) - Shat( Pp, vars ) ) * ( 4 * log( y * mb * ( Pp - what ) / ( mui * mui ) ) - 3 ); } double EvtVubBLNPHybrid::g1( double w, const std::vector& vars ) { double Pp = vars[0]; double Pm = vars[1]; double mBB = vars[5]; double y = ( Pm - Pp ) / ( mBB - Pp ); double x = ( Pp - w ) / ( mBB - Pp ); double q1 = ( 1 + x ) * ( 1 + x ) * y * ( x + y ); double q2 = y * ( -9 + 10 * y ) + x * x * ( -12.0 + 13.0 * y ) + 2 * x * ( -8.0 + 6 * y + 3 * y * y ); double q3 = 4 / x * log( y + y / x ); double q4 = 3.0 * pow( x, 4 ) * ( -2.0 + y ) - 2 * pow( y, 3 ) - 4 * pow( x, 3 ) * ( 2.0 + y ) - 2 * x * y * y * ( 4 + y ) - x * x * y * ( 12 + 4 * y + y * y ); double q5 = log( 1 + y / x ); double answer = q2 / q1 - q3 - 2 * q4 * q5 / ( q1 * y * x ); return answer; } double EvtVubBLNPHybrid::g2( double w, const std::vector& vars ) { double Pp = vars[0]; double Pm = vars[1]; double mBB = vars[5]; double y = ( Pm - Pp ) / ( mBB - Pp ); double x = ( Pp - w ) / ( mBB - Pp ); double q1 = ( 1 + x ) * ( 1 + x ) * pow( y, 3 ) * ( x + y ); double q2 = 10.0 * pow( x, 4 ) + y * y + 3.0 * pow( x, 2 ) * y * ( 10.0 + y ) + pow( x, 3 ) * ( 12.0 + 19.0 * y ) + x * y * ( 8.0 + 4.0 * y + y * y ); double q3 = 5 * pow( x, 4 ) + 2.0 * y * y + 6.0 * pow( x, 3 ) * ( 1.0 + 2.0 * y ) + 4.0 * x * y * ( 1 + 2.0 * y ) + x * x * y * ( 18.0 + 5.0 * y ); double q4 = log( 1 + y / x ); double answer = 2.0 / q1 * ( y * q2 - 2 * x * q3 * q4 ); return answer; } double EvtVubBLNPHybrid::g3( double w, const std::vector& vars ) { double Pp = vars[0]; double Pm = vars[1]; double mBB = vars[5]; double y = ( Pm - Pp ) / ( mBB - Pp ); double x = ( Pp - w ) / ( mBB - Pp ); double q1 = ( 1 + x ) * ( 1 + x ) * pow( y, 3 ) * ( x + y ); double q2 = 2.0 * pow( y, 3 ) * ( -11.0 + 2.0 * y ) - 10.0 * pow( x, 4 ) * ( 6 - 6 * y + y * y ) + x * y * y * ( -94.0 + 29.0 * y + 2.0 * y * y ) + 2.0 * x * x * y * ( -72.0 + 18.0 * y + 13.0 * y * y ) - x * x * x * ( 72.0 + 42.0 * y - 70.0 * y * y + 3.0 * y * y * y ); double q3 = -6.0 * x * ( -5.0 + y ) * pow( y, 3 ) + 4 * pow( y, 4 ) + 5 * pow( x, 5 ) * ( 6 - 6 * y + y * y ) - 4 * x * x * y * y * ( -20.0 + 6 * y + y * y ) + pow( x, 3 ) * y * ( 90.0 - 10.0 * y - 28.0 * y * y + y * y * y ) + pow( x, 4 ) * ( 36.0 + 36.0 * y - 50.0 * y * y + 4 * y * y * y ); double q4 = log( 1 + y / x ); double answer = q2 / q1 + 2 / q1 / y * q3 * q4; return answer; } double EvtVubBLNPHybrid::Shat( double w, const std::vector& vars ) { double mui = vars[2]; double b = vars[3]; double Lambda = vars[4]; double wzero = vars[7]; int itype = (int)vars[11]; double norm = 0.0; double shape = 0.0; if ( itype == 1 ) { double Lambar = ( Lambda / b ) * ( Gamma( 1 + b ) - Gamma( 1 + b, b * wzero / Lambda ) ) / ( Gamma( b ) - Gamma( b, b * wzero / Lambda ) ); double muf = wzero - Lambar; double mupisq = 3 * pow( Lambda, 2 ) / pow( b, 2 ) * ( Gamma( 2 + b ) - Gamma( 2 + b, b * wzero / Lambda ) ) / ( Gamma( b ) - Gamma( b, b * wzero / Lambda ) ) - 3 * Lambar * Lambar; norm = Mzero( muf, mui, mupisq, vars ) * Gamma( b ) / ( Gamma( b ) - Gamma( b, b * wzero / Lambda ) ); shape = pow( b, b ) / Lambda / Gamma( b ) * pow( w / Lambda, b - 1 ) * exp( -b * w / Lambda ); } if ( itype == 2 ) { double dcoef = pow( Gamma( 0.5 * ( 1 + b ) ) / Gamma( 0.5 * b ), 2 ); double t1 = wzero * wzero * dcoef / ( Lambda * Lambda ); double Lambar = Lambda * ( Gamma( 0.5 * ( 1 + b ) ) - Gamma( 0.5 * ( 1 + b ), t1 ) ) / pow( dcoef, 0.5 ) / ( Gamma( 0.5 * b ) - Gamma( 0.5 * b, t1 ) ); double muf = wzero - Lambar; double mupisq = 3 * Lambda * Lambda * ( Gamma( 1 + 0.5 * b ) - Gamma( 1 + 0.5 * b, t1 ) ) / dcoef / ( Gamma( 0.5 * b ) - Gamma( 0.5 * b, t1 ) ) - 3 * Lambar * Lambar; norm = Mzero( muf, mui, mupisq, vars ) * Gamma( 0.5 * b ) / ( Gamma( 0.5 * b ) - Gamma( 0.5 * b, wzero * wzero * dcoef / ( Lambda * Lambda ) ) ); shape = 2 * pow( dcoef, 0.5 * b ) / Lambda / Gamma( 0.5 * b ) * pow( w / Lambda, b - 1 ) * exp( -dcoef * w * w / ( Lambda * Lambda ) ); } double answer = norm * shape; return answer; } double EvtVubBLNPHybrid::Mzero( double muf, double mu, double mupisq, const std::vector& vars ) { double CF = 4.0 / 3.0; double amu = CF * alphas( mu, vars ) / M_PI; double answer = 1 - amu * ( pow( log( muf / mu ), 2 ) + log( muf / mu ) + M_PI * M_PI / 24.0 ) + amu * ( log( muf / mu ) - 0.5 ) * mupisq / ( 3 * muf * muf ); return answer; } double EvtVubBLNPHybrid::wS( double w ) { double answer = ( Lbar - w ) * Shat( w, gvars ); return answer; } double EvtVubBLNPHybrid::t( double w ) { double t1 = -3 * lambda2 / mupisq * ( Lbar - w ) * Shat( w, gvars ); double myf = myfunction( w, Lbar, moment2 ); double myBIK = myfunctionBIK( w, Lbar, moment2 ); double answer = t1; if ( isubl == 1 ) answer = t1; if ( isubl == 3 ) answer = t1 - myf; if ( isubl == 4 ) answer = t1 + myf; if ( isubl == 5 ) answer = t1 - myBIK; if ( isubl == 6 ) answer = t1 + myBIK; return answer; } double EvtVubBLNPHybrid::u( double w ) { double u1 = -2 * ( Lbar - w ) * Shat( w, gvars ); double myf = myfunction( w, Lbar, moment2 ); double myBIK = myfunctionBIK( w, Lbar, moment2 ); double answer = u1; if ( isubl == 1 ) answer = u1; if ( isubl == 3 ) answer = u1 + myf; if ( isubl == 4 ) answer = u1 - myf; if ( isubl == 5 ) answer = u1 + myBIK; if ( isubl == 6 ) answer = u1 - myBIK; return answer; } double EvtVubBLNPHybrid::v( double w ) { double v1 = 3 * lambda2 / mupisq * ( Lbar - w ) * Shat( w, gvars ); double myf = myfunction( w, Lbar, moment2 ); double myBIK = myfunctionBIK( w, Lbar, moment2 ); double answer = v1; if ( isubl == 1 ) answer = v1; if ( isubl == 3 ) answer = v1 - myf; if ( isubl == 4 ) answer = v1 + myf; if ( isubl == 5 ) answer = v1 - myBIK; if ( isubl == 6 ) answer = v1 + myBIK; return answer; } double EvtVubBLNPHybrid::myfunction( double w, double Lbar, double mom2 ) { double bval = 5.0; double x = w / Lbar; double factor = 0.5 * mom2 * pow( bval / Lbar, 3 ); double answer = factor * exp( -bval * x ) * ( 1 - 2 * bval * x + 0.5 * bval * bval * x * x ); return answer; } double EvtVubBLNPHybrid::myfunctionBIK( double w, double Lbar, double /* mom2 */ ) { double aval = 10.0; double normBIK = ( 4 - M_PI ) * M_PI * M_PI / 8 / ( 2 - M_PI ) / aval + 1; double z = 3 * M_PI * w / 8 / Lbar; double q = M_PI * M_PI * 2 * pow( M_PI * aval, 0.5 ) * exp( -aval * z * z ) / ( 4 * M_PI - 8 ) * ( 1 - 2 * pow( aval / M_PI, 0.5 ) * z ) + 8 / pow( 1 + z * z, 4 ) * ( z * log( z ) + 0.5 * z * ( 1 + z * z ) - M_PI / 4 * ( 1 - z * z ) ); double answer = q / normBIK; return answer; } double EvtVubBLNPHybrid::dU1nlo( double muh, double mui ) { double ai = alphas( mui, gvars ); double ah = alphas( muh, gvars ); double q1 = ( ah - ai ) / ( 4 * M_PI * beta0 ); double q2 = log( mb / muh ) * Gamma1 + gp1; double q3 = 4 * beta1 * ( log( mb / muh ) * Gamma0 + gp0 ) + Gamma2 * ( 1 - ai / ah ); double q4 = beta1 * beta1 * Gamma0 * ( -1.0 + ai / ah ) / ( 4 * pow( beta0, 3 ) ); double q5 = -beta2 * Gamma0 * ( 1.0 + ai / ah ) + beta1 * Gamma1 * ( 3 - ai / ah ); double q6 = beta1 * beta1 * Gamma0 * ( ah - ai ) / beta0 - beta2 * Gamma0 * ah + beta1 * Gamma1 * ai; double answer = q1 * ( q2 - q3 / 4 / beta0 + q4 + q5 / ( 4 * beta0 * beta0 ) ) + 1 / ( 8 * M_PI * beta0 * beta0 * beta0 ) * log( ai / ah ) * q6; return answer; } double EvtVubBLNPHybrid::U1lo( double muh, double mui ) { double epsilon = 0.0; double answer = pow( mb / muh, -2 * aGamma( muh, mui, epsilon ) ) * exp( 2 * Sfun( muh, mui, epsilon ) - 2 * agp( muh, mui, epsilon ) ); return answer; } double EvtVubBLNPHybrid::Sfun( double mu1, double mu2, double epsilon ) { double a1 = alphas( mu1, gvars ) / 4 / M_PI; double a2 = alphas( mu2, gvars ) / alphas( mu1, gvars ); double answer = S0( a1, a2 ) + S1( a1, a2 ) + epsilon * S2( a1, a2 ); return answer; } double EvtVubBLNPHybrid::S0( double a1, double r ) { double answer = -Gamma0 / ( 4.0 * beta0 * beta0 * a1 ) * ( -1.0 + 1.0 / r + log( r ) ); return answer; } double EvtVubBLNPHybrid::S1( double /* a1 */, double r ) { double answer = Gamma0 / ( 4 * beta0 * beta0 ) * ( 0.5 * log( r ) * log( r ) * beta1 / beta0 + ( Gamma1 / Gamma0 - beta1 / beta0 ) * ( 1 - r + log( r ) ) ); return answer; } double EvtVubBLNPHybrid::S2( double a1, double r ) { double w1 = pow( beta1, 2 ) / pow( beta0, 2 ) - beta2 / beta0 - beta1 * Gamma1 / ( beta0 * Gamma0 ) + Gamma2 / Gamma0; double w2 = pow( beta1, 2 ) / pow( beta0, 2 ) - beta2 / beta0; double w3 = beta1 * Gamma1 / ( beta0 * Gamma0 ) - beta2 / beta0; double w4 = a1 * Gamma0 / ( 4 * beta0 * beta0 ); double answer = w4 * ( -0.5 * pow( 1 - r, 2 ) * w1 + w2 * ( 1 - r ) * log( r ) + w3 * ( 1 - r + r * log( r ) ) ); return answer; } double EvtVubBLNPHybrid::aGamma( double mu1, double mu2, double epsilon ) { double a1 = alphas( mu1, gvars ); double a2 = alphas( mu2, gvars ); double answer = Gamma0 / ( 2 * beta0 ) * log( a2 / a1 ) + epsilon * ( a2 - a1 ) / ( 8.0 * M_PI ) * ( Gamma1 / beta0 - beta1 * Gamma0 / ( beta0 * beta0 ) ); return answer; } double EvtVubBLNPHybrid::agp( double mu1, double mu2, double epsilon ) { double a1 = alphas( mu1, gvars ); double a2 = alphas( mu2, gvars ); double answer = gp0 / ( 2 * beta0 ) * log( a2 / a1 ) + epsilon * ( a2 - a1 ) / ( 8.0 * M_PI ) * ( gp1 / beta0 - beta1 * gp0 / ( beta0 * beta0 ) ); return answer; } double EvtVubBLNPHybrid::alo( double muh, double mui ) { return -2.0 * aGamma( muh, mui, 0 ); } double EvtVubBLNPHybrid::anlo( double muh, double mui ) { // d/depsilon of aGamma double ah = alphas( muh, gvars ); double ai = alphas( mui, gvars ); double answer = ( ah - ai ) / ( 8.0 * M_PI ) * ( Gamma1 / beta0 - beta1 * Gamma0 / ( beta0 * beta0 ) ); return answer; } double EvtVubBLNPHybrid::alphas( double mu, const std::vector& vars ) { // Note: Lambda4 and Lambda5 depend on mbMS = 4.25 // So if you change mbMS, then you will have to recalculate them. double beta0 = vars[8]; double beta1 = vars[9]; double beta2 = vars[10]; double Lambda4 = 0.298791; double lg = 2 * log( mu / Lambda4 ); double answer = 4 * M_PI / ( beta0 * lg ) * ( 1 - beta1 * log( lg ) / ( beta0 * beta0 * lg ) + beta1 * beta1 / ( beta0 * beta0 * beta0 * beta0 * lg * lg ) * ( ( log( lg ) - 0.5 ) * ( log( lg ) - 0.5 ) - 5.0 / 4.0 + beta2 * beta0 / ( beta1 * beta1 ) ) ); return answer; } double EvtVubBLNPHybrid::PolyLog( double v, double z ) { if ( z >= 1 ) cout << "Error in EvtVubBLNPHybrid: 2nd argument to PolyLog is >= 1." << endl; double sum = 0.0; for ( int k = 1; k < 101; k++ ) { sum = sum + pow( z, k ) / pow( k, v ); } return sum; } double EvtVubBLNPHybrid::Gamma( double z ) { if ( z <= 0 ) return 0; double v = lgamma( z ); return exp( v ); } double EvtVubBLNPHybrid::Gamma( double a, double x ) { double LogGamma; /* if (x<0.0 || a<= 0.0) raise(SIGFPE);*/ if ( x < 0.0 ) x = 0.0; if ( a <= 0.0 ) a = 1.e-50; LogGamma = lgamma( a ); if ( x < ( a + 1.0 ) ) return gamser( a, x, LogGamma ); else return 1.0 - gammcf( a, x, LogGamma ); } /* ------------------Incomplete gamma function-----------------*/ /* ------------------via its series representation-------------*/ double EvtVubBLNPHybrid::gamser( double a, double x, double LogGamma ) { double n; double ap, del, sum; ap = a; del = sum = 1.0 / a; for ( n = 1; n < ITMAX; n++ ) { ++ap; del *= x / ap; sum += del; if ( fabs( del ) < fabs( sum ) * EPS ) return sum * exp( -x + a * log( x ) - LogGamma ); } raise( SIGFPE ); return 0.0; } /* ------------------Incomplete gamma function complement------*/ /* ------------------via its continued fraction representation-*/ double EvtVubBLNPHybrid::gammcf( double a, double x, double LogGamma ) { double an, b, c, d, del, h; int i; b = x + 1.0 - a; c = 1.0 / FPMIN; d = 1.0 / b; h = d; for ( i = 1; i < ITMAX; i++ ) { an = -i * ( i - a ); b += 2.0; d = an * d + b; if ( fabs( d ) < FPMIN ) d = FPMIN; c = b + an / c; if ( fabs( c ) < FPMIN ) c = FPMIN; d = 1.0 / d; del = d * c; h *= del; if ( fabs( del - 1.0 ) < EPS ) return exp( -x + a * log( x ) - LogGamma ) * h; } raise( SIGFPE ); return 0.0; } double EvtVubBLNPHybrid::findBLNPWhat() { double ranNum = EvtRandom::Flat(); double oOverBins = 1.0 / ( float( _pf.size() ) ); int nBinsBelow = 0; // largest k such that I[k] is known to be <= rand int nBinsAbove = _pf.size(); // largest k such that I[k] is known to be > rand int middle; while ( nBinsAbove > nBinsBelow + 1 ) { middle = ( nBinsAbove + nBinsBelow + 1 ) >> 1; if ( ranNum >= _pf[middle] ) { nBinsBelow = middle; } else { nBinsAbove = middle; } } double bSize = _pf[nBinsAbove] - _pf[nBinsBelow]; // binMeasure is always aProbFunc[nBinsBelow], if ( bSize == 0 ) { // rand lies right in a bin of measure 0. Simply return the center // of the range of that bin. (Any value between k/N and (k+1)/N is // equally good, in this rare case.) return ( nBinsBelow + .5 ) * oOverBins; } double bFract = ( ranNum - _pf[nBinsBelow] ) / bSize; return ( nBinsBelow + bFract ) * oOverBins; } double EvtVubBLNPHybrid::getWeight( double mX, double q2, double El ) { int ibin_mX = -1; int ibin_q2 = -1; int ibin_El = -1; for ( unsigned i = 0; i < _bins_mX.size(); i++ ) { if ( mX >= _bins_mX[i] ) ibin_mX = i; } for ( unsigned i = 0; i < _bins_q2.size(); i++ ) { if ( q2 >= _bins_q2[i] ) ibin_q2 = i; } for ( unsigned i = 0; i < _bins_El.size(); i++ ) { if ( El >= _bins_El[i] ) ibin_El = i; } int ibin = ibin_mX + ibin_q2 * _bins_mX.size() + ibin_El * _bins_mX.size() * _bins_q2.size(); if ( ( ibin_mX < 0 ) || ( ibin_q2 < 0 ) || ( ibin_El < 0 ) ) { EvtGenReport( EVTGEN_ERROR, "EvtVubHybrid" ) << "Cannot determine hybrid weight " << "for this event " << "-> assign weight = 0" << endl; return 0.0; } return _weights[ibin]; } void EvtVubBLNPHybrid::readWeights( int startArg ) { _weights.resize( _nbins ); double maxw = 0.0; for ( auto& w : _weights ) { w = getArg( startArg++ ); if ( w > maxw ) maxw = w; } if ( maxw == 0 ) { EvtGenReport( EVTGEN_ERROR, "EvtVubBLNPHybrid" ) << "EvtVub generator expected at least one " << " weight > 0, but found none! " << "Will terminate execution!" << endl; ::abort(); } // rescale weights (to be in range 0..1) for ( auto& w : _weights ) w /= maxw; } diff --git a/src/EvtGenModels/EvtVubNLO.cpp b/src/EvtGenModels/EvtVubNLO.cpp index a658f2e..3f3c41e 100644 --- a/src/EvtGenModels/EvtVubNLO.cpp +++ b/src/EvtGenModels/EvtVubNLO.cpp @@ -1,732 +1,732 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtVubNLO.hh" #include "EvtGenBase/EvtDiLog.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtVector4R.hh" #include "EvtGenModels/EvtBtoXsgammaFermiUtil.hh" #include "EvtGenModels/EvtItgPtrFunction.hh" #include "EvtGenModels/EvtItgSimpsonIntegrator.hh" #include "EvtGenModels/EvtPFermi.hh" #include #include #include using std::cout; using std::endl; EvtVubNLO::~EvtVubNLO() { cout << " max pdf : " << _gmax << endl; cout << " efficiency : " << (float)_ngood / (float)_ntot << endl; } std::string EvtVubNLO::getName() { return "VUB_NLO"; } EvtDecayBase* EvtVubNLO::clone() { return new EvtVubNLO; } void EvtVubNLO::init() { // max pdf _gmax = 0; _ntot = 0; _ngood = 0; _lbar = -1000; _mupi2 = -1000; - // check that there are at least 6 arguments + // check number of arguments int npar = 8; if ( getNArg() < npar ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtVubNLO generator expected " << " at least npar arguments but found: " << getNArg() << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate execution!" << endl; ::abort(); } // this is the shape function parameter _mb = getArg( 0 ); _b = getArg( 1 ); _lambdaSF = getArg( 2 ); // shape function lambda is different from lambda _mui = 1.5; // GeV (scale) _kpar = getArg( 3 ); // 0 _idSF = abs( (int)getArg( 4 ) ); // type of shape function 1: exponential (from Neubert) int nbins = abs( (int)getArg( 5 ) ); _masses.resize( nbins ); _weights.resize( nbins ); // Shape function normalization _mB = 5.28; // temporary B meson mass for normalization std::vector sCoeffs( 11 ); sCoeffs[3] = _b; sCoeffs[4] = _mb; sCoeffs[5] = _mB; sCoeffs[6] = _idSF; sCoeffs[7] = lambda_SF(); sCoeffs[8] = mu_h(); sCoeffs[9] = mu_i(); sCoeffs[10] = 1.; _SFNorm = SFNorm( sCoeffs ); // SF normalization; cout << " pdf 0.66, 1.32 , 4.32 " << tripleDiff( 0.66, 1.32, 4.32 ) << endl; cout << " pdf 0.23,0.37,3.76 " << tripleDiff( 0.23, 0.37, 3.76 ) << endl; cout << " pdf 0.97,4.32,4.42 " << tripleDiff( 0.97, 4.32, 4.42 ) << endl; cout << " pdf 0.52,1.02,2.01 " << tripleDiff( 0.52, 1.02, 2.01 ) << endl; cout << " pdf 1.35,1.39,2.73 " << tripleDiff( 1.35, 1.39, 2.73 ) << endl; if ( getNArg() - npar + 2 != int( 2 * _weights.size() ) ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtVubNLO generator expected " << _weights.size() << " masses and weights but found: " << ( getNArg() - npar ) / 2 << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate execution!" << endl; ::abort(); } int j = npar - 2; double maxw = 0.; for ( unsigned i = 0; i < _masses.size(); i++ ) { _masses[i] = getArg( j++ ); if ( i > 0 && _masses[i] <= _masses[i - 1] ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtVubNLO generator expected " << " mass bins in ascending order!" << "Will terminate execution!" << endl; ::abort(); } _weights[i] = getArg( j++ ); if ( _weights[i] < 0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtVubNLO generator expected " << " weights >= 0, but found: " << _weights[i] << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate execution!" << endl; ::abort(); } if ( _weights[i] > maxw ) maxw = _weights[i]; } if ( maxw == 0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtVubNLO generator expected at least one " << " weight > 0, but found none! " << "Will terminate execution!" << endl; ::abort(); } for ( auto& w : _weights ) w /= maxw; // the maximum dGamma*p2 value depends on alpha_s only: // _dGMax = 0.05; _dGMax = 150.; // for the Fermi Motion we need a B-Meso\n mass - but it's not critical // to get an exact value; in order to stay in the phase space for // B+- and B0 use the smaller mass // check that there are 3 daughters checkNDaug( 3 ); } void EvtVubNLO::initProbMax() { noProbMax(); } void EvtVubNLO::decay( EvtParticle* p ) { // B+ -> u-bar specflav l+ nu EvtParticle *xuhad, *lepton, *neutrino; EvtVector4R p4; double pp, pm, pl, ml, El( 0.0 ), Eh( 0.0 ), sh( 0.0 ); p->initializePhaseSpace( getNDaug(), getDaugs() ); xuhad = p->getDaug( 0 ); lepton = p->getDaug( 1 ); neutrino = p->getDaug( 2 ); _mB = p->mass(); ml = lepton->mass(); bool tryit = true; while ( tryit ) { // pm=(E_H+P_H) pm = EvtRandom::Flat( 0., 1 ); pm = pow( pm, 1. / 3. ) * _mB; // pl=mB-2*El pl = EvtRandom::Flat( 0., 1 ); pl = sqrt( pl ) * pm; // pp=(E_H-P_H) pp = EvtRandom::Flat( 0., pl ); _ntot++; El = ( _mB - pl ) / 2.; Eh = ( pp + pm ) / 2; sh = pp * pm; double pdf( 0. ); if ( pp < pl && El > ml && sh > _masses[0] * _masses[0] && _mB * _mB + sh - 2 * _mB * Eh > ml * ml ) { double xran = EvtRandom::Flat( 0, _dGMax ); pdf = tripleDiff( pp, pl, pm ); // triple differential distribution // cout <<" P+,P-,Pl,Pdf= "< _dGMax ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtVubNLO pdf above maximum: " << pdf << " P+,P-,Pl,Pdf= " << pp << " " << pm << " " << pl << " " << pdf << endl; //::abort(); } if ( pdf >= xran ) tryit = false; if ( pdf > _gmax ) _gmax = pdf; } else { // cout <<" EvtVubNLO incorrect kinematics sh= "< _masses[j] ) j++; double w = _weights[j - 1]; if ( w < xran1 ) tryit = true; // through away this candidate } } // cout <<" max prob "<init( getDaug( 0 ), p4 ); // calculate the W 4 vector in the B Meson restrframe double apWB = ptmp; double pWB[4] = {_mB - Eh, -pHB[1], -pHB[2], -pHB[3]}; // first go in the W restframe and calculate the lepton and // the neutrino in the W frame double mW2 = _mB * _mB + sh - 2 * _mB * Eh; // if(mW2<0.1){ // cout <<" low Q2! "< 1 ) ctL = 1; sttmp = sqrt( 1 - ctL * ctL ); // eX' = eZ x eW double xW[3] = {-pWB[2], pWB[1], 0}; // eZ' = eW double zW[3] = {pWB[1] / apWB, pWB[2] / apWB, pWB[3] / apWB}; double lx = sqrt( xW[0] * xW[0] + xW[1] * xW[1] ); for ( int j = 0; j < 2; j++ ) xW[j] /= lx; // eY' = eZ' x eX' double yW[3] = {-pWB[1] * pWB[3], -pWB[2] * pWB[3], pWB[1] * pWB[1] + pWB[2] * pWB[2]}; double ly = sqrt( yW[0] * yW[0] + yW[1] * yW[1] + yW[2] * yW[2] ); for ( int j = 0; j < 3; j++ ) yW[j] /= ly; // p_lep = |p_lep| * ( sin(Theta) * cos(Phi) * eX' // + sin(Theta) * sin(Phi) * eY' // + cos(Theta) * eZ') for ( int j = 0; j < 3; j++ ) pLW[j + 1] = sttmp * cos( phL ) * ptmp * xW[j] + sttmp * sin( phL ) * ptmp * yW[j] + ctL * ptmp * zW[j]; double apLW = ptmp; // boost them back in the B Meson restframe double appLB = beta * gamma * pLW[0] + gamma * ctL * apLW; ptmp = sqrt( El * El - ml * ml ); double ctLL = appLB / ptmp; if ( ctLL > 1 ) ctLL = 1; if ( ctLL < -1 ) ctLL = -1; double pLB[4] = {El, 0, 0, 0}; double pNB[8] = {pWB[0] - El, 0, 0, 0}; for ( int j = 1; j < 4; j++ ) { pLB[j] = pLW[j] + ( ctLL * ptmp - ctL * apLW ) / apWB * pWB[j]; pNB[j] = pWB[j] - pLB[j]; } p4.set( pLB[0], pLB[1], pLB[2], pLB[3] ); lepton->init( getDaug( 1 ), p4 ); p4.set( pNB[0], pNB[1], pNB[2], pNB[3] ); neutrino->init( getDaug( 2 ), p4 ); return; } double EvtVubNLO::tripleDiff( double pp, double pl, double pm ) { std::vector sCoeffs( 11 ); sCoeffs[0] = pp; sCoeffs[1] = pl; sCoeffs[2] = pm; sCoeffs[3] = _b; sCoeffs[4] = _mb; sCoeffs[5] = _mB; sCoeffs[6] = _idSF; sCoeffs[7] = lambda_SF(); sCoeffs[8] = mu_h(); sCoeffs[9] = mu_i(); sCoeffs[10] = _SFNorm; // SF normalization; double c1 = ( _mB + pl - pp - pm ) * ( pm - pl ); double c2 = 2 * ( pl - pp ) * ( pm - pl ); double c3 = ( _mB - pm ) * ( pm - pp ); double aF1 = F10( sCoeffs ); double aF2 = F20( sCoeffs ); double aF3 = F30( sCoeffs ); double td0 = c1 * aF1 + c2 * aF2 + c3 * aF3; auto func = EvtItgPtrFunction{&integrand, 0., _mB, sCoeffs}; auto jetSF = EvtItgSimpsonIntegrator{func, 0.01, 25}; double smallfrac = 0.000001; // stop a bit before the end to avoid problems with numerical integration double tdInt = jetSF.evaluate( 0, pp * ( 1 - smallfrac ) ); double SU = U1lo( mu_h(), mu_i() ) * pow( ( pm - pp ) / ( _mB - pp ), alo( mu_h(), mu_i() ) ); double TD = ( _mB - pp ) * SU * ( td0 + tdInt ); return TD; } double EvtVubNLO::integrand( double omega, const std::vector& coeffs ) { //double pp=coeffs[0]; double c1 = ( coeffs[5] + coeffs[1] - coeffs[0] - coeffs[2] ) * ( coeffs[2] - coeffs[1] ); double c2 = 2 * ( coeffs[1] - coeffs[0] ) * ( coeffs[2] - coeffs[1] ); double c3 = ( coeffs[5] - coeffs[2] ) * ( coeffs[2] - coeffs[0] ); return c1 * F1Int( omega, coeffs ) + c2 * F2Int( omega, coeffs ) + c3 * F3Int( omega, coeffs ); } double EvtVubNLO::F10( const std::vector& coeffs ) { double pp = coeffs[0]; double y = ( coeffs[2] - coeffs[0] ) / ( coeffs[5] - coeffs[0] ); double mui = coeffs[9]; double muh = coeffs[8]; double z = 1 - y; double result = U1nlo( muh, mui ) / U1lo( muh, mui ); result += anlo( muh, mui ) * log( y ); result += C_F( muh ) * ( -4 * pow( log( y * coeffs[4] / muh ), 2 ) + 10 * log( y * coeffs[4] / muh ) - 4 * log( y ) - 2 * log( y ) / ( 1 - y ) - 4.0 * EvtDiLog::DiLog( z ) - pow( EvtConst::pi, 2 ) / 6. - 12 ); result += C_F( mui ) * ( 2 * pow( log( y * coeffs[4] * pp / pow( mui, 2 ) ), 2 ) - 3 * log( y * coeffs[4] * pp / pow( mui, 2 ) ) + 7 - pow( EvtConst::pi, 2 ) ); result *= shapeFunction( pp, coeffs ); // changes due to SSF result += ( -subS( coeffs ) + 2 * subT( coeffs ) + ( subU( coeffs ) - subV( coeffs ) ) * ( 1 / y - 1. ) ) / ( coeffs[5] - pp ); result += shapeFunction( pp, coeffs ) / pow( ( coeffs[5] - coeffs[0] ), 2 ) * ( -5 * ( lambda1() + 3 * lambda2() ) / 6 + 2 * ( 2 * lambda1() / 3 - lambda2() ) / pow( y, 2 ) ); // result += (subS(coeffs)+subT(coeffs)+(subU(coeffs)-subV(coeffs))/y)/(coeffs[5]-pp); // this part has been added after Feb '05 //result += shapeFunction(pp,coeffs)/pow((coeffs[5]-coeffs[0]),2)*((lambda1()+3*lambda2())/6+2*(2*lambda1()/3-lambda2())/pow(y,2)); return result; } double EvtVubNLO::F1Int( double omega, const std::vector& coeffs ) { double pp = coeffs[0]; double y = ( coeffs[2] - coeffs[0] ) / ( coeffs[5] - coeffs[0] ); // mubar == mui return C_F( coeffs[9] ) * ( ( shapeFunction( omega, coeffs ) - shapeFunction( pp, coeffs ) ) * ( 4 * log( y * coeffs[4] * ( pp - omega ) / pow( coeffs[9], 2 ) ) - 3 ) / ( pp - omega ) + ( g1( y, ( pp - omega ) / ( coeffs[5] - coeffs[0] ) ) / ( coeffs[5] - pp ) * shapeFunction( omega, coeffs ) ) ); } double EvtVubNLO::F20( const std::vector& coeffs ) { double pp = coeffs[0]; double y = ( coeffs[2] - coeffs[0] ) / ( coeffs[5] - coeffs[0] ); double result = C_F( coeffs[8] ) * log( y ) / ( 1 - y ) * shapeFunction( pp, coeffs ) - 1 / y * ( subS( coeffs ) + 2 * subT( coeffs ) - ( subT( coeffs ) + subV( coeffs ) ) / y ) / ( coeffs[5] - pp ); // added after Feb '05 result += shapeFunction( pp, coeffs ) / pow( ( coeffs[5] - coeffs[0] ) * y, 2 ) * ( 2 * lambda1() / 3 + 4 * lambda2() - y * ( 7 / 6 * lambda1() + 3 * lambda2() ) ); return result; } double EvtVubNLO::F2Int( double omega, const std::vector& coeffs ) { double pp = coeffs[0]; double y = ( coeffs[2] - coeffs[0] ) / ( coeffs[5] - coeffs[0] ); return C_F( coeffs[9] ) * g3( y, ( pp - omega ) / ( coeffs[5] - coeffs[0] ) ) * shapeFunction( omega, coeffs ) / ( coeffs[5] - pp ); } double EvtVubNLO::F30( const std::vector& coeffs ) { double y = ( coeffs[2] - coeffs[0] ) / ( coeffs[5] - coeffs[0] ); return shapeFunction( coeffs[0], coeffs ) / pow( ( coeffs[5] - coeffs[0] ) * y, 2 ) * ( -2 * lambda1() / 3 + lambda2() ); } double EvtVubNLO::F3Int( double omega, const std::vector& coeffs ) { double pp = coeffs[0]; double y = ( coeffs[2] - coeffs[0] ) / ( coeffs[5] - coeffs[0] ); return C_F( coeffs[9] ) * g3( y, ( pp - omega ) / ( coeffs[5] - coeffs[0] ) ) / 2 * shapeFunction( omega, coeffs ) / ( coeffs[2] - coeffs[0] ); } double EvtVubNLO::g1( double y, double x ) { double result = ( y * ( -9 + 10 * y ) + x * x * ( -12 + 13 * y ) + 2 * x * ( -8 + 6 * y + 3 * y * y ) ) / y / pow( 1 + x, 2 ) / ( x + y ); result -= 4 * log( ( 1 + 1 / x ) * y ) / x; result -= 2 * log( 1 + y / x ) * ( 3 * pow( x, 4 ) * ( -2 + y ) - 2 * pow( y, 3 ) - 4 * pow( x, 3 ) * ( 2 + y ) - 2 * x * y * y * ( 4 + y ) - x * x * y * ( 12 + 4 * y + y * y ) ) / x / pow( ( 1 + x ) * y, 2 ) / ( x + y ); return result; } double EvtVubNLO::g2( double y, double x ) { double result = y * ( 10 * pow( x, 4 ) + y * y + 3 * x * x * y * ( 10 + y ) + pow( x, 3 ) * ( 12 + 19 * y ) + x * y * ( 8 + 4 * y + y * y ) ); result -= 2 * x * log( 1 + y / x ) * ( 5 * pow( x, 4 ) + 2 * y * y + 6 * pow( x, 3 ) * ( 1 + 2 * y ) + 4 * y * x * ( 1 + 2 * y ) + x * x * y * ( 18 + 5 * y ) ); result *= 2 / ( pow( y * ( 1 + x ), 2 ) * y * ( x + y ) ); return result; } double EvtVubNLO::g3( double y, double x ) { double result = ( 2 * pow( y, 3 ) * ( -11 + 2 * y ) - 10 * pow( x, 4 ) * ( 6 - 6 * y + y * y ) + x * y * y * ( -94 + 29 * y + 2 * y * y ) + 2 * x * x * y * ( -72 + 18 * y + 13 * y * y ) - pow( x, 3 ) * ( 72 + 42 * y - 70 * y * y + 3 * pow( y, 3 ) ) ) / ( pow( y * ( 1 + x ), 2 ) * y * ( x + y ) ); result += 2 * log( 1 + y / x ) * ( -6 * x * pow( y, 3 ) * ( -5 + y ) + 4 * pow( y, 4 ) + 5 * pow( x, 5 ) * ( 6 - 6 * y + y * y ) - 4 * pow( x * y, 2 ) * ( -20 + 6 * y + y * y ) + pow( x, 3 ) * y * ( 90 - 10 * y - 28 * y * y + pow( y, 3 ) ) + pow( x, 4 ) * ( 36 + 36 * y - 50 * y * y + 4 * pow( y, 3 ) ) ) / ( pow( ( 1 + x ) * y * y, 2 ) * ( x + y ) ); return result; } /* old version (before Feb 05 notebook from NNeubert double EvtVubNLO::F1Int(double omega,const std::vector &coeffs){ double pp=coeffs[0]; double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]); // mubar == mui return C_F(coeffs[9])*( (shapeFunction(omega,coeffs)-shapeFunction(pp,coeffs))*(4*log(y*coeffs[4]*(pp-omega)/pow(coeffs[9],2))-3)/(pp-omega)- (1./y/(coeffs[5]-pp)*shapeFunction(omega,coeffs)*(5-6*y+4*(3-y)*log((pp-omega)/y/coeffs[4]))) ); } double EvtVubNLO::F2Int(double omega,const std::vector &coeffs){ double pp=coeffs[0]; double y=(coeffs[2]-coeffs[0])/(coeffs[5]-coeffs[0]); return C_F(coeffs[9])*shapeFunction(omega,coeffs)*(2-11/y-4/y*log((pp-omega)/y/coeffs[4]))/(coeffs[5]-pp); } double EvtVubNLO::F3(const std::vector &coeffs){ return C_F(coeffs[9])*shapeFunction(omega,coeffs)/(coeffs[2]-coeffs[0]); } */ double EvtVubNLO::SFNorm( const std::vector& /*coeffs*/ ) { double omega0 = 1.68; //normalization scale (mB-2*1.8) if ( _idSF == 1 ) { // exponential SF double omega0 = 1.68; //normalization scale (mB-2*1.8) return M0( mu_i(), omega0 ) * pow( _b, _b ) / lambda_SF() / ( Gamma( _b ) - Gamma( _b, _b * omega0 / lambda_SF() ) ); } else if ( _idSF == 2 ) { // Gaussian SF double c = cGaus( _b ); return M0( mu_i(), omega0 ) * 2 / lambda_SF() / pow( c, -( 1 + _b ) / 2. ) / ( Gamma( ( 1 + _b ) / 2 ) - Gamma( ( 1 + _b ) / 2, pow( omega0 / lambda_SF(), 2 ) * c ) ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "unknown SF " << _idSF << endl; return -1; } } double EvtVubNLO::shapeFunction( double omega, const std::vector& sCoeffs ) { if ( sCoeffs[6] == 1 ) { return sCoeffs[10] * expShapeFunction( omega, sCoeffs ); } else if ( sCoeffs[6] == 2 ) { return sCoeffs[10] * gausShapeFunction( omega, sCoeffs ); } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtVubNLO : unknown shape function # " << sCoeffs[6] << endl; } return -1.; } // SSF double EvtVubNLO::subS( const std::vector& c ) { return ( lambda_bar( 1.68 ) - c[0] ) * shapeFunction( c[0], c ); } double EvtVubNLO::subT( const std::vector& c ) { return -3 * lambda2() * subS( c ) / mu_pi2( 1.68 ); } double EvtVubNLO::subU( const std::vector& c ) { return -2 * subS( c ); } double EvtVubNLO::subV( const std::vector& c ) { return -subT( c ); } double EvtVubNLO::lambda_bar( double omega0 ) { if ( _lbar < 0 ) { if ( _idSF == 1 ) { // exponential SF double rat = omega0 * _b / lambda_SF(); _lbar = lambda_SF() / _b * ( Gamma( 1 + _b ) - Gamma( 1 + _b, rat ) ) / ( Gamma( _b ) - Gamma( _b, rat ) ); } else if ( _idSF == 2 ) { // Gaussian SF double c = cGaus( _b ); _lbar = lambda_SF() * ( Gamma( 1 + _b / 2 ) - Gamma( 1 + _b / 2, pow( omega0 / lambda_SF(), 2 ) * c ) ) / ( Gamma( ( 1 + _b ) / 2 ) - Gamma( ( 1 + _b ) / 2, pow( omega0 / lambda_SF(), 2 ) * c ) ) / sqrt( c ); } } return _lbar; } double EvtVubNLO::mu_pi2( double omega0 ) { if ( _mupi2 < 0 ) { if ( _idSF == 1 ) { // exponential SF double rat = omega0 * _b / lambda_SF(); _mupi2 = 3 * ( pow( lambda_SF() / _b, 2 ) * ( Gamma( 2 + _b ) - Gamma( 2 + _b, rat ) ) / ( Gamma( _b ) - Gamma( _b, rat ) ) - pow( lambda_bar( omega0 ), 2 ) ); } else if ( _idSF == 2 ) { // Gaussian SF double c = cGaus( _b ); double m1 = Gamma( ( 3 + _b ) / 2 ) - Gamma( ( 3 + _b ) / 2, pow( omega0 / lambda_SF(), 2 ) * c ); double m2 = Gamma( 1 + _b / 2 ) - Gamma( 1 + _b / 2, pow( omega0 / lambda_SF(), 2 ) * c ); double m3 = Gamma( ( 1 + _b ) / 2 ) - Gamma( ( 1 + _b ) / 2, pow( omega0 / lambda_SF(), 2 ) * c ); _mupi2 = 3 * pow( lambda_SF(), 2 ) * ( m1 / m3 - pow( m2 / m3, 2 ) ) / c; } } return _mupi2; } double EvtVubNLO::M0( double mui, double omega0 ) { double mf = omega0 - lambda_bar( omega0 ); return 1 + 4 * C_F( mui ) * ( -pow( log( mf / mui ), 2 ) - log( mf / mui ) - pow( EvtConst::pi / 2, 2 ) / 6. + mu_pi2( omega0 ) / 3 / pow( mf, 2 ) * ( log( mf / mui ) - 0.5 ) ); } double EvtVubNLO::alphas( double mu ) { double Lambda4 = 0.302932; double lg = 2 * log( mu / Lambda4 ); return 4 * EvtConst::pi / lg / beta0() * ( 1 - beta1() * log( lg ) / pow( beta0(), 2 ) / lg + pow( beta1() / lg, 2 ) / pow( beta0(), 4 ) * ( pow( log( lg ) - 0.5, 2 ) - 1.25 + beta2() * beta0() / pow( beta1(), 2 ) ) ); } double EvtVubNLO::gausShapeFunction( double omega, const std::vector& sCoeffs ) { double b = sCoeffs[3]; double l = sCoeffs[7]; double wL = omega / l; return pow( wL, b ) * exp( -cGaus( b ) * wL * wL ); } double EvtVubNLO::expShapeFunction( double omega, const std::vector& sCoeffs ) { double b = sCoeffs[3]; double l = sCoeffs[7]; double wL = omega / l; return pow( wL, b - 1 ) * exp( -b * wL ); } double EvtVubNLO::Gamma( double z ) { std::array gammaCoeffs{ 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5}; //Lifted from Numerical Recipies in C double y = z; double x = z; double tmp = x + 5.5; tmp = tmp - ( x + 0.5 ) * log( tmp ); double ser = 1.000000000190015; for ( const auto& gammaCoeff : gammaCoeffs ) { y += 1.0; ser += gammaCoeff / y; } return exp( -tmp + log( 2.5066282746310005 * ser / x ) ); } double EvtVubNLO::Gamma( double z, double tmin ) { std::vector c( 1 ); c[0] = z; auto func = EvtItgPtrFunction{&dgamma, tmin, 100., c}; auto jetSF = EvtItgSimpsonIntegrator{func, 0.001}; return jetSF.evaluate( tmin, 100. ); } diff --git a/src/EvtGenModels/EvtbTosllAli.cpp b/src/EvtGenModels/EvtbTosllAli.cpp index 78d7a4a..04971af 100644 --- a/src/EvtGenModels/EvtbTosllAli.cpp +++ b/src/EvtGenModels/EvtbTosllAli.cpp @@ -1,105 +1,105 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtbTosllAli.hh" #include "EvtGenBase/EvtGenKine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenModels/EvtbTosllAliFF.hh" #include "EvtGenModels/EvtbTosllAmp.hh" #include "EvtGenModels/EvtbTosllScalarAmp.hh" #include "EvtGenModels/EvtbTosllVectorAmp.hh" #include #include using std::endl; std::string EvtbTosllAli::getName() { return "BTOSLLALI"; } EvtDecayBase* EvtbTosllAli::clone() { return new EvtbTosllAli; } void EvtbTosllAli::decay( EvtParticle* p ) { setWeight( p->initializePhaseSpace( getNDaug(), getDaugs(), false, _poleSize, 1, 2 ) ); _calcamp->CalcAmp( p, _amp2, _aliffmodel.get() ); } void EvtbTosllAli::initProbMax() { EvtId parnum, mesnum, l1num, l2num; parnum = getParentId(); mesnum = getDaug( 0 ); l1num = getDaug( 1 ); l2num = getDaug( 2 ); //This routine sets the _poleSize. double mymaxprob = _calcamp->CalcMaxProb( parnum, mesnum, l1num, l2num, _aliffmodel.get(), _poleSize ); - + mymaxprob *= 1.25; // Increase to avoid maxprob errors setProbMax( mymaxprob ); } void EvtbTosllAli::init() { checkNArg( 0 ); checkNDaug( 3 ); //We expect the parent to be a scalar //and the daughters to be X lepton+ lepton- checkSpinParent( EvtSpinType::SCALAR ); EvtSpinType::spintype mesontype = EvtPDL::getSpinType( getDaug( 0 ) ); if ( !( mesontype == EvtSpinType::VECTOR || mesontype == EvtSpinType::SCALAR ) ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "EvtbTosllAli generator expected " << " a SCALAR or VECTOR 1st daughter, found:" << EvtPDL::name( getDaug( 0 ) ).c_str() << endl; EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate execution!" << endl; ::abort(); } checkSpinDaughter( 1, EvtSpinType::DIRAC ); checkSpinDaughter( 2, EvtSpinType::DIRAC ); _aliffmodel = std::make_unique(); if ( mesontype == EvtSpinType::SCALAR ) { _calcamp = std::make_unique(); } if ( mesontype == EvtSpinType::VECTOR ) { _calcamp = std::make_unique(); } } diff --git a/src/EvtGenModels/EvtbsToLLLLAmp.cpp b/src/EvtGenModels/EvtbsToLLLLAmp.cpp index 7a34a05..ad1412b 100644 --- a/src/EvtGenModels/EvtbsToLLLLAmp.cpp +++ b/src/EvtGenModels/EvtbsToLLLLAmp.cpp @@ -1,822 +1,822 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtbsToLLLLAmp.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/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtScalarParticle.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include "EvtGenModels/EvtbTosllWilsCoeffNLO.hh" #include "EvtGenModels/Evtbs2llGammaFFMNT.hh" #include // 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). // Wolfenstein parameterization for CKM matrix // CKM_A, CKM_lambda, CKM_barrho, CKM_bareta void EvtbsToLLLLAmp::CalcAmp( EvtParticle* parent, EvtAmp& amp, Evtbs2llGammaFF* formFactors, EvtbTosllWilsCoeffNLO* WilsCoeff, double mu, int Nf, int res_swch, int ias, double CKM_A, double CKM_lambda, double CKM_barrho, double CKM_bareta ) { // FILE *mytest; int il1 = 0, il2 = 1, il3 = 2, il4 = 3; // leptons are the first, second, thirds // and fourth 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; // // Setting of the mq and CKM matrix elements for different Bq-mesons tipes // EvtId idparent = parent->getId(); // Bq-meson Id EvtId IdMu1, IdMu2, IdMu3, IdMu4; 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 EvtbsToLLLLAmp::CalcAmp(...)" << "\n Error in the mq setting!" << "\n mq = " << mq << "< 0.001" << "\n idparent = " << idparent << 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} // // Setting the leptonic kinematical properties // // to find charges of ell^+ and ell^- in the B-meson daughters int charge1 = ( EvtPDL::chg3( parent->getDaug( il1 )->getId() ) ) / 3; int charge2 = ( EvtPDL::chg3( parent->getDaug( il2 )->getId() ) ) / 3; int charge3 = ( EvtPDL::chg3( parent->getDaug( il3 )->getId() ) ) / 3; int charge4 = ( EvtPDL::chg3( parent->getDaug( il4 )->getId() ) ) / 3; if ( ( abs( charge1 ) != 1 ) || ( abs( charge2 ) != 1 ) || ( abs( charge3 ) != 1 ) || ( abs( charge4 ) != 1 ) || ( charge1 + charge2 + charge3 + charge4 != 0 ) ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLAmp::CalcAmp(...)" << "\n Error in the leptonic charge definition!" << "\n charge1 =" << charge1 << "\n charge2 =" << charge2 << "\n charge3 =" << charge3 << "\n charge4 =" << charge4 << "\n number of daughters =" << parent->getNDaug() << std::endl; ::abort(); } EvtParticle* lep1Plus = 0; EvtParticle* lep1Minus = 0; EvtParticle* lep2Plus = 0; EvtParticle* lep2Minus = 0; EvtVector4R p; // B-meson momentum in the B-rest frame EvtVector4R q; // first transition 4-momentum in the B-rest frame EvtVector4R k; // second transition 4-momentum in the B-rest frame double q2; // Mandelstam variable s=q^2 // Nondimentional 4-momentums EvtVector4R hatp; EvtVector4R hatq; EvtVector4R hatk; EvtVector4R qsecond; // first transition 4-momentum in the B-rest frame EvtVector4R ksecond; // second transition 4-momentum in the B-rest frame double q2second; // Mandelstam variable s=q^2 // Nondimentional 4-momentums EvtVector4R hatpsecond; EvtVector4R hatqsecond; EvtVector4R hatksecond; EvtVector4R k_1; // 4-momentum of ell^+ in the B-rest frame EvtVector4R k_2; // 4-momentum of ell^- in the B-rest frame EvtVector4R k_3; // 4-momentum of ell^+ in the B-rest frame EvtVector4R k_4; // 4-momentum of ell^- in the B-rest frame k_1.set( 0.0, 0.0, 0.0, 0.0 ); k_2.set( 0.0, 0.0, 0.0, 0.0 ); k_3.set( 0.0, 0.0, 0.0, 0.0 ); k_4.set( 0.0, 0.0, 0.0, 0.0 ); if ( ( charge1 + charge2 == 0 ) && ( charge3 + charge4 == 0 ) ) { // positive charged lepton 1 lep1Plus = ( charge1 > charge2 ) ? parent->getDaug( il1 ) : parent->getDaug( il2 ); // negative charged lepton 1 lep1Minus = ( charge1 < charge2 ) ? parent->getDaug( il1 ) : parent->getDaug( il2 ); if ( charge1 > charge2 ) { k_1 = parent->getDaug( il1 )->getP4(); k_2 = parent->getDaug( il2 )->getP4(); IdMu1 = parent->getDaug( il1 )->getId(); IdMu2 = parent->getDaug( il2 )->getId(); } else { k_1 = parent->getDaug( il2 )->getP4(); k_2 = parent->getDaug( il1 )->getP4(); IdMu1 = parent->getDaug( il2 )->getId(); IdMu2 = parent->getDaug( il1 )->getId(); } // positive charged lepton 2 lep2Plus = ( charge3 > charge4 ) ? parent->getDaug( il3 ) : parent->getDaug( il4 ); // negative charged lepton 2 lep2Minus = ( charge3 < charge4 ) ? parent->getDaug( il3 ) : parent->getDaug( il4 ); if ( charge3 > charge4 ) { k_3 = parent->getDaug( il3 )->getP4(); k_4 = parent->getDaug( il4 )->getP4(); IdMu3 = parent->getDaug( il3 )->getId(); IdMu4 = parent->getDaug( il4 )->getId(); } else { k_3 = parent->getDaug( il4 )->getP4(); k_4 = parent->getDaug( il3 )->getP4(); IdMu3 = parent->getDaug( il4 )->getId(); IdMu4 = parent->getDaug( il3 )->getId(); } } if ( ( charge1 + charge3 == 0 ) && ( charge2 + charge4 == 0 ) ) { // positive charged lepton 1 lep1Plus = ( charge1 > charge3 ) ? parent->getDaug( il1 ) : parent->getDaug( il3 ); // negative charged lepton 1 lep1Minus = ( charge1 < charge3 ) ? parent->getDaug( il1 ) : parent->getDaug( il3 ); if ( charge1 > charge3 ) { k_1 = parent->getDaug( il1 )->getP4(); k_2 = parent->getDaug( il3 )->getP4(); IdMu1 = parent->getDaug( il1 )->getId(); IdMu2 = parent->getDaug( il3 )->getId(); } else { k_1 = parent->getDaug( il3 )->getP4(); k_2 = parent->getDaug( il1 )->getP4(); IdMu1 = parent->getDaug( il3 )->getId(); IdMu2 = parent->getDaug( il1 )->getId(); } // positive charged lepton 2 lep2Plus = ( charge2 > charge4 ) ? parent->getDaug( il2 ) : parent->getDaug( il4 ); // negative charged lepton 2 lep2Minus = ( charge2 < charge4 ) ? parent->getDaug( il2 ) : parent->getDaug( il4 ); if ( charge2 > charge4 ) { k_3 = parent->getDaug( il2 )->getP4(); k_4 = parent->getDaug( il4 )->getP4(); IdMu3 = parent->getDaug( il2 )->getId(); IdMu4 = parent->getDaug( il4 )->getId(); } else { k_3 = parent->getDaug( il4 )->getP4(); k_4 = parent->getDaug( il2 )->getP4(); IdMu3 = parent->getDaug( il4 )->getId(); IdMu4 = parent->getDaug( il2 )->getId(); } } p = parent->getP4Restframe(); hatp = p / M1; // // The calculation of the FIRST part of the amplitude // q = k_1 + k_2; k = k_3 + k_4; q2 = q.mass2(); // Mandelstam variable s=q^2 hatq = q / M1; hatk = k / M1; // 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; // Excluded of the J/psi and psi' resonant area if ( ( 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; // Excluded of the J/psi and psi' resonant area if ( ( 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 EvtbsToLLLLAmp::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 ); } // The functions for the hadronic matrix element calculation EvtComplex a_b2q, a_barb2barq, b_b2q, b_barb2barq, c_b2q, c_barb2barq; EvtComplex e_b2q, e_barb2barq, f_b2q, f_barb2barq, g_b2q, g_barb2barq; 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 ) * ( hatp * hatk ); b_barb2barq = ( c9eff_barb2barq * Fa + 2.0 * c7gam * Fta_barb2barq * mb * M1 / q2 ) * ( hatp * hatk ); c_b2q = c9eff_b2q * Fa + 2.0 * c7gam * Fta_b2q * mb * M1 / q2; c_barb2barq = c9eff_barb2barq * Fa + 2.0 * c7gam * Fta_barb2barq * mb * M1 / q2; e_b2q = c10a * Fv; e_barb2barq = e_b2q; f_b2q = c10a * Fa * ( hatp * hatk ); f_barb2barq = f_b2q; g_b2q = c10a * Fa; g_barb2barq = g_b2q; // // The calculation of the SECOND part of the amplitude // qsecond = k_1 + k_4; ksecond = k_3 + k_2; q2second = qsecond.mass2(); // Mandelstam variable s=q^2 hatqsecond = qsecond / M1; hatksecond = ksecond / M1; // Excluded of the J/psi and psi' resonant area if ( ( res_swch == 1 ) && ( q2second >= 9.199 ) && ( q2second <= 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, q2second, mb, mq, mc, mu, mt, Mw, ml, Relambda_qu, Imlambda_qu ); c9eff_barb2barq = WilsCoeff->GetC9Eff( 1, res_swch, ias, Nf, q2second, mb, mq, mc, mu, mt, Mw, ml, Relambda_qu, Imlambda_qu ); c10a = WilsCoeff->GetC10Eff( mt, Mw ); } // Excluded of the J/psi and psi' resonant area if ( ( res_swch == 1 ) && ( q2second >= 9.199 ) && ( q2second <= 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 EvtbsToLLLLAmp::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(), q2second, 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(), q2second, M1, mb, mq, c7gam, a1, lambda_qu, lambda_qc, Fv, Fa, Ftv_barb2barq, Fta_barb2barq ); } // The functions for the hadronic matrix element calculation EvtComplex a_b2qsecond, a_barb2barqsecond, b_b2qsecond, b_barb2barqsecond, c_b2qsecond, c_barb2barqsecond; EvtComplex e_b2qsecond, e_barb2barqsecond, f_b2qsecond, f_barb2barqsecond, g_b2qsecond, g_barb2barqsecond; a_b2qsecond = c9eff_b2q * Fv + 2.0 * c7gam * Ftv_b2q * mb * M1 / q2second; a_barb2barqsecond = c9eff_barb2barq * Fv + 2.0 * c7gam * Ftv_barb2barq * mb * M1 / q2second; b_b2qsecond = ( c9eff_b2q * Fa + 2.0 * c7gam * Fta_b2q * mb * M1 / q2second ) * ( hatpsecond * hatksecond ); b_barb2barqsecond = ( c9eff_barb2barq * Fa + 2.0 * c7gam * Fta_barb2barq * mb * M1 / q2second ) * ( hatpsecond * hatksecond ); c_b2qsecond = c9eff_b2q * Fa + 2.0 * c7gam * Fta_b2q * mb * M1 / q2second; c_barb2barqsecond = c9eff_barb2barq * Fa + 2.0 * c7gam * Fta_barb2barq * mb * M1 / q2second; e_b2qsecond = c10a * Fv; e_barb2barqsecond = e_b2qsecond; f_b2qsecond = c10a * Fa * ( hatpsecond * hatksecond ); f_barb2barqsecond = f_b2qsecond; g_b2qsecond = c10a * Fa; g_barb2barqsecond = g_b2qsecond; EvtTensor4C T1, T2; // Tensor structures for EvtTensor4C T1second, T2second; // the hadronic matrix element calculation // B - and barB - mesons descriptors static EvtIdSet bmesons( "anti-B0", "anti-B_s0" ); static 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( hatq, hatk ) ) - b_b2q * uniti * EvtTensor4C::g() + c_b2q * uniti * EvtGenFunctions::directProd( hatk, hatq ); T2 = e_b2q * unit1 * dual( EvtGenFunctions::directProd( hatp, hatk ) ) - f_b2q * uniti * EvtTensor4C::g() + g_b2q * uniti * EvtGenFunctions::directProd( hatk, hatq ); T1second = a_b2qsecond * unit1 * dual( EvtGenFunctions::directProd( hatqsecond, hatksecond ) ) - b_b2qsecond * uniti * EvtTensor4C::g() + c_b2qsecond * uniti * EvtGenFunctions::directProd( hatksecond, hatqsecond ); T2second = e_b2qsecond * unit1 * dual( EvtGenFunctions::directProd( hatpsecond, hatksecond ) ) - f_b2qsecond * uniti * EvtTensor4C::g() + g_b2qsecond * uniti * EvtGenFunctions::directProd( hatksecond, hatqsecond ); int i1, i2, i3, i4; // leptonic spin structures counters int leptonicspin[4]; // array for the saving of the leptonic spin configuration // Tables for correspondings // l^+(k_1) && lep1Plus && k_1 && i1 // l^-(k_2) && lep1Minus && k_2 && i2 // l^+(k_3) && lep2Plus && k_3 && i3 // l^-(k_4) && lep2Minus && k_4 && i4 for ( i2 = 0; i2 < 2; i2++ ) { leptonicspin[0] = i2; for ( i1 = 0; i1 < 2; i1++ ) { leptonicspin[1] = i1; for ( i4 = 0; i4 < 2; i4++ ) { leptonicspin[2] = i4; for ( i3 = 0; i3 < 2; i3++ ) { leptonicspin[3] = i3; EvtVector4C VL2L1, AL2L1, VL4L3; EvtVector4C E1, E2; EvtVector4C VL2L1second, AL2L1second, VL4L3second; EvtVector4C E1second, E2second; VL2L1 = EvtLeptonVCurrent( lep1Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); AL2L1 = EvtLeptonACurrent( lep1Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); VL4L3 = EvtLeptonVCurrent( lep2Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); E1 = T1.cont2( VL4L3 ); E2 = T2.cont2( VL4L3 ); VL2L1second = EvtLeptonVCurrent( lep2Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); AL2L1second = EvtLeptonACurrent( lep2Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); VL4L3second = EvtLeptonVCurrent( lep1Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); E1second = T1second.cont2( VL4L3second ); E2second = T2second.cont2( VL4L3second ); amp.vertex( leptonicspin, CKM_factor * ( VL2L1 * E1 + AL2L1 * E2 + VL2L1second * E1second + AL2L1second * E2second ) ); // EvtGenReport(EVTGEN_ERROR,"EvtGen") // << "\n\n ============================================================================" // << "\n The matrix element (first + second) = " // << CKM_factor*(VL2L1*E1+AL2L1*E2+VL2L1second*E1second+AL2L1second*E2second) // << "\n The matrix element (only first) = " // << CKM_factor*(VL2L1*E1+AL2L1*E2) // << "============================================================================\n\n" // << std::endl; } } } } // EvtGenReport(EVTGEN_ERROR,"EvtGen") << "\n The function EvtbsToLLLLAmp::CalcAmp(...) passed with arguments:" // << "\n ============================================================================" // << "\n Input parameters:" // << "\n mu = " << mu // << "\n Nf =" << Nf // << "\n res_swch = " << res_swch // << "\n ias = " << ias // << "\n CKM_A = " << CKM_A // << "\n CKM_lambda = " << CKM_lambda // << "\n CKM_barrho = " << CKM_barrho // << "\n CKM_bareta = " << CKM_bareta // << "\n CKM_factor = " << CKM_factor // << "\n ============================================================================" // << "\n Kinematics:" // << "\n k_1 = " << k_1 // << "\n m_ell_1 =" << parent->getDaug(il1)->mass() // << "\n k_2 = " << k_2 // << "\n m_ell_2 =" << parent->getDaug(il2)->mass() // << "\n k_3 = " << k_3 // << "\n m_ell_3 =" << parent->getDaug(il3)->mass() // << "\n k_4 = " << k_4 // << "\n m_ell_4 =" << parent->getDaug(il4)->mass() // << "\n p = " << p // << "\n q = " << q // << "\n k = " << k // << "\n ============================================================================" // << "\n Form-factors" // << "\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 fb = " << fb // << "\n ============================================================================" // << "\n Wilson Coefficients:" // << "\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) // << "\n ============================================================================" // << "\n Functions in the matrix element:" // << "\n a_b2q = " << a_b2q // << "\n b_b2q = " << b_b2q // << "\n c_b2q = " << c_b2q // << "\n e_b2q = " << e_b2q // << "\n f_b2q = " << f_b2q // << "\n g_b2q = " << g_b2q // << "\n ============================================================================" // << "\n Partical Properties:" // << "\n IdB = " << idparent << " == " << EvtPDL::getId(std::string("anti-B_s0")) // << "\n IdMu1 = " << IdMu1 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu2 = " << IdMu2 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n IdMu3 = " << IdMu3 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu4 = " << IdMu4 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n\n\n\n" // << 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( hatq, hatk ) ) - b_barb2barq * uniti * EvtTensor4C::g() + c_barb2barq * uniti * EvtGenFunctions::directProd( hatk, hatq ); T2 = -e_barb2barq * unit1 * dual( EvtGenFunctions::directProd( hatq, hatk ) ) - f_barb2barq * uniti * EvtTensor4C::g() + g_barb2barq * uniti * EvtGenFunctions::directProd( hatk, hatq ); T1second = -a_barb2barqsecond * unit1 * dual( EvtGenFunctions::directProd( hatqsecond, hatksecond ) ) - b_barb2barqsecond * uniti * EvtTensor4C::g() + c_barb2barqsecond * uniti * EvtGenFunctions::directProd( hatksecond, hatqsecond ); T2second = -e_barb2barqsecond * unit1 * dual( EvtGenFunctions::directProd( hatpsecond, hatksecond ) ) - f_barb2barqsecond * uniti * EvtTensor4C::g() + g_barb2barqsecond * uniti * EvtGenFunctions::directProd( hatksecond, hatqsecond ); int i1, i2, i3, i4; // leptonic spin structures counters int leptonicspin[4]; // array for the saving of the leptonic spin configuration // Tables for correspondings // l^+(k_1) && lep1Plus && k_1 && i1 // l^-(k_2) && lep1Minus && k_2 && i2 // l^+(k_3) && lep2Plus && k_3 && i3 // l^-(k_4) && lep2Minus && k_4 && i4 - for ( i2 = 1; i2 < 0; i2-- ) { + for ( i2 = 1; i2 > -1; i2-- ) { leptonicspin[0] = i2; - for ( i1 = 1; i1 < 0; i1-- ) { + for ( i1 = 1; i1 > -1; i1-- ) { leptonicspin[1] = i1; - for ( i4 = 1; i4 < 0; i4-- ) { + for ( i4 = 1; i4 > -1; i4-- ) { leptonicspin[2] = i4; - for ( i3 = 1; i3 < 0; i3-- ) { + for ( i3 = 1; i3 > -1; i3-- ) { leptonicspin[3] = i3; EvtVector4C VL2L1, AL2L1, VL4L3; EvtVector4C E1, E2; EvtVector4C VL2L1second, AL2L1second, VL4L3second; EvtVector4C E1second, E2second; VL2L1 = EvtLeptonVCurrent( lep1Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); AL2L1 = EvtLeptonACurrent( lep1Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); VL4L3 = EvtLeptonVCurrent( lep2Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); E1 = T1.cont2( VL4L3 ); E2 = T2.cont2( VL4L3 ); VL2L1second = EvtLeptonVCurrent( lep2Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); AL2L1second = EvtLeptonACurrent( lep2Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); VL4L3second = EvtLeptonVCurrent( lep1Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); E1second = T1second.cont2( VL4L3second ); E2second = T2second.cont2( VL4L3second ); amp.vertex( leptonicspin, conj( CKM_factor ) * ( VL2L1 * E1 + AL2L1 * E2 + VL2L1second * E1second + AL2L1second * E2second ) ); } } } } // EvtGenReport(EVTGEN_ERROR,"EvtGen") << "\n The function EvtbsToLLLLAmp::CalcAmp(...) passed with arguments:" // << "\n ============================================================================" // << "\n Input parameters:" // << "\n mu = " << mu // << "\n Nf =" << Nf // << "\n res_swch = " << res_swch // << "\n ias = " << ias // << "\n CKM_A = " << CKM_A // << "\n CKM_lambda = " << CKM_lambda // << "\n CKM_barrho = " << CKM_barrho // << "\n CKM_bareta = " << CKM_bareta // << "\n CKM_factor = " << CKM_factor // << "\n ============================================================================" // << "\n Kinematics:" // << "\n k_1 = " << k_1 // << "\n m_ell_1 =" << parent->getDaug(il1)->mass() // << "\n k_2 = " << k_2 // << "\n m_ell_2 =" << parent->getDaug(il2)->mass() // << "\n k_3 = " << k_3 // << "\n m_ell_3 =" << parent->getDaug(il3)->mass() // << "\n k_4 = " << k_4 // << "\n m_ell_4 =" << parent->getDaug(il4)->mass() // << "\n p = " << p // << "\n q = " << q // << "\n k = " << k // << "\n ============================================================================" // << "\n Form-factors" // << "\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 fb = " << fb // << "\n ============================================================================" // << "\n Wilson Coefficients:" // << "\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) // << "\n ============================================================================" // << "\n Functions in the matrix element:" // << "\n a_barb2barq = " << a_barb2barq // << "\n b_barb2barq = " << b_barb2barq // << "\n c_barb2barq = " << c_barb2barq // << "\n e_barb2barq = " << e_barb2barq // << "\n f_barb2barq = " << f_barb2barq // << "\n g_barb2barq = " << g_barb2barq // << "\n ============================================================================" // << "\n Partical Properties:" // << "\n IdB = " << idparent << " == " << EvtPDL::getId(std::string("B_s0")) // << "\n IdMu1 = " << IdMu1 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu2 = " << IdMu2 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n IdMu3 = " << IdMu3 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu4 = " << IdMu4 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n\n\n\n" // << std::endl; } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLAmp::CalcAmp(...)" << "\n Wrong Bq-meson number" << std::endl; ::abort(); } } } // // The decays Bq -> ell^+ ell^- ell^+ ell^- maximum probability calculation // double EvtbsToLLLLAmp::CalcMaxProb( // EvtId parnum, // EvtId l1num, EvtId l2num, // EvtId l3num, EvtId l4num, // Evtbs2llGammaFF *formFactors, // EvtbTosllWilsCoeffNLO *WilsCoeff, // double mu, int Nf, // int res_swch, int ias, // double CKM_A, double CKM_lambda, // double CKM_barrho, double CKM_bareta ) { - double maxfoundprob = 5.0; // maximum of the probability + double maxfoundprob = 10.0; // maximum of the probability return maxfoundprob; } // Triangular function double EvtbsToLLLLAmp::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/EvtbsToLLLLHyperCPAmp.cpp b/src/EvtGenModels/EvtbsToLLLLHyperCPAmp.cpp index fce3cf7..40b090e 100644 --- a/src/EvtGenModels/EvtbsToLLLLHyperCPAmp.cpp +++ b/src/EvtGenModels/EvtbsToLLLLHyperCPAmp.cpp @@ -1,605 +1,605 @@ /*********************************************************************** * 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 . * ***********************************************************************/ #include "EvtGenModels/EvtbsToLLLLHyperCPAmp.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/EvtPatches.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtScalarParticle.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include // input: *parent - the pointer to the parent particle (B-meson, the // object of the EvtParticle class); // mS - the mass of the scalar sgoldstino "S" (GeV); // mP - the mass of the pseudoscalar sgoldstino "P" (GeV); // gammaS - the decay width of the scalar sgoldstino "S" (GeV); // gammaP - the decay width of the pseudoscalar sgoldstino "P" (GeV); // mLiiLR - // Fc - coupling constant (GeV^2); // mDijLL(RR) - parameters for \bar Bq-decays // mDjiLL(RR) - parameters for Bq-decays (i <-> j!) // d==1, s==2, b==3 // void EvtbsToLLLLHyperCPAmp::CalcAmp( EvtParticle* parent, EvtAmp& amp, double mS, double mP, double gammaS, double gammaP, double mLiiLR, double Fc, double mD23LL, double mD23RR, double mD32LL, double mD32RR, double mD13LL, double mD13RR, double mD31LL, double mD31RR ) { // FILE *mytest; int il1 = 0, il2 = 1, il3 = 2, il4 = 3; // leptons are the first, second, thirds // and fourth daughter particles EvtComplex unit1( 1.0, 0.0 ); // real unit EvtComplex uniti( 0.0, 1.0 ); // imaginary unit parent->mass(); // B - meson mass, GeV double fb = 0.0; // leptonic decay constant of B-meson, GeV double Cl = 0.0; // LPL and LSL - vertexes if ( Fc != 0.0 ) { Cl = mLiiLR * mLiiLR / ( sqrt( 2 ) * Fc ); } if ( Cl == 0.0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLHyperCPAmp::CalcAmp(...)" << "\n Error in the Cl setting!" << "\n Cl = " << Cl << "\n mLiiLR = " << mLiiLR << "\n Fc = " << Fc << std::endl; ::abort(); } EvtComplex MS = unit1 * mS - uniti * gammaS / 2.0; // complex mass of the scalar sgoldstino EvtComplex MP = unit1 * mP - uniti * gammaP / 2.0; // complex mass of the pseudoscalar sgoldstino // // Setting of the different Bq-mesons tipes // EvtId idparent = parent->getId(); // Bq-meson Id EvtId IdMu1, IdMu2, IdMu3, IdMu4; double CB = 0.0; if ( idparent == EvtPDL::getId( std::string( "B_s0" ) ) ) { fb = 0.24; // leptonic decay constant CB = mD32LL * mD32LL + mD32RR * mD32RR; } if ( idparent == EvtPDL::getId( std::string( "anti-B_s0" ) ) ) { fb = 0.24; // leptonic decay constant CB = mD23LL * mD23LL + mD23RR * mD23RR; } if ( idparent == EvtPDL::getId( std::string( "B0" ) ) ) { fb = 0.20; // leptonic decay constant CB = mD31LL * mD31LL + mD31RR * mD31RR; } if ( idparent == EvtPDL::getId( std::string( "anti-B0" ) ) ) { fb = 0.20; // leptonic decay constant CB = mD13LL * mD13LL + mD13RR * mD13RR; } if ( CB == 0.0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLHyperCPAmp::CalcAmp(...)" << "\n Error in the CB setting!" << "\n CB = " << CB << "\n mD32LL = " << mD32LL << "\n mD32RR = " << mD32RR << "\n mD23LL = " << mD23LL << "\n mD23RR = " << mD23RR << "\n mD31LL = " << mD31LL << "\n mD31RR = " << mD31RR << "\n mD13LL = " << mD13LL << "\n mD13RR = " << mD13RR << "\n idparent = " << idparent << std::endl; ::abort(); } // // Setting the leptonic kinematical properties // // to find charges of ell^+ and ell^- in the B-meson daughters int charge1 = ( EvtPDL::chg3( parent->getDaug( il1 )->getId() ) ) / 3; int charge2 = ( EvtPDL::chg3( parent->getDaug( il2 )->getId() ) ) / 3; int charge3 = ( EvtPDL::chg3( parent->getDaug( il3 )->getId() ) ) / 3; int charge4 = ( EvtPDL::chg3( parent->getDaug( il4 )->getId() ) ) / 3; if ( ( abs( charge1 ) != 1 ) || ( abs( charge2 ) != 1 ) || ( abs( charge3 ) != 1 ) || ( abs( charge4 ) != 1 ) || ( charge1 + charge2 + charge3 + charge4 != 0 ) ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLHyperCPAmp::CalcAmp(...)" << "\n Error in the leptonic charge definition!" << "\n charge1 =" << charge1 << "\n charge2 =" << charge2 << "\n charge3 =" << charge3 << "\n charge4 =" << charge4 << "\n number of daughters =" << parent->getNDaug() << std::endl; ::abort(); } EvtParticle* lep1Plus = 0; EvtParticle* lep1Minus = 0; EvtParticle* lep2Plus = 0; EvtParticle* lep2Minus = 0; EvtVector4R p; // B-meson momentum in the B-rest frame EvtVector4R q; // first transition 4-momentum in the B-rest frame EvtVector4R k; // second transition 4-momentum in the B-rest frame double q2; // Mandelstam variable s=q^2 double k2; // Mandelstam variable t=k^2 EvtVector4R qsecond; // first transition 4-momentum in the B-rest frame EvtVector4R ksecond; // second transition 4-momentum in the B-rest frame double q2second; // Mandelstam variable s=q^2 double k2second; // Mandelstam variable t=k^2 EvtVector4R k_1; // 4-momentum of ell^+ in the B-rest frame EvtVector4R k_2; // 4-momentum of ell^- in the B-rest frame EvtVector4R k_3; // 4-momentum of ell^+ in the B-rest frame EvtVector4R k_4; // 4-momentum of ell^- in the B-rest frame k_1.set( 0.0, 0.0, 0.0, 0.0 ); k_2.set( 0.0, 0.0, 0.0, 0.0 ); k_3.set( 0.0, 0.0, 0.0, 0.0 ); k_4.set( 0.0, 0.0, 0.0, 0.0 ); if ( ( charge1 + charge2 == 0 ) && ( charge3 + charge4 == 0 ) ) { // positive charged lepton 1 lep1Plus = ( charge1 > charge2 ) ? parent->getDaug( il1 ) : parent->getDaug( il2 ); // negative charged lepton 1 lep1Minus = ( charge1 < charge2 ) ? parent->getDaug( il1 ) : parent->getDaug( il2 ); if ( charge1 > charge2 ) { k_1 = parent->getDaug( il1 )->getP4(); k_2 = parent->getDaug( il2 )->getP4(); IdMu1 = parent->getDaug( il1 )->getId(); IdMu2 = parent->getDaug( il2 )->getId(); } else { k_1 = parent->getDaug( il2 )->getP4(); k_2 = parent->getDaug( il1 )->getP4(); IdMu1 = parent->getDaug( il2 )->getId(); IdMu2 = parent->getDaug( il1 )->getId(); } // positive charged lepton 2 lep2Plus = ( charge3 > charge4 ) ? parent->getDaug( il3 ) : parent->getDaug( il4 ); // negative charged lepton 2 lep2Minus = ( charge3 < charge4 ) ? parent->getDaug( il3 ) : parent->getDaug( il4 ); if ( charge3 > charge4 ) { k_3 = parent->getDaug( il3 )->getP4(); k_4 = parent->getDaug( il4 )->getP4(); IdMu3 = parent->getDaug( il3 )->getId(); IdMu4 = parent->getDaug( il4 )->getId(); } else { k_3 = parent->getDaug( il4 )->getP4(); k_4 = parent->getDaug( il3 )->getP4(); IdMu3 = parent->getDaug( il4 )->getId(); IdMu4 = parent->getDaug( il3 )->getId(); } } if ( ( charge1 + charge3 == 0 ) && ( charge2 + charge4 == 0 ) ) { // positive charged lepton 1 lep1Plus = ( charge1 > charge3 ) ? parent->getDaug( il1 ) : parent->getDaug( il3 ); // negative charged lepton 1 lep1Minus = ( charge1 < charge3 ) ? parent->getDaug( il1 ) : parent->getDaug( il3 ); if ( charge1 > charge3 ) { k_1 = parent->getDaug( il1 )->getP4(); k_2 = parent->getDaug( il3 )->getP4(); IdMu1 = parent->getDaug( il1 )->getId(); IdMu2 = parent->getDaug( il3 )->getId(); } else { k_1 = parent->getDaug( il3 )->getP4(); k_2 = parent->getDaug( il1 )->getP4(); IdMu1 = parent->getDaug( il3 )->getId(); IdMu2 = parent->getDaug( il1 )->getId(); } // positive charged lepton 2 lep2Plus = ( charge2 > charge4 ) ? parent->getDaug( il2 ) : parent->getDaug( il4 ); // negative charged lepton 2 lep2Minus = ( charge2 < charge4 ) ? parent->getDaug( il2 ) : parent->getDaug( il4 ); if ( charge2 > charge4 ) { k_3 = parent->getDaug( il2 )->getP4(); k_4 = parent->getDaug( il4 )->getP4(); IdMu3 = parent->getDaug( il2 )->getId(); IdMu4 = parent->getDaug( il4 )->getId(); } else { k_3 = parent->getDaug( il4 )->getP4(); k_4 = parent->getDaug( il2 )->getP4(); IdMu3 = parent->getDaug( il4 )->getId(); IdMu4 = parent->getDaug( il2 )->getId(); } } p = parent->getP4Restframe(); // // The calculation of the FIRST part of the amplitude // q = k_1 + k_2; k = k_3 + k_4; q2 = q.mass2(); // Mandelstam variable s=q^2 k2 = k.mass2(); // Mandelstam variable t=k^2 // // The calculation of the SECOND part of the amplitude // qsecond = k_1 + k_4; ksecond = k_3 + k_2; q2second = qsecond.mass2(); // Mandelstam variable s=q^2 k2second = ksecond.mass2(); // Mandelstam variable t=k^2 // B - and barB - mesons descriptors static EvtIdSet bmesons( "anti-B0", "anti-B_s0" ); static EvtIdSet bbarmesons( "B0", "B_s0" ); EvtId parentID = parent->getId(); if ( bmesons.contains( parentID ) ) { // The amplitude for the decay barB -> ell^+ ell^- ell^+ ell^- or // b \bar q -> ell^+ ell^- ell^+ ell^- int i1, i2, i3, i4; // leptonic spin structures counters int leptonicspin[4]; // array for the saving of the leptonic spin configuration // Tables for correspondings // l^+(k_1) && lep1Plus && k_1 && i1 // l^-(k_2) && lep1Minus && k_2 && i2 // l^+(k_3) && lep2Plus && k_3 && i3 // l^-(k_4) && lep2Minus && k_4 && i4 for ( i2 = 0; i2 < 2; i2++ ) { leptonicspin[0] = i2; for ( i1 = 0; i1 < 2; i1++ ) { leptonicspin[1] = i1; for ( i4 = 0; i4 < 2; i4++ ) { leptonicspin[2] = i4; for ( i3 = 0; i3 < 2; i3++ ) { leptonicspin[3] = i3; EvtComplex SL2L1, PL4L3; EvtComplex SL2L1second, PL4L3second; SL2L1 = EvtLeptonSCurrent( lep1Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); PL4L3 = EvtLeptonPCurrent( lep2Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); SL2L1second = EvtLeptonSCurrent( lep2Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); PL4L3second = EvtLeptonPCurrent( lep1Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); amp.vertex( leptonicspin, Cl * Cl * CB * fb * ( SL2L1 * PL4L3 * ( q2 - k2 ) / ( ( q2 - MS * MS ) * ( k2 - MP * MP ) ) - SL2L1second * PL4L3second * ( q2second - k2second ) / ( ( q2second - MS * MS ) * ( k2second - MP * MP ) ) ) / ( 4.0 * Fc * Fc ) ); } } } } // EvtGenReport(EVTGEN_ERROR,"EvtGen") << "\n The function EvtbsToLLLLHyperCPAmp::CalcAmp(...) passed with arguments:" // << "\n ============================================================================" // << "\n Input parameters:" // << "\n mS = " << mS // << "\n mP = " << mP // << "\n gammaS = " << gammaS // << "\n gammaP = " << gammaP // << "\n mLiiLR = " << mLiiLR // << "\n Fc = " << Fc // << "\n mD23LL = " << mD23LL // << "\n mD23RR = " << mD23RR // << "\n mD32LL = " << mD32LL // << "\n mD32RR = " << mD32RR // << "\n mD13LL = " << mD13LL // << "\n mD13RR = " << mD13RR // << "\n mD31LL = " << mD31LL // << "\n mD31RR = " << mD31RR // << "\n ============================================================================" // << "\n Kinematics:" // << "\n k_1 = " << k_1 // << "\n m_ell_1 =" << parent->getDaug(il1)->mass() // << "\n k_2 = " << k_2 // << "\n m_ell_2 =" << parent->getDaug(il2)->mass() // << "\n k_3 = " << k_3 // << "\n m_ell_3 =" << parent->getDaug(il3)->mass() // << "\n k_4 = " << k_4 // << "\n m_ell_4 =" << parent->getDaug(il4)->mass() // << "\n p = " << p // << "\n q = " << q // << "\n k = " << k // << "\n qsecond = " << qsecond // << "\n ksecond = " << ksecond // << "\n ============================================================================" // << "\n Form-factors" // << "\n fb = " << fb // << "\n ============================================================================" // << "\n Coefficients:" // << "\n Cl = " << Cl // << "\n CB = " << CB // << "\n ============================================================================" // << "\n Partical Properties:" // << "\n IdB = " << idparent << " == " << EvtPDL::getId(std::string("anti-B_s0")) // << "\n IdMu1 = " << IdMu1 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu2 = " << IdMu2 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n IdMu3 = " << IdMu3 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu4 = " << IdMu4 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n\n\n\n" // << std::endl; } else { if ( bbarmesons.contains( parentID ) ) { // The amplitude for the decay B -> ell^+ ell^- ell^+ ell^- or // q bar b -> ell^+ ell^- ell^+ ell^- int i1, i2, i3, i4; // leptonic spin structures counters int leptonicspin[4]; // array for the saving of the leptonic spin configuration // Tables for correspondings // l^+(k_1) && lep1Plus && k_1 && i1 // l^-(k_2) && lep1Minus && k_2 && i2 // l^+(k_3) && lep2Plus && k_3 && i3 // l^-(k_4) && lep2Minus && k_4 && i4 - for ( i2 = 1; i2 < 0; i2-- ) { + for ( i2 = 1; i2 > -1; i2-- ) { leptonicspin[0] = i2; - for ( i1 = 1; i1 < 0; i1-- ) { + for ( i1 = 1; i1 > -1; i1-- ) { leptonicspin[1] = i1; - for ( i4 = 1; i4 < 0; i4-- ) { + for ( i4 = 1; i4 > -1; i4-- ) { leptonicspin[2] = i4; - for ( i3 = 1; i3 < 0; i3-- ) { + for ( i3 = 1; i3 > -1; i3-- ) { leptonicspin[3] = i3; EvtComplex SL2L1, PL4L3; EvtComplex SL2L1second, PL4L3second; SL2L1 = EvtLeptonSCurrent( lep1Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); PL4L3 = EvtLeptonPCurrent( lep2Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); SL2L1second = EvtLeptonSCurrent( lep2Minus->spParent( i2 ), lep1Plus->spParent( i1 ) ); PL4L3second = EvtLeptonPCurrent( lep1Minus->spParent( i4 ), lep2Plus->spParent( i3 ) ); amp.vertex( leptonicspin, Cl * Cl * CB * fb * ( SL2L1 * PL4L3 * ( q2 - k2 ) / ( ( q2 - MS * MS ) * ( k2 - MP * MP ) ) - SL2L1second * PL4L3second * ( q2second - k2second ) / ( ( q2second - MS * MS ) * ( k2second - MP * MP ) ) ) / ( 4.0 * Fc * Fc ) ); } } } } // EvtGenReport(EVTGEN_ERROR,"EvtGen") << "\n The function EvtbsToLLLLHyperCPAmp::CalcAmp(...) passed with arguments:" // << "\n ============================================================================" // << "\n Input parameters:" // << "\n mS = " << mS // << "\n mP = " << mP // << "\n gammaS = " << gammaS // << "\n gammaP = " << gammaP // << "\n mLiiLR = " << mLiiLR // << "\n Fc = " << Fc // << "\n mD23LL = " << mD23LL // << "\n mD23RR = " << mD23RR // << "\n mD32LL = " << mD32LL // << "\n mD32RR = " << mD32RR // << "\n mD13LL = " << mD13LL // << "\n mD13RR = " << mD13RR // << "\n mD31LL = " << mD31LL // << "\n mD31RR = " << mD31RR // << "\n ============================================================================" // << "\n Kinematics:" // << "\n k_1 = " << k_1 // << "\n m_ell_1 =" << parent->getDaug(il1)->mass() // << "\n k_2 = " << k_2 // << "\n m_ell_2 =" << parent->getDaug(il2)->mass() // << "\n k_3 = " << k_3 // << "\n m_ell_3 =" << parent->getDaug(il3)->mass() // << "\n k_4 = " << k_4 // << "\n m_ell_4 =" << parent->getDaug(il4)->mass() // << "\n p = " << p // << "\n q = " << q // << "\n k = " << k // << "\n qsecond = " << qsecond // << "\n ksecond = " << ksecond // << "\n ============================================================================" // << "\n Form-factors" // << "\n fb = " << fb // << "\n ============================================================================" // << "\n Coefficients:" // << "\n Cl = " << Cl // << "\n CB = " << CB // << "\n ============================================================================" // << "\n Partical Properties:" // << "\n IdB = " << idparent << " == " << EvtPDL::getId(std::string("anti-B_s0")) // << "\n IdMu1 = " << IdMu1 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu2 = " << IdMu2 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n IdMu3 = " << IdMu3 << " == " << EvtPDL::getId(std::string("mu+")) // << "\n IdMu4 = " << IdMu4 << " == " << EvtPDL::getId(std::string("mu-")) // << "\n\n\n\n" // << std::endl; } else { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLHyperCPAmp::CalcAmp(...)" << "\n Wrong Bq-meson number" << std::endl; ::abort(); } } } // // The decays Bq -> ell^+ ell^- ell^+ ell^- maximum probability calculation // double EvtbsToLLLLHyperCPAmp::CalcMaxProb( EvtId parnum, EvtId l1num, EvtId /*l2num*/, EvtId /*l3num*/, EvtId /*l4num*/, double mS, double mP, double gammaS, double gammaP, double mLiiLR, double Fc, double mD23LL, double mD23RR, double mD32LL, double mD32RR, double mD13LL, double mD13RR, double mD31LL, double mD31RR ) { if ( Fc == 0.0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLHyperCPAmp::CalcMaxProb" << "\n Error in the Fc setting!" << "\n Fc = " << Fc << "\n mD32LL = " << mD32LL << "\n mD32RR = " << mD32RR << "\n mD23LL = " << mD23LL << "\n mD23RR = " << mD23RR << "\n mD31LL = " << mD31LL << "\n mD31RR = " << mD31RR << "\n mD13LL = " << mD13LL << "\n mD13RR = " << mD13RR << "\n parnum = " << parnum << std::endl; ::abort(); } double Cl = 0.0; // LPL and LSL - vertexes if ( Fc != 0.0 ) { Cl = mLiiLR * mLiiLR / ( sqrt( 2 ) * Fc ); } if ( Cl == 0.0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLHyperCPAmp::CalcMaxProb" << "\n Error in the Cl setting!" << "\n Cl = " << Cl << "\n mLiiLR = " << mLiiLR << "\n Fc = " << Fc << std::endl; ::abort(); } // // Setting of the different Bq-mesons tipes // double fb = 0.0; double CB = 0.0; if ( parnum == EvtPDL::getId( std::string( "B_s0" ) ) ) { fb = 0.24; // leptonic decay constant CB = mD32LL * mD32LL + mD32RR * mD32RR; } if ( parnum == EvtPDL::getId( std::string( "anti-B_s0" ) ) ) { fb = 0.24; // leptonic decay constant CB = mD23LL * mD23LL + mD23RR * mD23RR; } if ( parnum == EvtPDL::getId( std::string( "B0" ) ) ) { fb = 0.20; // leptonic decay constant CB = mD31LL * mD31LL + mD31RR * mD31RR; } if ( parnum == EvtPDL::getId( std::string( "anti-B0" ) ) ) { fb = 0.20; // leptonic decay constant CB = mD13LL * mD13LL + mD13RR * mD13RR; } if ( CB == 0.0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n The function EvtbsToLLLLHyperCPAmp::CalcMaxProb" << "\n Error in the CB setting!" << "\n CB = " << CB << "\n mD32LL = " << mD32LL << "\n mD32RR = " << mD32RR << "\n mD23LL = " << mD23LL << "\n mD23RR = " << mD23RR << "\n mD31LL = " << mD31LL << "\n mD31RR = " << mD31RR << "\n mD13LL = " << mD13LL << "\n mD13RR = " << mD13RR << "\n parnum = " << parnum << std::endl; ::abort(); } double M1 = EvtPDL::getMeanMass( parnum ); // B - meson mass EvtPDL::getMeanMass( l1num ); // leptonic mass // We find the maximum amplitude probability double maxfoundprob = Cl * Cl * CB * fb * fabs( mS * mS + mP * mP + M1 * M1 ) * 10000000.0 / ( 4.0 * Fc * Fc * mS * gammaS * mP * gammaP ); if ( maxfoundprob <= 0.0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "\n\n In the function EvtbsToLLLLHyperCPAmp::CalcMaxProb" << "\n maxfoundprob = " << maxfoundprob << " < 0 or =0!" << "\n mS = " << mS << "\n mP = " << mP << "\n gammaS = " << gammaS << "\n gammaP = " << gammaP << "\n mLiiLR = " << mLiiLR << "\n Fc = " << Fc << "\n mD32LL = " << mD32LL << "\n mD32RR = " << mD32RR << "\n mD23LL = " << mD23LL << "\n mD23RR = " << mD23RR << "\n mD31LL = " << mD31LL << "\n mD31RR = " << mD31RR << "\n mD13LL = " << mD13LL << "\n mD13RR = " << mD13RR << "\n parnum = " << parnum << std::endl; ::abort(); } EvtGenReport( EVTGEN_NOTICE, "EvtGen" ) << "\n maxfoundprob (...) = " << maxfoundprob << std::endl; maxfoundprob *= 1.01; return maxfoundprob; } // Triangular function double EvtbsToLLLLHyperCPAmp::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/CMakeLists.txt b/test/CMakeLists.txt index 18ca882..0bc4183 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,55 +1,60 @@ ######################################################################## # 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 . # ######################################################################## # the test executables require ROOT for histogramming etc. find_package(ROOT QUIET COMPONENTS Hist) -if (ROOT_FOUND) +find_package(nlohmann_json 3.6.1 QUIET) +if (ROOT_FOUND AND nlohmann_json_FOUND) add_library(root_interface INTERFACE IMPORTED) target_include_directories(root_interface INTERFACE ${ROOT_INCLUDE_DIRS}) target_link_libraries(root_interface INTERFACE ${ROOT_LIBRARIES}) # build each of the executables - foreach( test_exe evt_dalitz evtgenlhc_test1 example1 exampleWriteHepMC ) + foreach( test_exe evt_dalitz evtgenlhc_test1 example1 exampleWriteHepMC testDecayModel ) add_executable(${test_exe} ${test_exe}.cc) target_link_libraries(${test_exe} PRIVATE EvtGen) if (EVTGEN_HEPMC3) target_compile_definitions(${test_exe} PRIVATE EVTGEN_HEPMC3) endif() if( EVTGEN_PYTHIA OR EVTGEN_PHOTOS OR EVTGEN_TAUOLA ) target_compile_definitions(${test_exe} PRIVATE EVTGEN_EXTERNAL) target_link_libraries(${test_exe} PRIVATE EvtGenExternal) endif() target_link_libraries(${test_exe} PRIVATE root_interface) endforeach() + # testDecayModel needs nlohmann_json as well + target_link_libraries(testDecayModel PRIVATE nlohmann_json::nlohmann_json) + # install the executables - install(TARGETS evt_dalitz evtgenlhc_test1 example1 exampleWriteHepMC + install(TARGETS evt_dalitz evtgenlhc_test1 example1 exampleWriteHepMC testDecayModel DESTINATION ${CMAKE_INSTALL_DATADIR}/EvtGen/test ) # install the decay files, macros, scripts, etc. install(DIRECTORY exampleFiles DESTINATION ${CMAKE_INSTALL_DATADIR}/EvtGen/test) - install(FILES do_tests + install(DIRECTORY jsonFiles DESTINATION ${CMAKE_INSTALL_DATADIR}/EvtGen/test) + install(FILES do_tests runTests.py makeSrcDepsJson makeModelsJson DESTINATION ${CMAKE_INSTALL_DATADIR}/EvtGen/test PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE) else() - message(WARNING "Could not find ROOT, cannot build test executables") + message(WARNING "Could not find ROOT and/or nlohmann_json, cannot build test executables") endif() diff --git a/test/do_tests b/test/do_tests index fcff10f..a817216 100755 --- a/test/do_tests +++ b/test/do_tests @@ -1,101 +1,100 @@ #!/bin/bash ######################################################################## # 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 . # ######################################################################## time ./evtgenlhc_test1 file 1000 exampleFiles/GENERIC.DEC time ./evtgenlhc_test1 print 100 exampleFiles/GENERIC.DEC time ./evtgenlhc_test1 filevpho 1000 exampleFiles/GENERIC.DEC time ./evtgenlhc_test1 test1 1000 time ./evtgenlhc_test1 chi1kstar 1000 time ./evtgenlhc_test1 test2 1000 time ./evtgenlhc_test1 omega 1000 time ./evtgenlhc_test1 alias time ./evtgenlhc_test1 photos 1000 time ./evtgenlhc_test1 trackmult 1000 time ./evtgenlhc_test1 generic 1000 time ./evtgenlhc_test1 generic 1000 exampleFiles/generic.list time ./evtgenlhc_test1 generic 1000 exampleFiles/genericlong.list time ./evtgenlhc_test1 finalstates 1000 time ./evtgenlhc_test1 kstarnunu 1000 time ./evtgenlhc_test1 bsmix 10000 time ./evtgenlhc_test1 BtoXsgamma 1000 time ./evtgenlhc_test1 BtoK1273gamma 1000 time ./evtgenlhc_test1 pi0dalitz 1000 time ./evtgenlhc_test1 ddalitz 1000 time ./evtgenlhc_test1 kstarll 1000 time ./evtgenlhc_test1 kll 1000 time ./evtgenlhc_test1 hll 1000 pimm time ./evtgenlhc_test1 hll 1000 piee time ./evtgenlhc_test1 hll 1000 pi0mm time ./evtgenlhc_test1 hll 1000 pi0ee time ./evtgenlhc_test1 vectorisr 10000 time ./evtgenlhc_test1 bsquark 1000 time ./evtgenlhc_test1 k3gamma 1000 time ./evtgenlhc_test1 lambda 1000 time ./evtgenlhc_test1 tautaupipi 1000 time ./evtgenlhc_test1 tautauee 1000 time ./evtgenlhc_test1 tautau2pi2pi 1000 time ./evtgenlhc_test1 tautau3pi3pi 1000 time ./evtgenlhc_test1 jpsikstar 1000 0 time ./evtgenlhc_test1 jpsikstar 1000 1 time ./evtgenlhc_test1 jpsikstar 1000 2 time ./evtgenlhc_test1 jpsikstar 1000 3 time ./evtgenlhc_test1 jpsikstar 1000 4 time ./evtgenlhc_test1 svvcplh 1000 time ./evtgenlhc_test1 svscplh 1000 time ./evtgenlhc_test1 ssdcp 10000 time ./evtgenlhc_test1 kstarstargamma 1000 time ./evtgenlhc_test1 dstarpi 10000 time ./evtgenlhc_test1 etacphiphi 10000 time ./evtgenlhc_test1 vvpipi 1000 time ./evtgenlhc_test1 svvhelamp 1000 time ./evtgenlhc_test1 partwave 1000 time ./evtgenlhc_test1 twobody 1000 exampleFiles/TWOBODY1.DEC twobody1.root time ./evtgenlhc_test1 twobody 1000 exampleFiles/TWOBODY2.DEC twobody2.root time ./evtgenlhc_test1 twobody 1000 exampleFiles/TWOBODY3.DEC twobody3.root time ./evtgenlhc_test1 pipipi 1000 time ./evtgenlhc_test1 bhadronic 1000 time ./evtgenlhc_test1 singleb 1000 time ./evtgenlhc_test1 pipi 1000 time ./evtgenlhc_test1 pipipipi 1000 time ./evtgenlhc_test1 a2pi 1000 time ./evtgenlhc_test1 helamp 1000 exampleFiles/HELAMP1_D2STGAMMA.DEC helamp1_D2stgamma.root time ./evtgenlhc_test1 helamp2 1000 time ./evtgenlhc_test1 lambda 1000 time ./evtgenlhc_test1 d2pi 1000 time ./evtgenlhc_test1 a1pi 1000 time ./evtgenlhc_test1 cptest 1000 time ./evtgenlhc_test1 pipicpt 1000 time ./evtgenlhc_test1 jpsiks 1000 time ./evtgenlhc_test1 dump 10 time ./evtgenlhc_test1 genericcont 1000 time ./evtgenlhc_test1 d1 1000 time ./evtgenlhc_test1 mix 1000 time ./evtgenlhc_test1 bmix 10000 exampleFiles/BMIX_1.DEC bmix1.root time ./evtgenlhc_test1 bmix 10000 exampleFiles/BMIX_2.DEC bmix2.root time ./evtgenlhc_test1 semic 10000 time ./evtgenlhc_test1 ddk 10000 time ./evtgenlhc_test1 checkmass 10000 511 time ./evtgenlhc_test1 jpsipolarization 10000 time ./evtgenlhc_test1 checkrotboost time ./evtgenlhc_test1 baryonic 1000 time ./evtgenlhc_test1 phspdecaytimecut 10000 time ./evtgenlhc_test1 3bodyPhsp 1000000 -time ./evtgenlhc_test1 flatSqDalitz 1000000 diff --git a/test/evtgenlhc_test1.cc b/test/evtgenlhc_test1.cc index 1406497..279d92f 100644 --- a/test/evtgenlhc_test1.cc +++ b/test/evtgenlhc_test1.cc @@ -1,5951 +1,5885 @@ /*********************************************************************** * 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 . * ***********************************************************************/ //#@# Dalitz plot for D0 --> K- pi+ pi0 decay: //#@# 1: Mass(K-, pi+) //#@# 2: Mass(pi+,pi0) // // Description: // // This program invokes the EvtGen event generator package // for testing various decay models that are implemented. #include "EvtGen/EvtGen.hh" #include "EvtGenBase/EvtAbsRadCorr.hh" #include "EvtGenBase/EvtComplex.hh" #include "EvtGenBase/EvtConst.hh" #include "EvtGenBase/EvtDecayBase.hh" #include "EvtGenBase/EvtDecayTable.hh" #include "EvtGenBase/EvtDiracSpinor.hh" #include "EvtGenBase/EvtGammaMatrix.hh" #include "EvtGenBase/EvtIdSet.hh" #include "EvtGenBase/EvtKine.hh" #include "EvtGenBase/EvtMTRandomEngine.hh" #include "EvtGenBase/EvtPDL.hh" #include "EvtGenBase/EvtParser.hh" #include "EvtGenBase/EvtParticle.hh" #include "EvtGenBase/EvtParticleFactory.hh" #include "EvtGenBase/EvtRadCorr.hh" #include "EvtGenBase/EvtRandom.hh" #include "EvtGenBase/EvtRandomEngine.hh" #include "EvtGenBase/EvtReport.hh" #include "EvtGenBase/EvtSecondary.hh" #include "EvtGenBase/EvtSimpleRandomEngine.hh" #include "EvtGenBase/EvtStdHep.hh" #include "EvtGenBase/EvtTensor4C.hh" #include "EvtGenBase/EvtVector4C.hh" #include "EvtGenBase/EvtVector4R.hh" #include "EvtGenBase/EvtVectorParticle.hh" #ifdef EVTGEN_EXTERNAL #include "EvtGenExternal/EvtExternalGenList.hh" #endif #include "TApplication.h" #include "TFile.h" #include "TH1.h" #include "TH2.h" #include "TROOT.h" -#include "TTree.h" #include "TString.h" +#include "TTree.h" #include #include #include #include #include #include #include using std::vector; void runFile( int nevent, char* fname, EvtGen& myGenerator ); void runPrint( int nevent, char* fname, EvtGen& myGenerator ); void runFileVpho( int nevent, char* fname, EvtGen& myGenerator ); void runTest1( int nevent, EvtGen& myGenerator ); void runTest2( int nevent, EvtGen& myGenerator ); void runOmega( int nevent, EvtGen& myGenerator ); void runChi1Kstar( int nevent, EvtGen& myGenerator ); void runPi0Dalitz( int nevent, EvtGen& myGenerator ); void runMix( int nevent, EvtGen& myGenerator ); void runBMix( int nevent, EvtGen& myGenerator, std::string userFile, std::string rootFile ); void runDDalitz( int nevent, EvtGen& myGenerator ); void runPiPiCPT( int nevent, EvtGen& myGenerator ); void runPiPiPiPi( int nevent, EvtGen& myGenerator ); void runD2Pi( int nevent, EvtGen& myGenerator ); void runJetsetTab3( int nevent, EvtGen& myGenerator ); void runHelAmp( int nevent, EvtGen& myGenerator, std::string userFile, std::string rootFile ); void runHelAmp2( int nevent, EvtGen& myGenerator ); void runJpsiKs( int nevent, EvtGen& myGenerator ); void runDump( int nevent, EvtGen& myGenerator ); void runD1( int nevent, EvtGen& myGenerator ); void runGenericCont( int nevent, EvtGen& myGenerator ); void runPiPiPi( int nevent, EvtGen& myGenerator ); void runBHadronic( int nevent, EvtGen& myGenerator ); void runSingleB( int nevent, EvtGen& myGenerator ); void runA2Pi( int nevent, EvtGen& myGenerator ); void runAlias(); void runRepeat( int nevent ); void runPhotos( int nevent, EvtGen& myGenerator ); void runTrackMult( int nevent, EvtGen& myGenerator ); void runGeneric( int neventOrig, EvtGen& myGenerator, std::string listfile ); void runFinalStates( int nevent, EvtGen& myGenerator ); std::vector findFinalState( EvtParticle* p ); void runKstarnunu( int nevent, EvtGen& myGenerator ); void runBsmix( int nevent, EvtGen& myGenerator ); void runTauTauPiPi( int nevent, EvtGen& myGenerator ); void runTauTauEE( int nevent, EvtGen& myGenerator ); void runTauTau2Pi2Pi( int nevent, EvtGen& myGenerator ); void runTauTau3Pi3Pi( int nevent, EvtGen& myGenerator ); void runJPsiKstar( int nevent, EvtGen& myGenerator, int modeInt ); void runSVVCPLH( int nevent, EvtGen& myGenerator ); void runSVSCPLH( int nevent, EvtGen& myGenerator ); void runSSDCP( int nevent, EvtGen& myGenerator ); void runKstarstargamma( int nevent, EvtGen& myGenerator ); void runDSTARPI( int nevent, EvtGen& myGenerator ); void runETACPHIPHI( int nevent, EvtGen& myGenerator ); void runVVPiPi( int nevent, EvtGen& myGenerator ); void runSVVHelAmp( int nevent, EvtGen& myGenerator ); void runSVVHelAmp2( int nevent, EvtGen& myGenerator ); void runPartWave( int nevent, EvtGen& myGenerator ); void runPartWave2( int nevent, EvtGen& myGenerator ); void runTwoBody( int nevent, EvtGen& myGenerator, std::string decfile, std::string rootFile ); void runPiPi( int nevent, EvtGen& myGenerator ); void runA1Pi( int nevent, EvtGen& myGenerator ); void runCPTest( int nevent, EvtGen& myGenerator ); void runSemic( int nevent, EvtGen& myGenerator ); void runKstarll( int nevent, EvtGen& myGenerator ); void runKll( int nevent, EvtGen& myGenerator ); void runHll( int nevent, EvtGen& myGenerator, char* mode ); void runVectorIsr( int nevent, EvtGen& myGenerator ); void runBsquark( int nevent, EvtGen& myGenerator ); void runK3gamma( int nevent, EvtGen& myGenerator ); void runLambda( int nevent, EvtGen& myGenerator ); void runBtoXsgamma( int nevent, EvtGen& myGenerator ); void runBtoK1273gamma( int nevent, EvtGen& myGenerator ); void runCheckRotBoost(); void runMassCheck( int nevent, EvtGen& myGenerator, int partnum ); void runJpsiPolarization( int nevent, EvtGen& myGenerator ); void runDDK( int nevent, EvtGen& myGenerator ); void runPhspDecaytimeCut( int nevent, EvtGen& myGenerator ); int countInclusive( std::string name, EvtParticle* root, TH1F* mom = 0, TH1F* mass = 0 ); int countInclusiveParent( std::string name, EvtParticle* root, EvtIdSet setIds, TH1F* mom = 0 ); int countInclusiveSubTree( std::string name, EvtParticle* root, EvtIdSet setIds, TH1F* mom = 0 ); void runBaryonic( int nEvent, EvtGen& myGenerator ); void run3BPhspRegion( int nEvent, EvtGen& myGenerator ); -void runFlatSqDalitz( int nEvent, EvtGen& myGenerator ); void runFourBody( int nevent, EvtGen& myGenerator ); int main( int argc, char* argv[] ) { // Define the random number generator EvtRandomEngine* myRandomEngine = 0; #ifdef EVTGEN_CPP11 // Use the Mersenne-Twister generator (C++11 only) myRandomEngine = new EvtMTRandomEngine(); #else myRandomEngine = new EvtSimpleRandomEngine(); #endif if ( !TROOT::Initialized() ) { static TROOT root( "RooTuple", "RooTuple ROOT in EvtGen" ); } if ( argc == 1 ) { EvtVector4R p( 0.0, 1.0, 0.0, 0.0 ); EvtVector4R k( 0.0, 0.0, 1.0, 0.0 ); EvtTensor4C T = dual( EvtGenFunctions::directProd( p, k ) ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "p:" << p << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "k:" << k << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "T=dual(directProd(p,k)):" << T << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "T03:" << T.get( 0, 3 ) << std::endl; return 1; } EvtAbsRadCorr* radCorrEngine = 0; std::list extraModels; #ifdef EVTGEN_EXTERNAL bool convertPythiaCodes( false ); bool useEvtGenRandom( true ); EvtExternalGenList genList( convertPythiaCodes, "", "gamma", useEvtGenRandom ); radCorrEngine = genList.getPhotosModel(); extraModels = genList.getListOfModels(); #endif EvtGen myGenerator( "../DECAY.DEC", "../evt.pdl", myRandomEngine, radCorrEngine, &extraModels ); if ( !strcmp( argv[1], "file" ) ) { int nevent = atoi( argv[2] ); runFile( nevent, argv[3], myGenerator ); } if ( !strcmp( argv[1], "print" ) ) { int nevent = atoi( argv[2] ); runPrint( nevent, argv[3], myGenerator ); } if ( !strcmp( argv[1], "filevpho" ) ) { int nevent = atoi( argv[2] ); runFileVpho( nevent, argv[3], myGenerator ); } if ( !strcmp( argv[1], "test1" ) ) { int nevent = atoi( argv[2] ); runTest1( nevent, myGenerator ); } if ( !strcmp( argv[1], "chi1kstar" ) ) { int nevent = atoi( argv[2] ); runChi1Kstar( nevent, myGenerator ); } if ( !strcmp( argv[1], "test2" ) ) { int nevent = atoi( argv[2] ); runTest2( nevent, myGenerator ); } if ( !strcmp( argv[1], "omega" ) ) { int nevent = atoi( argv[2] ); runOmega( nevent, myGenerator ); } if ( !strcmp( argv[1], "alias" ) ) { runAlias(); } if ( !strcmp( argv[1], "repeat" ) ) { int nevent = atoi( argv[2] ); runRepeat( nevent ); } if ( !strcmp( argv[1], "photos" ) ) { int nevent = atoi( argv[2] ); runPhotos( nevent, myGenerator ); } if ( !strcmp( argv[1], "trackmult" ) ) { int nevent = atoi( argv[2] ); runTrackMult( nevent, myGenerator ); } if ( !strcmp( argv[1], "generic" ) ) { int nevent = atoi( argv[2] ); std::string listfile( "" ); if ( argc == 4 ) listfile = argv[3]; runGeneric( nevent, myGenerator, listfile ); } if ( !strcmp( argv[1], "finalstates" ) ) { int nevent = atoi( argv[2] ); runFinalStates( nevent, myGenerator ); } if ( !strcmp( argv[1], "kstarnunu" ) ) { int nevent = atoi( argv[2] ); runKstarnunu( nevent, myGenerator ); } if ( !strcmp( argv[1], "bsmix" ) ) { int nevent = atoi( argv[2] ); runBsmix( nevent, myGenerator ); } if ( !strcmp( argv[1], "BtoXsgamma" ) ) { int nevent = atoi( argv[2] ); runBtoXsgamma( nevent, myGenerator ); } if ( !strcmp( argv[1], "BtoK1273gamma" ) ) { int nevent = atoi( argv[2] ); runBtoK1273gamma( nevent, myGenerator ); } if ( !strcmp( argv[1], "pi0dalitz" ) ) { int nevent = atoi( argv[2] ); runPi0Dalitz( nevent, myGenerator ); } if ( !strcmp( argv[1], "ddalitz" ) ) { int nevent = atoi( argv[2] ); runDDalitz( nevent, myGenerator ); } if ( !strcmp( argv[1], "kstarll" ) ) { int nevent = atoi( argv[2] ); runKstarll( nevent, myGenerator ); } if ( !strcmp( argv[1], "kll" ) ) { int nevent = atoi( argv[2] ); runKll( nevent, myGenerator ); } if ( !strcmp( argv[1], "hll" ) ) { int nevent = atoi( argv[2] ); runHll( nevent, myGenerator, argv[3] ); } if ( !strcmp( argv[1], "vectorisr" ) ) { int nevent = atoi( argv[2] ); runVectorIsr( nevent, myGenerator ); } if ( !strcmp( argv[1], "bsquark" ) ) { int nevent = atoi( argv[2] ); runBsquark( nevent, myGenerator ); } if ( !strcmp( argv[1], "k3gamma" ) ) { int nevent = atoi( argv[2] ); runK3gamma( nevent, myGenerator ); } if ( !strcmp( argv[1], "lambda" ) ) { int nevent = atoi( argv[2] ); runLambda( nevent, myGenerator ); } if ( !strcmp( argv[1], "tautaupipi" ) ) { int nevent = atoi( argv[2] ); runTauTauPiPi( nevent, myGenerator ); } if ( !strcmp( argv[1], "tautauee" ) ) { int nevent = atoi( argv[2] ); runTauTauEE( nevent, myGenerator ); } if ( !strcmp( argv[1], "tautau2pi2pi" ) ) { int nevent = atoi( argv[2] ); runTauTau2Pi2Pi( nevent, myGenerator ); } if ( !strcmp( argv[1], "tautau3pi3pi" ) ) { int nevent = atoi( argv[2] ); runTauTau3Pi3Pi( nevent, myGenerator ); } if ( !strcmp( argv[1], "jpsikstar" ) ) { int nevent = atoi( argv[2] ); int modeInt = atoi( argv[3] ); runJPsiKstar( nevent, myGenerator, modeInt ); } if ( !strcmp( argv[1], "svvcplh" ) ) { int nevent = atoi( argv[2] ); runSVVCPLH( nevent, myGenerator ); } if ( !strcmp( argv[1], "svscplh" ) ) { int nevent = atoi( argv[2] ); runSVSCPLH( nevent, myGenerator ); } if ( !strcmp( argv[1], "ssdcp" ) ) { int nevent = atoi( argv[2] ); runSSDCP( nevent, myGenerator ); } if ( !strcmp( argv[1], "kstarstargamma" ) ) { int nevent = atoi( argv[2] ); runKstarstargamma( nevent, myGenerator ); } if ( !strcmp( argv[1], "dstarpi" ) ) { int nevent = atoi( argv[2] ); runDSTARPI( nevent, myGenerator ); } if ( !strcmp( argv[1], "etacphiphi" ) ) { int nevent = atoi( argv[2] ); runETACPHIPHI( nevent, myGenerator ); } if ( !strcmp( argv[1], "vvpipi" ) ) { int nevent = atoi( argv[2] ); runVVPiPi( nevent, myGenerator ); } if ( !strcmp( argv[1], "svvhelamp" ) ) { int nevent = atoi( argv[2] ); runSVVHelAmp( nevent, myGenerator ); } if ( !strcmp( argv[1], "partwave" ) ) { int nevent = atoi( argv[2] ); runPartWave( nevent, myGenerator ); } if ( !strcmp( argv[1], "partwave2" ) ) { int nevent = atoi( argv[2] ); runPartWave2( nevent, myGenerator ); } if ( !strcmp( argv[1], "twobody" ) ) { int nevent = atoi( argv[2] ); runTwoBody( nevent, myGenerator, argv[3], argv[4] ); } if ( !strcmp( argv[1], "pipipi" ) ) { int nevent = atoi( argv[2] ); runPiPiPi( nevent, myGenerator ); } if ( !strcmp( argv[1], "bhadronic" ) ) { int nevent = atoi( argv[2] ); runBHadronic( nevent, myGenerator ); } if ( !strcmp( argv[1], "singleb" ) ) { int nevent = atoi( argv[2] ); runSingleB( nevent, myGenerator ); } if ( !strcmp( argv[1], "pipi" ) ) { int nevent = atoi( argv[2] ); runPiPi( nevent, myGenerator ); } if ( !strcmp( argv[1], "pipipipi" ) ) { int nevent = atoi( argv[2] ); runPiPiPiPi( nevent, myGenerator ); } if ( !strcmp( argv[1], "a2pi" ) ) { int nevent = atoi( argv[2] ); runA2Pi( nevent, myGenerator ); } if ( !strcmp( argv[1], "helamp" ) ) { int nevent = atoi( argv[2] ); runHelAmp( nevent, myGenerator, argv[3], argv[4] ); } if ( !strcmp( argv[1], "helamp2" ) ) { int nevent = atoi( argv[2] ); runHelAmp2( nevent, myGenerator ); } if ( !strcmp( argv[1], "d2pi" ) ) { int nevent = atoi( argv[2] ); runD2Pi( nevent, myGenerator ); } if ( !strcmp( argv[1], "a1pi" ) ) { int nevent = atoi( argv[2] ); runA1Pi( nevent, myGenerator ); } if ( !strcmp( argv[1], "cptest" ) ) { int nevent = atoi( argv[2] ); runCPTest( nevent, myGenerator ); } if ( !strcmp( argv[1], "pipicpt" ) ) { int nevent = atoi( argv[2] ); runPiPiCPT( nevent, myGenerator ); } if ( !strcmp( argv[1], "jpsiks" ) ) { int nevent = atoi( argv[2] ); runJpsiKs( nevent, myGenerator ); } if ( !strcmp( argv[1], "dump" ) ) { int nevent = atoi( argv[2] ); runDump( nevent, myGenerator ); } if ( !strcmp( argv[1], "genericcont" ) ) { int nevent = atoi( argv[2] ); runGenericCont( nevent, myGenerator ); } if ( !strcmp( argv[1], "d1" ) ) { int nevent = atoi( argv[2] ); runD1( nevent, myGenerator ); } if ( !strcmp( argv[1], "mix" ) ) { int nevent = atoi( argv[2] ); runMix( nevent, myGenerator ); } if ( !strcmp( argv[1], "bmix" ) ) { int nevent = atoi( argv[2] ); runBMix( nevent, myGenerator, argv[3], argv[4] ); } if ( !strcmp( argv[1], "semic" ) ) { int nevent = atoi( argv[2] ); runSemic( nevent, myGenerator ); } if ( !strcmp( argv[1], "ddk" ) ) { int nevent = atoi( argv[2] ); runDDK( nevent, myGenerator ); } if ( !strcmp( argv[1], "checkmass" ) ) { int nevent = atoi( argv[2] ); int partnum = atoi( argv[3] ); runMassCheck( nevent, myGenerator, partnum ); } if ( !strcmp( argv[1], "jpsipolarization" ) ) { int nevent = atoi( argv[2] ); runJpsiPolarization( nevent, myGenerator ); } if ( !strcmp( argv[1], "phspdecaytimecut" ) ) { int nevent = atoi( argv[2] ); runPhspDecaytimeCut( nevent, myGenerator ); } if ( !strcmp( argv[1], "3bodyPhsp" ) ) { int nevent = atoi( argv[2] ); EvtRadCorr::setNeverRadCorr(); run3BPhspRegion( nevent, myGenerator ); } - if ( !strcmp( argv[1], "flatSqDalitz" ) ) { - int nevent = atoi( argv[2] ); - EvtRadCorr::setNeverRadCorr(); - runFlatSqDalitz( nevent, myGenerator ); - } - if ( !strcmp( argv[1], "4bodyPhsp" ) ) { int nevent = atoi( argv[2] ); EvtRadCorr::setNeverRadCorr(); runFourBody( nevent, myGenerator ); } //******************************************************* //test of the rotations and boosts performed in EvtGen. // Added by Lange and Ryd Jan 5,2000. //******************************************************* if ( !strcmp( argv[1], "checkrotboost" ) ) { runCheckRotBoost(); } if ( !strcmp( argv[1], "baryonic" ) ) { runBaryonic( atoi( argv[2] ), myGenerator ); } delete myRandomEngine; return 0; } void runFile( int nevent, char* fname, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); int count; char udecay_name[100]; strcpy( udecay_name, fname ); myGenerator.readUDecay( udecay_name ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); root_part->deleteTree(); } while ( count++ < nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPrint( int nevent, char* fname, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); int count; char udecay_name[100]; strcpy( udecay_name, fname ); myGenerator.readUDecay( udecay_name ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); root_part->printTree(); root_part->deleteTree(); } while ( count++ < nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runFileVpho( int nevent, char* fname, EvtGen& myGenerator ) { static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); int count; char udecay_name[100]; strcpy( udecay_name, fname ); myGenerator.readUDecay( udecay_name ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); root_part->deleteTree(); } while ( count++ < nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } /////////////// void runJpsiPolarization( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId JPSI = EvtPDL::getId( std::string( "J/psi" ) ); int count; myGenerator.readUDecay( "exampleFiles/GENERIC.DEC" ); myGenerator.readUDecay( "exampleFiles/JPSITOLL.DEC" ); TFile* file = new TFile( "jpsipolar.root", "RECREATE" ); TH1F* coshel = new TH1F( "h1", "cos hel", 50, -1.0, 1.0 ); TH1F* coshelHigh = new TH1F( "h2", "cos hel pstar gt 1.1", 50, -1.0, 1.0 ); TH1F* coshelLow = new TH1F( "h3", "cos hel pstar lt 1.1", 50, -1.0, 1.0 ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle* p = root_part; do { if ( p->getId() == JPSI ) { EvtVector4R p4psi = p->getP4Lab(); EvtVector4R p4Daug = p->getDaug( 0 )->getP4Lab(); double dcostheta = EvtDecayAngle( p_init, p4psi, p4Daug ); coshel->Fill( dcostheta ); if ( p4psi.d3mag() > 1.1 ) { coshelHigh->Fill( dcostheta ); } else { coshelLow->Fill( dcostheta ); } } p = p->nextIter( root_part ); } while ( p != 0 ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runMassCheck( int nevent, EvtGen& /*myGenerator*/, int partnum ) { int count; static EvtId myPart = EvtPDL::evtIdFromStdHep( partnum ); TFile* file = new TFile( "checkmass.root", "RECREATE" ); TH1F* mass = new TH1F( "h1", "Mass", 500, 0.0, 2.5 ); count = 1; do { mass->Fill( EvtPDL::getMass( myPart ) ); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPi0Dalitz( int nevent, EvtGen& myGenerator ) { static EvtId PI0 = EvtPDL::getId( std::string( "pi0" ) ); TFile* file = new TFile( "pi0dalitz.root", "RECREATE" ); TH1F* q2 = new TH1F( "h1", "q2", 50, 0.0, 0.02 ); int count; myGenerator.readUDecay( "exampleFiles/PI0DALITZ.DEC" ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( PI0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( PI0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtVector4R ep = root_part->getDaug( 0 )->getP4Lab(); EvtVector4R em = root_part->getDaug( 1 )->getP4Lab(); //EvtVector4R gamma=root_part->getDaug(2)->getP4Lab(); q2->Fill( ( ep + em ).mass2() ); // EvtGenReport(EVTGEN_INFO,"EvtGen") << ep << em << gamma <deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } //******************************************************************************* void runTest1( int nevent, EvtGen& myGenerator ) { // TFile *file=new TFile("test1.root", "RECREATE"); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); // int first=0; // char **second; // TApplication *theApp = new TApplication("App", &first, second); TFile* file = new TFile( "test1.root", "RECREATE", "Example" ); TH1F* costhetaB = new TH1F( "hcosthetaB", "costhetaB", 50, -1.0, 1.0 ); TH1F* phiB = new TH1F( "hphiB", "phiB", 50, -EvtConst::pi, EvtConst::pi ); TH1F* Elep = new TH1F( "hEl", "E?l!", 50, 0.0, 2.5 ); TH1F* q2 = new TH1F( "hq2", "q^2!", 44, 0.0, 11.0 ); TH1F* ctv = new TH1F( "hctv", "ctv", 50, -1.0, 1.0 ); TH1F* chi_low_ctv = new TH1F( "hcostv1", "[h] for cos[Q]?V!\"L#0", 50, 0.0, EvtConst::twoPi ); TH1F* chi_high_ctv = new TH1F( "hcostv2", "[h] for cos[Q]?V!\"G#0", 50, 0.0, EvtConst::twoPi ); TH1F* dt = new TH1F( "hdt", "dt", 50, -5.0, 5.0 ); int count; EvtVector4R p4b0, p4b0b, p4dstar, p4e, p4nu, p4d, p4pi, p4pip, p4pim; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/TEST1.DEC" ); // EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); double costhetaV; count = 1; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); p4b0 = root_part->getDaug( 0 )->getP4Lab(); p4b0b = root_part->getDaug( 1 )->getP4Lab(); p4dstar = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); p4e = root_part->getDaug( 0 )->getDaug( 1 )->getP4Lab(); p4nu = root_part->getDaug( 0 )->getDaug( 2 )->getP4Lab(); p4d = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->getP4Lab(); p4pi = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 1 )->getP4Lab(); p4pip = root_part->getDaug( 1 )->getDaug( 0 )->getP4Lab(); p4pim = root_part->getDaug( 1 )->getDaug( 1 )->getP4Lab(); costhetaB->Fill( p4b0.get( 3 ) / p4b0.d3mag() ); phiB->Fill( atan2( p4b0.get( 1 ), p4b0.get( 2 ) ) ); Elep->Fill( p4b0 * p4e / p4b0.mass() ); q2->Fill( ( p4e + p4nu ).mass2() ); dt->Fill( root_part->getDaug( 1 )->getLifetime() - root_part->getDaug( 0 )->getLifetime() ); costhetaV = EvtDecayAngle( p4b0, p4d + p4pi, p4d ); ctv->Fill( costhetaV ); if ( costhetaV < 0.0 ) { chi_low_ctv->Fill( EvtDecayAngleChi( p4b0, p4d, p4pi, p4e, p4nu ) ); } else { chi_high_ctv->Fill( EvtDecayAngleChi( p4b0, p4d, p4pi, p4e, p4nu ) ); } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); // delete theApp; // hfile.write(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } //******************************************************************************* void runDDK( int nevent, EvtGen& myGenerator ) { // TFile *file=new TFile("test1.root", "RECREATE"); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); int count; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/GENERIC.DEC" ); myGenerator.readUDecay( udecay_name ); count = 1; static EvtId kp = EvtPDL::getId( std::string( "K+" ) ); static EvtId km = EvtPDL::getId( std::string( "K-" ) ); static EvtId ks = EvtPDL::getId( std::string( "K_S0" ) ); static EvtId kl = EvtPDL::getId( std::string( "K_L0" ) ); static EvtId k0 = EvtPDL::getId( std::string( "K0" ) ); static EvtId kb = EvtPDL::getId( std::string( "anti-K0" ) ); static EvtId d0 = EvtPDL::getId( std::string( "D0" ) ); static EvtId dp = EvtPDL::getId( std::string( "D+" ) ); static EvtId dm = EvtPDL::getId( std::string( "D-" ) ); static EvtId db = EvtPDL::getId( std::string( "anti-D0" ) ); static EvtIdSet theKs( kp, km, ks, kl, k0, kb ); static EvtIdSet theDs( d0, dp, dm, db ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); static EvtId BP = EvtPDL::getId( std::string( "B+" ) ); static EvtId BM = EvtPDL::getId( std::string( "B-" ) ); static EvtIdSet theBs( B0B, B0, BP, BM ); int nDDK = 0; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle* theB01 = root_part->getDaug( 0 ); EvtParticle* theB02 = root_part->getDaug( 1 ); int nD = 0; int nK = 0; EvtParticle* p = theB01; do { EvtId type = p->getId(); EvtId typePar = p->getParent()->getId(); if ( theDs.contains( type ) ) nD++; if ( theKs.contains( type ) && theBs.contains( typePar ) ) nK++; p = p->nextIter( theB01 ); } while ( p != 0 ); if ( nD == 2 && nK == 1 ) nDDK++; nD = 0; nK = 0; p = theB02; do { EvtId type = p->getId(); EvtId typePar = p->getParent()->getId(); if ( theDs.contains( type ) ) nD++; if ( theKs.contains( type ) && theBs.contains( typePar ) ) nK++; p = p->nextIter( theB02 ); } while ( p != 0 ); if ( nD == 2 && nK == 1 ) nDDK++; root_part->deleteTree(); } while ( count++ < nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << nDDK << " " << ( count - 1 ) << " " << nDDK / float( 2 * ( count - 1 ) ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } //******************************************************************************* void runTest2( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "test2.root", "RECREATE" ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); TH1F* costhetaB = new TH1F( "h1", "cos[Q]?B!", 50, -1.0, 1.0 ); TH1F* phiB = new TH1F( "h2", "[f]?B!", 50, -EvtConst::pi, EvtConst::pi ); TH1F* dt = new TH1F( "h3", "[D]t", 100, -5.0, 5.0 ); TH1F* costhetaJpsi = new TH1F( "h4", "cos[Q]?J/[y]!", 50, -1.0, 1.0 ); TH1F* costhetaKstar = new TH1F( "h5", "cos[Q]?K*!", 50, -1.0, 1.0 ); TH1F* chi = new TH1F( "h6", "[h]", 50, 0.0, EvtConst::twoPi ); TH1F* chi1 = new TH1F( "h26", "[h] [D]t\"L#0", 50, 0.0, EvtConst::twoPi ); TH1F* chi2 = new TH1F( "h27", "[h] [D]t\"G#0", 50, 0.0, EvtConst::twoPi ); TH1F* costhetaomega = new TH1F( "h7", "costhetaomega", 50, -1.0, 1.0 ); TH1F* costhetaomega1 = new TH1F( "h20", "costhetaomega1", 50, -1.0, 1.0 ); TH1F* costhetaomega2 = new TH1F( "h21", "costhetaomega2", 50, -1.0, 1.0 ); TH1F* costhetaomega3 = new TH1F( "h22", "costhetaomega3", 50, -1.0, 1.0 ); TH1F* omegaamp = new TH1F( "h8", "omegaamp", 50, 0.0, 0.05 ); TH1F* omegaamp1 = new TH1F( "h9", "omegaamp1", 50, 0.0, 0.05 ); TH1F* omegaamp2 = new TH1F( "h10", "omegaamp2", 50, 0.0, 0.05 ); TH1F* omegaamp3 = new TH1F( "h11", "omegaamp3", 50, 0.0, 0.05 ); TH2F* chi1vscoskstarl = new TH2F( "h30", "[h] vs. cos[Q]?J/[y]! [D]t\"L#0", 20, 0.0, EvtConst::twoPi, 20, -1.0, 1.0 ); TH2F* chi1vscoskstarg = new TH2F( "h31", "[h] vs. cos[Q]?J/[y]! [D]t\"G#0", 20, 0.0, EvtConst::twoPi, 20, -1.0, 1.0 ); int count = 1; EvtVector4R p4_b0, p4_b0b, p4_psi, p4_kstar, p4_mup, p4_mum; EvtVector4R p4_kz, p4_pi0, p4_pi1, p4_pi2, p4_pi3, p4_omega; EvtVector4R p4_pi1_omega, p4_pi2_omega, p4_pi3_omega; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/TEST2.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); p4_b0 = root_part->getDaug( 0 )->getP4Lab(); p4_b0b = root_part->getDaug( 1 )->getP4Lab(); p4_psi = root_part->getDaug( 1 )->getDaug( 0 )->getP4Lab(); p4_kstar = root_part->getDaug( 1 )->getDaug( 1 )->getP4Lab(); p4_mup = root_part->getDaug( 1 )->getDaug( 0 )->getDaug( 0 )->getP4Lab(); p4_mum = root_part->getDaug( 1 )->getDaug( 0 )->getDaug( 1 )->getP4Lab(); p4_kz = root_part->getDaug( 1 )->getDaug( 1 )->getDaug( 0 )->getP4Lab(); p4_pi0 = root_part->getDaug( 1 )->getDaug( 1 )->getDaug( 1 )->getP4Lab(); p4_omega = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); p4_pi1 = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->getP4Lab(); p4_pi2 = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 1 )->getP4Lab(); p4_pi3 = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 2 )->getP4Lab(); //get momentum in the omega restframe p4_pi1_omega = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->getP4(); p4_pi2_omega = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 1 )->getP4(); p4_pi3_omega = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 2 )->getP4(); EvtVector3R p3_perp = cross( EvtVector3R( p4_pi2_omega.get( 0 ), p4_pi2_omega.get( 1 ), p4_pi2_omega.get( 2 ) ), EvtVector3R( p4_pi3_omega.get( 0 ), p4_pi3_omega.get( 1 ), p4_pi3_omega.get( 2 ) ) ); EvtVector4R p4_perp( p3_perp.d3mag(), p3_perp.get( 0 ), p3_perp.get( 1 ), p3_perp.get( 2 ) ); root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->setP4( p4_perp ); p4_perp = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->getP4Lab(); EvtVector4R p4_perpprime = p4_omega - p4_perp; double d_omegaamp = EvtVector3R( p4_pi1_omega.get( 0 ), p4_pi1_omega.get( 1 ), p4_pi1_omega.get( 2 ) ) * p3_perp; d_omegaamp *= d_omegaamp; d_omegaamp *= 20.0; double d_dt = root_part->getDaug( 1 )->getLifetime() - root_part->getDaug( 0 )->getLifetime(); double d_costhetaJpsi = EvtDecayAngle( p4_b0b, p4_mup + p4_mum, p4_mup ); double d_costhetaKstar = EvtDecayAngle( p4_b0b, p4_pi0 + p4_kz, p4_pi0 ); double d_chi = EvtDecayAngleChi( p4_b0b, p4_pi0, p4_kz, p4_mup, p4_mum ); costhetaB->Fill( p4_b0.get( 3 ) / p4_b0.d3mag() ); phiB->Fill( atan2( p4_b0.get( 1 ), p4_b0.get( 2 ) ) ); dt->Fill( d_dt ); costhetaJpsi->Fill( d_costhetaJpsi ); costhetaKstar->Fill( d_costhetaKstar ); chi->Fill( d_chi ); if ( d_dt < 0.0 ) { chi1->Fill( d_chi ); chi1vscoskstarl->Fill( d_chi, d_costhetaJpsi, 1.0 ); } if ( d_dt > 0.0 ) { chi2->Fill( d_chi ); chi1vscoskstarg->Fill( d_chi, d_costhetaJpsi, 1.0 ); } double d_costhetaomega = EvtDecayAngle( p4_b0b, p4_perp + p4_perpprime, p4_perp ); costhetaomega->Fill( d_costhetaomega ); if ( d_omegaamp < 0.001 ) costhetaomega1->Fill( d_costhetaomega ); if ( d_omegaamp > 0.02 ) costhetaomega2->Fill( d_costhetaomega ); if ( std::fabs( d_omegaamp - 0.015 ) < 0.005 ) costhetaomega3->Fill( d_costhetaomega ); omegaamp->Fill( d_omegaamp ); if ( d_costhetaomega < -0.5 ) omegaamp1->Fill( d_omegaamp ); if ( d_costhetaomega > 0.5 ) omegaamp2->Fill( d_omegaamp ); if ( std::fabs( d_costhetaomega ) < 0.5 ) omegaamp3->Fill( d_omegaamp ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runOmega( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "omega.root", "RECREATE" ); static EvtId OMEGA = EvtPDL::getId( std::string( "omega" ) ); TH2F* dalitz = new TH2F( "h1", "E1 vs E2", 50, 0.0, 0.5, 50, 0.0, 0.5 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/OMEGA.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMeanMass( OMEGA ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( OMEGA, p_init ); //root_part->setDiagonalSpinDensity(); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); dalitz->Fill( root_part->getDaug( 0 )->getP4().get( 0 ), root_part->getDaug( 1 )->getP4().get( 0 ), 1.0 ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runChi1Kstar( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "chi1kstar.root", "RECREATE" ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); TH1F* costhetaChi1 = new TH1F( "h1", "cos[Q]?J/[x]!", 50, -1.0, 1.0 ); TH1F* costhetaKstar = new TH1F( "h2", "cos[Q]?K*!", 50, -1.0, 1.0 ); TH1F* chi = new TH1F( "h3", "[x]", 50, -EvtConst::pi, EvtConst::pi ); int count = 1; EvtVector4R p4_b, p4_chi, p4_kstar, p4_gamma, p4_psi, p4_k, p4_p; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/CHI1KSTAR.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); myGenerator.generateDecay( root_part ); p4_b = root_part->getP4Lab(); p4_chi = root_part->getDaug( 0 )->getP4Lab(); p4_kstar = root_part->getDaug( 1 )->getP4Lab(); p4_psi = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); p4_gamma = root_part->getDaug( 0 )->getDaug( 1 )->getP4Lab(); p4_k = root_part->getDaug( 1 )->getDaug( 0 )->getP4Lab(); p4_p = root_part->getDaug( 1 )->getDaug( 1 )->getP4Lab(); double d_costhetaChi1 = EvtDecayAngle( p4_b, p4_chi, p4_psi ); double d_costhetaKstar = EvtDecayAngle( p4_b, p4_kstar, p4_k ); double d_chi = EvtDecayAngleChi( p4_b, p4_k, p4_p, p4_psi, p4_gamma ); if ( d_chi > EvtConst::pi ) d_chi -= EvtConst::twoPi; costhetaChi1->Fill( d_costhetaChi1 ); costhetaKstar->Fill( d_costhetaKstar ); chi->Fill( d_chi ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runAlias() { EvtId idpip = EvtPDL::getId( std::string( "pi+" ) ); EvtPDL::alias( idpip, std::string( "my_pi+" ) ); EvtId myidpip = EvtPDL::getId( std::string( "my_pi+" ) ); EvtId idpim = EvtPDL::getId( std::string( "pi-" ) ); EvtPDL::alias( idpim, std::string( "my_pi-" ) ); EvtId myidpim = EvtPDL::getId( std::string( "my_pi-" ) ); EvtId idpi0 = EvtPDL::getId( std::string( "pi0" ) ); EvtPDL::alias( idpi0, std::string( "my_pi0" ) ); EvtId myidpi0 = EvtPDL::getId( std::string( "my_pi0" ) ); EvtPDL::aliasChgConj( myidpip, myidpim ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Id pi+:" << idpip << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Id pi-:" << idpim << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Id pi0:" << idpi0 << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Id my_pi+:" << myidpip << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Id my_pi-:" << myidpim << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Id my_pi0:" << myidpi0 << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Chg conj pi+:" << EvtPDL::chargeConj( idpip ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Chg conj pi-:" << EvtPDL::chargeConj( idpim ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Chg conj pi0:" << EvtPDL::chargeConj( idpi0 ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Chg conj my_pi+:" << EvtPDL::chargeConj( myidpip ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Chg conj my_pi-:" << EvtPDL::chargeConj( myidpim ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Chg conj my_pi0:" << EvtPDL::chargeConj( myidpi0 ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runRepeat( int nevent ) { int i; for ( i = 0; i < nevent; i++ ) { EvtDecayTable::getInstance()->readDecayFile( std::string( "../DECAY.DEC" ) ); } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPhotos( int nevent, EvtGen& myGenerator ) { static EvtId PSI = EvtPDL::getId( std::string( "J/psi" ) ); TFile* file = new TFile( "photos.root", "RECREATE" ); TH1F* mee = new TH1F( "h1", "mee", 60, 3.0, 3.12 ); int count = 1; EvtVector4R e1, e2; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/PHOTOS.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( PSI ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( PSI, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); e1 = root_part->getDaug( 0 )->getP4Lab(); e2 = root_part->getDaug( 1 )->getP4Lab(); mee->Fill( ( e1 + e2 ).mass() ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runFinalStates( int nevent, EvtGen& myGenerator ) { //Parse the table of particles to find.. EvtParser parser; parser.read( std::string( "exampleFiles/finalstates.list" ) ); std::vector dList[20]; int dListNum[20]; std::vector* dListItem = 0; std::string dListName[20]; int ik, lk; std::string tk = ""; int tline = -1; std::string parent; for ( ik = 0; ik < parser.getNToken(); ik++ ) { lk = tline; tline = parser.getLineofToken( ik ); tk = parser.getToken( ik ); if ( lk != tline && tline > 2 ) { if ( tline > 1 ) { dList[tline - 3] = *dListItem; dListItem = new std::vector; dListNum[tline - 3] = 0; dListName[tline - 2] = parser.getToken( ik ); } } else { if ( tline == 1 ) { //This is the parent particle name parent = parser.getToken( ik ); dListItem = new std::vector; } else { //This is one of the daughters if ( tline != 2 || ( lk == tline ) ) { dListItem->push_back( parser.getToken( ik ) ); } if ( tline == 2 && ( lk != tline ) ) { dListName[tline - 2] = parser.getToken( ik ); } } } } dList[tline - 2] = *dListItem; dListNum[tline - 2] = 0; static EvtId parId = EvtPDL::getId( parent ); int count = 0; do { if ( count == 1000 * ( count / 1000 ) ) { //if (count==1*(count/1)) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Event:" << count << std::endl; //EvtGenReport(EVTGEN_INFO,"EvtGen") << HepRandom::getTheSeed()<setVectorSpinDensity(); } else { root_part->setDiagonalSpinDensity(); } myGenerator.generateDecay( root_part ); EvtParticle* p = root_part; std::vector fs = findFinalState( p ); int j; for ( j = 0; j < ( tline - 1 ); j++ ) { std::vector temp = dList[j]; if ( temp.size() == fs.size() ) { bool foundIt = true; unsigned int k, l; std::vector alreadyUsed( temp.size() ); for ( k = 0; k < temp.size(); k++ ) { bool foundThisOne = false; for ( l = 0; l < temp.size(); l++ ) { if ( k == 0 ) alreadyUsed[l] = false; if ( foundThisOne || alreadyUsed[l] ) continue; if ( temp[k] == fs[l] ) { alreadyUsed[l] = true; foundThisOne = true; // EvtGenReport(EVTGEN_INFO,"EvtGen") << "found daughter " << k << " " << l << std::endl; } } if ( !foundThisOne ) foundIt = false; } if ( foundIt ) { //EvtGenReport(EVTGEN_INFO,"EvtGen") << "found a cand \n"; (histo1[j])->Fill(0.5); //EvtGenReport(EVTGEN_INFO,"EvtGen") << "found one " << j << std::endl; dListNum[j]++; } } } root_part->deleteTree(); count++; } while ( count < nevent ); int j; for ( j = 0; j < ( tline - 1 ); j++ ) EvtGenReport( EVTGEN_INFO, "EvtGen" ) << dListName[j].c_str() << " " << j << " " << dListNum[j] << " " << count << " " << ( dListNum[j] / ( 1.0 * count ) ) << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } std::vector findFinalState( EvtParticle* tree ) { EvtParticle* p = tree; std::vector fs; static EvtId ep = EvtPDL::getId( std::string( "e+" ) ); static EvtId em = EvtPDL::getId( std::string( "e-" ) ); static EvtId kp = EvtPDL::getId( std::string( "K+" ) ); static EvtId km = EvtPDL::getId( std::string( "K-" ) ); static EvtId mup = EvtPDL::getId( std::string( "mu+" ) ); static EvtId mum = EvtPDL::getId( std::string( "mu-" ) ); static EvtId pip = EvtPDL::getId( std::string( "pi+" ) ); static EvtId pim = EvtPDL::getId( std::string( "pi-" ) ); static EvtId pi0 = EvtPDL::getId( std::string( "pi0" ) ); static EvtId pr = EvtPDL::getId( std::string( "p+" ) ); static EvtId apr = EvtPDL::getId( std::string( "anti-p-" ) ); static EvtId ne = EvtPDL::getId( std::string( "n0" ) ); static EvtId ane = EvtPDL::getId( std::string( "anti-n0" ) ); do { EvtId type = p->getId(); if ( type == ep ) fs.push_back( std::string( "e+" ) ); if ( type == em ) fs.push_back( std::string( "e-" ) ); if ( type == mup ) fs.push_back( std::string( "mu+" ) ); if ( type == mum ) fs.push_back( std::string( "mu-" ) ); if ( type == kp ) fs.push_back( std::string( "K+" ) ); if ( type == km ) fs.push_back( std::string( "K-" ) ); if ( type == pip ) fs.push_back( std::string( "pi+" ) ); if ( type == pim ) fs.push_back( std::string( "pi-" ) ); if ( type == pi0 ) fs.push_back( std::string( "pi0" ) ); if ( type == pr ) fs.push_back( std::string( "p+" ) ); if ( type == apr ) fs.push_back( std::string( "anti-p-" ) ); if ( type == ne ) fs.push_back( std::string( "n0" ) ); if ( type == ane ) fs.push_back( std::string( "anti-n0" ) ); p = p->nextIter(); } while ( p != 0 ); return fs; } void runTrackMult( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "trackmult.root", "RECREATE" ); TH1F* trackAll = new TH1F( "trackAll", "trackAll", 12, 1.0, 25.0 ); TH1F* trackNoSL = new TH1F( "trackNoSL", "trackNoSL", 12, 1.0, 25.0 ); TH1F* track1SL = new TH1F( "track1SL", "track1SL", 12, 1.0, 25.0 ); TH1F* track2SL = new TH1F( "track2SL", "track2SL", 12, 1.0, 25.0 ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); static EvtId BP = EvtPDL::getId( std::string( "B+" ) ); static EvtId BM = EvtPDL::getId( std::string( "B-" ) ); //look for these tracks in generic events static EvtId ep = EvtPDL::getId( std::string( "e+" ) ); static EvtId em = EvtPDL::getId( std::string( "e-" ) ); static EvtId mup = EvtPDL::getId( std::string( "mu+" ) ); static EvtId mum = EvtPDL::getId( std::string( "mu-" ) ); static EvtId pip = EvtPDL::getId( std::string( "pi+" ) ); static EvtId pim = EvtPDL::getId( std::string( "pi-" ) ); static EvtId kp = EvtPDL::getId( std::string( "K+" ) ); static EvtId km = EvtPDL::getId( std::string( "K-" ) ); static EvtId pp = EvtPDL::getId( std::string( "p+" ) ); static EvtId pm = EvtPDL::getId( std::string( "anti-p-" ) ); static EvtIdSet theTracks( ep, em, mup, mum, pip, pim, kp, km, pp, pm ); static EvtIdSet theLeptons( ep, em, mup, mum ); static EvtIdSet theBs( B0, B0B, BP, BM ); int count = 1; EvtParticle* p; myGenerator.readUDecay( "exampleFiles/GENERIC.DEC" ); int totTracks = 0; int totTracksNoSL = 0; int totTracks1SL = 0; int totTracks2SL = 0; int totNoSL = 0; int tot1SL = 0; int tot2SL = 0; do { int evTracks = 0; if ( count == 1000 * ( count / 1000 ) ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << count << std::endl; //EvtGenReport(EVTGEN_INFO,"EvtGen") << HepRandom::getTheSeed()<setVectorSpinDensity(); myGenerator.generateDecay( root_part ); p = root_part; int howManySL = 0; do { if ( theTracks.contains( p->getId() ) ) { totTracks += 1; evTracks += 1; } if ( theLeptons.contains( p->getId() ) ) { if ( p->getParent() ) { if ( theBs.contains( p->getParent()->getId() ) ) howManySL += 1; } } p = p->nextIter( root_part ); } while ( p != 0 ); //Now need to figure out which histogram to book trackAll->Fill( evTracks ); if ( howManySL == 0 ) { trackNoSL->Fill( evTracks ); totNoSL += 1; totTracksNoSL += evTracks; } if ( howManySL == 1 ) { track1SL->Fill( evTracks ); tot1SL += 1; totTracks1SL += evTracks; } if ( howManySL == 2 ) { track2SL->Fill( evTracks ); tot2SL += 1; totTracks2SL += evTracks; } root_part->deleteTree(); } while ( count++ < nevent ); double aveMulti = float( totTracks ) / float( nevent ); double aveMultiNoSL = float( totTracksNoSL ) / float( totNoSL ); double aveMulti1SL = float( totTracks1SL ) / float( tot1SL ); double aveMulti2SL = float( totTracks2SL ) / float( tot2SL ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Your average multiplicity=" << aveMulti << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Your average multiplicity for no B->semileptonic events=" << aveMultiNoSL << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Your average multiplicity for 1 B->semileptonic events=" << aveMulti1SL << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Your average multiplicity for 2 B->semileptonic events=" << aveMulti2SL << std::endl; file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runGeneric( int neventOrig, EvtGen& myGenerator, std::string listfile ) { int nevent = abs( neventOrig ); //Parse the table of particles to find.. TFile* file = new TFile( "generic.root", "RECREATE" ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); static EvtId BP = EvtPDL::getId( std::string( "B+" ) ); static EvtId BM = EvtPDL::getId( std::string( "B-" ) ); static EvtIdSet theBs( B0B, B0, BP, BM ); static EvtIdSet theB0B( B0B ); static EvtIdSet theB0( B0 ); static EvtIdSet theBP( BP ); static EvtIdSet theBM( BM ); static EvtId D0 = EvtPDL::getId( std::string( "D0" ) ); static EvtId D0B = EvtPDL::getId( std::string( "anti-D0" ) ); static EvtId DP = EvtPDL::getId( std::string( "D+" ) ); static EvtId DM = EvtPDL::getId( std::string( "D-" ) ); static EvtIdSet theDs( D0B, D0, DP, DM ); static EvtIdSet theD0B( D0B ); static EvtIdSet theD0( D0 ); static EvtIdSet theDP( DP ); static EvtIdSet theDM( DM ); int count; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/GENERIC.DEC" ); myGenerator.readUDecay( udecay_name ); if ( listfile != "" ) { EvtParser parser; if ( parser.read( listfile ) != 0 ) { EvtGenReport( EVTGEN_ERROR, "EvtGen" ) << "Will terminate." << std::endl; exit( -1 ); } std::vector histo1( parser.getNToken() ); std::vector histo2( parser.getNToken() ); std::vector massHisto( parser.getNToken() ); int ik; std::string tk, tkname; for ( ik = 0; ik < ( parser.getNToken() / 2 ); ik++ ) { tk = parser.getToken( 2 * ik ); tkname = parser.getToken( 1 + 2 * ik ); histo1[ik] = new TH1F( tkname.c_str(), tkname.c_str(), 30, 0.0, 3.0 ); char* directName; directName = new char[( strlen( tkname.c_str() ) + 8 )]; directName = strcpy( directName, tkname.c_str() ); directName = strcat( directName, "Direct" ); histo2[ik] = new TH1F( directName, directName, 30, 0.0, 3.0 ); delete directName; char* massName; massName = new char[( strlen( tkname.c_str() ) + 4 )]; massName = strcpy( massName, tkname.c_str() ); massName = strcat( massName, "Mass" ); massHisto[ik] = new TH1F( massName, massName, 3000, 0.0, 5.0 ); delete massName; } count = 1; std::vector temp( parser.getNToken() / 2, 0 ); std::vector tempB( parser.getNToken() / 2, 0 ); std::vector tempB0B( parser.getNToken() / 2, 0 ); std::vector tempB0( parser.getNToken() / 2, 0 ); std::vector tempBP( parser.getNToken() / 2, 0 ); std::vector tempBM( parser.getNToken() / 2, 0 ); std::vector tempD( parser.getNToken() / 2, 0 ); std::vector tempD0B( parser.getNToken() / 2, 0 ); std::vector tempD0( parser.getNToken() / 2, 0 ); std::vector tempDP( parser.getNToken() / 2, 0 ); std::vector tempDM( parser.getNToken() / 2, 0 ); do { //EvtGenReport(EVTGEN_INFO,"EvtGen") << "new event\n"; if ( count == 1000 * ( count / 1000 ) ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << count << std::endl; //EvtGenReport(EVTGEN_INFO,"EvtGen") << HepRandom::getTheSeed()< 0 ) { root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); } else { root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); } root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); //EvtStdHep stdhep; //stdhep.init(); //root_part->makeStdHep(stdhep); //EvtGenReport(EVTGEN_INFO,"EvtGen") <printTree(); root_part->deleteTree(); } while ( count++ < nevent ); int itok; std::string token; for ( itok = 0; itok < ( parser.getNToken() / 2 ); itok++ ) { token = parser.getToken( 2 * itok ); float br = 0.5 * float( temp[itok] ) / float( nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Found " << temp[itok] << " " << token.c_str() << " in " << nevent << " events. Average number of " << token.c_str() << " per B meson=" << br << std::endl; br = 0.5 * float( tempB[itok] ) / float( nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Found " << tempB[itok] << " " << token.c_str() << " produced directly in decays of B mesons avg. br.fr.=" << br << std::endl; br = 2.0 * float( tempB0[itok] ) / float( nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Found " << tempB0[itok] << " " << token.c_str() << " in decay tree of B0, br.fr.=" << br << std::endl; br = 2.0 * float( tempB0B[itok] ) / float( nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Found " << tempB0B[itok] << " " << token.c_str() << " in decay tree of anti-B0, br.fr.=" << br << std::endl; br = 2.0 * float( tempBP[itok] ) / float( nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Found " << tempBP[itok] << " " << token.c_str() << " in decay tree of B+, br.fr.=" << br << std::endl; br = 2.0 * float( tempBM[itok] ) / float( nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Found " << tempBM[itok] << " " << token.c_str() << " in decay tree of B-, br.fr.=" << br << std::endl; // br=0.5*float(tempD[itok])/float(numd0+numd0b+numdm+numdp); // EvtGenReport(EVTGEN_INFO,"EvtGen") << "Found "< 0 ) { root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); } else { root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); } root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); root_part->deleteTree(); } while ( count++ < nevent ); } file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runKstarnunu( int nevent, EvtGen& myGenerator ) { static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); //static EvtId B0B=EvtPDL::getId(std::string("anti-B0")); TFile* file = new TFile( "kstarnunu.root", "RECREATE" ); TH1F* q2 = new TH1F( "h1", "q2", 50, 0.0, 25.0 ); TH1F* enu = new TH1F( "h2", "Neutrino energy", 50, 0.0, 5.0 ); TH1F* x = new TH1F( "h3", "Total neutrino energy/B mass", 50, 0.5, 0.9 ); int count; EvtVector4R kstar, nu, nub; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/KSTARNUNU.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); kstar = root_part->getDaug( 0 )->getP4Lab(); nu = root_part->getDaug( 1 )->getP4Lab(); nub = root_part->getDaug( 2 )->getP4Lab(); q2->Fill( ( nu + nub ).mass2() ); enu->Fill( nu.get( 0 ) ); x->Fill( ( nu.get( 0 ) + nub.get( 0 ) ) / root_part->mass() ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runBsmix( int nevent, EvtGen& myGenerator ) { static EvtId BS0 = EvtPDL::getId( std::string( "B_s0" ) ); static EvtId BSB = EvtPDL::getId( std::string( "anti-B_s0" ) ); TFile* file = new TFile( "bsmix.root", "RECREATE" ); TH1F* tmix = new TH1F( "h1", "tmix (mm)", 100, 0.0, 5.0 ); TH1F* tnomix = new TH1F( "h2", "tnomix (mm)", 100, 0.0, 5.0 ); int count; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/BSMIX.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( BS0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( BS0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); double t = root_part->getLifetime(); int mix = 0; if ( root_part->getNDaug() == 1 ) { if ( root_part->getDaug( 0 )->getId() == BSB ) { mix = 1; } } if ( mix == 0 ) tnomix->Fill( t ); if ( mix == 1 ) tmix->Fill( t ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runSemic( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId EP = EvtPDL::getId( std::string( "e+" ) ); static EvtId EM = EvtPDL::getId( std::string( "e-" ) ); static EvtId DST0 = EvtPDL::getId( std::string( "D*0" ) ); static EvtId DSTB = EvtPDL::getId( std::string( "anti-D*0" ) ); static EvtId DSTP = EvtPDL::getId( std::string( "D*+" ) ); static EvtId DSTM = EvtPDL::getId( std::string( "D*-" ) ); static EvtId D0 = EvtPDL::getId( std::string( "D0" ) ); static EvtId D0B = EvtPDL::getId( std::string( "anti-D0" ) ); static EvtId DP = EvtPDL::getId( std::string( "D+" ) ); static EvtId DM = EvtPDL::getId( std::string( "D-" ) ); static EvtId D1P1P = EvtPDL::getId( std::string( "D_1+" ) ); static EvtId D1P1N = EvtPDL::getId( std::string( "D_1-" ) ); static EvtId D1P10 = EvtPDL::getId( std::string( "D_10" ) ); static EvtId D1P1B = EvtPDL::getId( std::string( "anti-D_10" ) ); static EvtId D3P2P = EvtPDL::getId( std::string( "D_2*+" ) ); static EvtId D3P2N = EvtPDL::getId( std::string( "D_2*-" ) ); static EvtId D3P20 = EvtPDL::getId( std::string( "D_2*0" ) ); static EvtId D3P2B = EvtPDL::getId( std::string( "anti-D_2*0" ) ); static EvtId D3P1P = EvtPDL::getId( std::string( "D'_1+" ) ); static EvtId D3P1N = EvtPDL::getId( std::string( "D'_1-" ) ); static EvtId D3P10 = EvtPDL::getId( std::string( "D'_10" ) ); static EvtId D3P1B = EvtPDL::getId( std::string( "anti-D'_10" ) ); static EvtId D3P0P = EvtPDL::getId( std::string( "D_0*+" ) ); static EvtId D3P0N = EvtPDL::getId( std::string( "D_0*-" ) ); static EvtId D3P00 = EvtPDL::getId( std::string( "D_0*0" ) ); static EvtId D3P0B = EvtPDL::getId( std::string( "anti-D_0*0" ) ); static EvtId D23S1P = EvtPDL::getId( std::string( "D*(2S)+" ) ); static EvtId D23S1N = EvtPDL::getId( std::string( "D*(2S)-" ) ); static EvtId D23S10 = EvtPDL::getId( std::string( "D*(2S)0" ) ); static EvtId D23S1B = EvtPDL::getId( std::string( "anti-D*(2S)0" ) ); static EvtIdSet radExitDstar( D23S1P, D23S1N, D23S10, D23S1B ); TFile* file = new TFile( "semic.root", "RECREATE" ); TH1F* Dpe_q2 = new TH1F( "h11", "q2 for B0B ->D+ e- nu", 50, 0.0, 12.0 ); TH1F* Dpe_elep = new TH1F( "h12", "Elep for B0B ->D+ e- nu", 50, 0.0, 2.5 ); TH1F* Dme_q2 = new TH1F( "h13", "q2 for B0 ->D- e+ nu", 50, 0.0, 12.0 ); TH1F* Dme_elep = new TH1F( "h14", "Elep for B0 ->D- e+ nu", 50, 0.0, 2.5 ); TH1F* D0e_q2 = new TH1F( "h15", "q2 for B- ->D0 e- nu", 50, 0.0, 12.0 ); TH1F* D0e_elep = new TH1F( "h16", "Elep for B- ->D0 e- nu", 50, 0.0, 2.5 ); TH1F* D0Be_q2 = new TH1F( "h17", "q2 for B+ ->D0B e+ nu", 50, 0.0, 12.0 ); TH1F* D0Be_elep = new TH1F( "h18", "Elep for B+ ->D0B e+ nu", 50, 0.0, 2.5 ); TH1F* Dstpe_q2 = new TH1F( "h21", "q2 for B0B ->D*+ e- nu", 50, 0.0, 12.0 ); TH1F* Dstpe_elep = new TH1F( "h22", "Elep for B0B ->D*+ e- nu", 50, 0.0, 2.5 ); TH1F* Dstme_q2 = new TH1F( "h23", "q2 for B0 ->D*- e+ nu", 50, 0.0, 12.0 ); TH1F* Dstme_elep = new TH1F( "h24", "Elep for B0 ->D*- e+ nu", 50, 0.0, 2.5 ); TH1F* Dst0e_q2 = new TH1F( "h25", "q2 for B- ->D*0 e- nu", 50, 0.0, 12.0 ); TH1F* Dst0e_elep = new TH1F( "h26", "Elep for B*- ->D*0 e- nu", 50, 0.0, 2.5 ); TH1F* Dst0Be_q2 = new TH1F( "h27", "q2 for B+ ->D*0B e+ nu", 50, 0.0, 12.0 ); TH1F* Dst0Be_elep = new TH1F( "h28", "Elep for B+ ->D*0B e+ nu", 50, 0.0, 2.5 ); TH1F* D1P1pe_q2 = new TH1F( "h31", "q2 for B0B ->1P1+ e- nu", 50, 0.0, 12.0 ); TH1F* D1P1pe_elep = new TH1F( "h32", "Elep for B0B ->1P1+ e- nu", 50, 0.0, 2.5 ); TH1F* D1P1me_q2 = new TH1F( "h33", "q2 for B0 ->1P1- e+ nu", 50, 0.0, 12.0 ); TH1F* D1P1me_elep = new TH1F( "h34", "Elep for B0 ->1P1- e+ nu", 50, 0.0, 2.5 ); TH1F* D1P10e_q2 = new TH1F( "h35", "q2 for B- ->1P10 e- nu", 50, 0.0, 12.0 ); TH1F* D1P10e_elep = new TH1F( "h36", "Elep for B*- ->1P10 e- nu", 50, 0.0, 2.5 ); TH1F* D1P10Be_q2 = new TH1F( "h37", "q2 for B+ ->1P1B e+ nu", 50, 0.0, 12.0 ); TH1F* D1P10Be_elep = new TH1F( "h38", "Elep for B+ ->1P1B e+ nu", 50, 0.0, 2.5 ); TH1F* D3P0pe_q2 = new TH1F( "h41", "q2 for B0B ->3P0+ e- nu", 50, 0.0, 12.0 ); TH1F* D3P0pe_elep = new TH1F( "h42", "Elep for B0B ->3P0+ e- nu", 50, 0.0, 2.5 ); TH1F* D3P0me_q2 = new TH1F( "h43", "q2 for B0 ->3P0- e+ nu", 50, 0.0, 12.0 ); TH1F* D3P0me_elep = new TH1F( "h44", "Elep for B0 ->3P0- e+ nu", 50, 0.0, 2.5 ); TH1F* D3P00e_q2 = new TH1F( "h45", "q2 for B- ->3P00 e- nu", 50, 0.0, 12.0 ); TH1F* D3P00e_elep = new TH1F( "h46", "Elep for B*- ->3P00 e- nu", 50, 0.0, 2.5 ); TH1F* D3P00Be_q2 = new TH1F( "h47", "q2 for B+ ->3P0B e+ nu", 50, 0.0, 12.0 ); TH1F* D3P00Be_elep = new TH1F( "h48", "Elep for B+ ->3P0B e+ nu", 50, 0.0, 2.5 ); TH1F* D3P1pe_q2 = new TH1F( "h51", "q2 for B0B ->3P1+ e- nu", 50, 0.0, 12.0 ); TH1F* D3P1pe_elep = new TH1F( "h52", "Elep for B0B ->3P1+ e- nu", 50, 0.0, 2.5 ); TH1F* D3P1me_q2 = new TH1F( "h53", "q2 for B0 ->3P1- e+ nu", 50, 0.0, 12.0 ); TH1F* D3P1me_elep = new TH1F( "h54", "Elep for B0 ->3P1- e+ nu", 50, 0.0, 2.5 ); TH1F* D3P10e_q2 = new TH1F( "h55", "q2 for B- ->3P10 e- nu", 50, 0.0, 12.0 ); TH1F* D3P10e_elep = new TH1F( "h56", "Elep for B*- ->3P10 e- nu", 50, 0.0, 2.5 ); TH1F* D3P10Be_q2 = new TH1F( "h57", "q2 for B+ ->3P1B e+ nu", 50, 0.0, 12.0 ); TH1F* D3P10Be_elep = new TH1F( "h58", "Elep for B+ ->3P1B e+ nu", 50, 0.0, 2.5 ); TH1F* D3P2pe_q2 = new TH1F( "h61", "q2 for B0B ->3P2+ e- nu", 50, 0.0, 12.0 ); TH1F* D3P2pe_elep = new TH1F( "h62", "Elep for B0B ->3P2+ e- nu", 50, 0.0, 2.5 ); TH1F* D3P2me_q2 = new TH1F( "h63", "q2 for B0 ->3P2- e+ nu", 50, 0.0, 12.0 ); TH1F* D3P2me_elep = new TH1F( "h64", "Elep for B0 ->3P2- e+ nu", 50, 0.0, 2.5 ); TH1F* D3P20e_q2 = new TH1F( "h65", "q2 for B- ->3P20 e- nu", 50, 0.0, 12.0 ); TH1F* D3P20e_elep = new TH1F( "h66", "Elep for B*- ->3P20 e- nu", 50, 0.0, 2.5 ); TH1F* D3P20Be_q2 = new TH1F( "h67", "q2 for B+ ->3P2B e+ nu", 50, 0.0, 12.0 ); TH1F* D3P20Be_elep = new TH1F( "h68", "Elep for B+ ->3P2B e+ nu", 50, 0.0, 2.5 ); TH1F* phiL = new TH1F( "h69", "phi", 50, -3.1416, 3.1416 ); int count; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/SEMIC.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); int i; for ( i = 0; i < 2; i++ ) { EvtId meson = root_part->getDaug( i )->getDaug( 0 )->getId(); EvtId lepton = root_part->getDaug( i )->getDaug( 1 )->getId(); EvtVector4R lep = root_part->getDaug( i )->getDaug( 1 )->getP4Lab(); phiL->Fill( atan2( lep.get( 1 ), lep.get( 2 ) ) ); EvtVector4R nu = root_part->getDaug( i )->getDaug( 2 )->getP4Lab(); double q2 = ( lep + nu ).mass2(); double elep = root_part->getDaug( i )->getDaug( 1 )->getP4().get( 0 ); if ( meson == DP && lepton == EM ) { Dpe_q2->Fill( q2 ); Dpe_elep->Fill( elep ); } if ( meson == DM && lepton == EP ) { Dme_q2->Fill( q2 ); Dme_elep->Fill( elep ); } if ( meson == D0 && lepton == EM ) { D0e_q2->Fill( q2 ); D0e_elep->Fill( elep ); } if ( meson == D0B && lepton == EP ) { D0Be_q2->Fill( q2 ); D0Be_elep->Fill( elep ); } if ( meson == DSTP && lepton == EM ) { Dstpe_q2->Fill( q2 ); Dstpe_elep->Fill( elep ); } if ( meson == DSTM && lepton == EP ) { Dstme_q2->Fill( q2 ); Dstme_elep->Fill( elep ); } if ( meson == DST0 && lepton == EM ) { Dst0e_q2->Fill( q2 ); Dst0e_elep->Fill( elep ); } if ( meson == DSTB && lepton == EP ) { Dst0Be_q2->Fill( q2 ); Dst0Be_elep->Fill( elep ); } if ( meson == D1P1P && lepton == EM ) { D1P1pe_q2->Fill( q2 ); D1P1pe_elep->Fill( elep ); } if ( meson == D1P1N && lepton == EP ) { D1P1me_q2->Fill( q2 ); D1P1me_elep->Fill( elep ); } if ( meson == D1P10 && lepton == EM ) { D1P10e_q2->Fill( q2 ); D1P10e_elep->Fill( elep ); } if ( meson == D1P1B && lepton == EP ) { D1P10Be_q2->Fill( q2 ); D1P10Be_elep->Fill( elep ); } if ( meson == D3P0P && lepton == EM ) { D3P0pe_q2->Fill( q2 ); D3P0pe_elep->Fill( elep ); } if ( meson == D3P0N && lepton == EP ) { D3P0me_q2->Fill( q2 ); D3P0me_elep->Fill( elep ); } if ( meson == D3P00 && lepton == EM ) { D3P00e_q2->Fill( q2 ); D3P00e_elep->Fill( elep ); } if ( meson == D3P0B && lepton == EP ) { D3P00Be_q2->Fill( q2 ); D3P00Be_elep->Fill( elep ); } if ( meson == D3P1P && lepton == EM ) { D3P1pe_q2->Fill( q2 ); D3P1pe_elep->Fill( elep ); } if ( meson == D3P1N && lepton == EP ) { D3P1me_q2->Fill( q2 ); D3P1me_elep->Fill( elep ); } if ( meson == D3P10 && lepton == EM ) { D3P10e_q2->Fill( q2 ); D3P10e_elep->Fill( elep ); } if ( meson == D3P1B && lepton == EP ) { D3P10Be_q2->Fill( q2 ); D3P10Be_elep->Fill( elep ); } if ( meson == D3P2P && lepton == EM ) { D3P2pe_q2->Fill( q2 ); D3P2pe_elep->Fill( elep ); } if ( meson == D3P2N && lepton == EP ) { D3P2me_q2->Fill( q2 ); D3P2me_elep->Fill( elep ); } if ( meson == D3P20 && lepton == EM ) { D3P20e_q2->Fill( q2 ); D3P20e_elep->Fill( elep ); } if ( meson == D3P2B && lepton == EP ) { D3P20Be_q2->Fill( q2 ); D3P20Be_elep->Fill( elep ); } } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runKstarll( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "kstkmm.root", "RECREATE" ); TH2F* _dalitz = new TH2F( "h1", "q^2! vs Elep", 70, 0.0, 3.5, 60, 0.0, 30.0 ); TH1F* _ctl = new TH1F( "h2", "ctl", 50, -1.0, 1.0 ); TH1F* _q2 = new TH1F( "h3", "q2", 50, 0.0, 25.0 ); TH1F* _q2low = new TH1F( "h4", "q2 (low)", 50, 0.0, 1.0 ); TH1F* _q2lowlow = new TH1F( "h5", "q2 (lowlow)", 50, 0.0, 0.00001 ); TH1F* _phi = new TH1F( "h6", "phi", 50, -EvtConst::pi, EvtConst::pi ); TH1F* _chi = new TH1F( "h7", "chi", 50, 0.0, EvtConst::twoPi ); TH1F* _chictl = new TH1F( "h8", "chictl", 50, 0.0, EvtConst::twoPi ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); int count = 1; EvtVector4R kstar, l1, l2; EvtVector4R k, pi, b; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/KSTARLL.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); std::vector q2low( 5 ); std::vector q2high( 5 ); std::vector counts( 5 ); //kee //int n=4; //q2low[0]=0.0; q2high[0]=4.5; //q2low[1]=4.5; q2high[1]=8.41; //q2low[2]=10.24; q2high[2]=12.96; //q2low[3]=14.06; q2high[3]=30.0; //kmm //int n=4; //q2low[0]=0.0; q2high[0]=4.5; //q2low[1]=4.5; q2high[1]=9.0; //q2low[2]=10.24; q2high[2]=12.96; //q2low[3]=14.06; q2high[3]=30.0; //K*ee int n = 5; q2low[0] = 0.0; q2high[0] = 0.1; q2low[1] = 0.1; q2high[1] = 4.5; q2low[2] = 4.5; q2high[2] = 8.41; q2low[3] = 10.24; q2high[3] = 12.96; q2low[4] = 14.06; q2high[4] = 30.0; //K*mm //int n=5; //q2low[0]=0.0; q2high[0]=0.1; //q2low[1]=0.1; q2high[1]=4.5; //q2low[2]=4.5; q2high[2]=9.0; //q2low[3]=10.24; q2high[3]=12.96; //q2low[4]=14.06; q2high[4]=30.0; do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); // root_part->printTree(); //root_part->getDaug(0)->printTree(); //root_part->getDaug(1)->printTree(); //root_part->getDaug(2)->printTree(); kstar = root_part->getDaug( 0 )->getP4Lab(); l1 = root_part->getDaug( 1 )->getP4Lab(); l2 = root_part->getDaug( 2 )->getP4Lab(); b = root_part->getP4(); k = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); pi = root_part->getDaug( 0 )->getDaug( 1 )->getP4Lab(); double qsq = ( l1 + l2 ).mass2(); for ( int j = 0; j < n; j++ ) { if ( qsq > q2low[j] && qsq < q2high[j] ) counts[j]++; } _q2->Fill( ( l1 + l2 ).mass2() ); _q2low->Fill( ( l1 + l2 ).mass2() ); _q2lowlow->Fill( ( l1 + l2 ).mass2() ); _ctl->Fill( EvtDecayAngle( ( l1 + l2 + kstar ), ( l1 + l2 ), l1 ) ); _dalitz->Fill( l1.get( 0 ), ( l1 + l2 ).mass2(), 1.0 ); root_part->deleteTree(); _phi->Fill( atan2( l1.get( 1 ), l1.get( 2 ) ) ); _chi->Fill( EvtDecayAngleChi( b, k, pi, l1, l2 ) ); if ( EvtDecayAngle( ( l1 + l2 + kstar ), ( l1 + l2 ), l1 ) > 0 ) { _chictl->Fill( EvtDecayAngleChi( b, k, pi, l1, l2 ) ); } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "count:" << count << " " << ( l1 + l2 ).mass2() << std::endl; } while ( count++ < nevent ); for ( int j = 0; j < n; j++ ) { std::cout << "[" << q2low[j] << ".." << q2high[j] << "]=" << counts[j] << std::endl; } file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runKll( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "ksem.root", "RECREATE" ); TH2F* _dalitz = new TH2F( "h1", "q^2! vs Elep", 70, 0.0, 3.5, 60, 0.0, 30.0 ); TH1F* _ctl = new TH1F( "h2", "ctl", 50, -1.0, 1.0 ); TH1F* _q2 = new TH1F( "h3", "q2", 50, 0.0, 25.0 ); TH1F* _q2low = new TH1F( "h4", "q2 (low)", 50, 0.0, 1.0 ); TH1F* _q2lowlow = new TH1F( "h5", "q2 (lowlow)", 50, 0.0, 0.00001 ); TH1F* _phi = new TH1F( "h6", "phi", 50, -EvtConst::pi, EvtConst::pi ); // TH1F* _chi = new TH1F("h7","chi",50,0.0,EvtConst::twoPi); // TH1F* _chictl = new TH1F("h8","chictl",50,0.0,EvtConst::twoPi); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); int count = 1; EvtVector4R k, l1, l2; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/KLL.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); std::vector q2low( 5 ); std::vector q2high( 5 ); std::vector counts( 5 ); //kee // int n=4; //q2low[0]=0.0; q2high[0]=4.5; //q2low[1]=4.5; q2high[1]=8.41; //q2low[2]=10.24; q2high[2]=12.96; //q2low[3]=14.06; q2high[3]=30.0; //kmm int n = 4; q2low[0] = 0.0; q2high[0] = 4.5; q2low[1] = 4.5; q2high[1] = 9.0; q2low[2] = 10.24; q2high[2] = 12.96; q2low[3] = 14.06; q2high[3] = 30.0; //K*ee //int n=5; //q2low[0]=0.0; q2high[0]=0.1; //q2low[1]=0.1; q2high[1]=4.5; //q2low[2]=4.5; q2high[2]=8.41; //q2low[3]=10.24; q2high[3]=12.96; //q2low[4]=14.06; q2high[4]=30.0; //K*mm //int n=5; //q2low[0]=0.0; q2high[0]=0.1; //q2low[1]=0.1; q2high[1]=4.5; //q2low[2]=4.5; q2high[2]=9.0; //q2low[3]=10.24; q2high[3]=12.96; //q2low[4]=14.06; q2high[4]=30.0; do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); // root_part->printTree(); //root_part->getDaug(0)->printTree(); //root_part->getDaug(1)->printTree(); //root_part->getDaug(2)->printTree(); k = root_part->getDaug( 0 )->getP4Lab(); l1 = root_part->getDaug( 1 )->getP4Lab(); l2 = root_part->getDaug( 2 )->getP4Lab(); //b=root_part->getP4(); // k=root_part->getDaug(0)->getDaug(0)->getP4Lab(); // pi=root_part->getDaug(0)->getDaug(1)->getP4Lab(); double qsq = ( l1 + l2 ).mass2(); for ( int j = 0; j < n; j++ ) { if ( qsq > q2low[j] && qsq < q2high[j] ) counts[j]++; } _q2->Fill( ( l1 + l2 ).mass2() ); _q2low->Fill( ( l1 + l2 ).mass2() ); _q2lowlow->Fill( ( l1 + l2 ).mass2() ); _ctl->Fill( EvtDecayAngle( ( l1 + l2 + k ), ( l1 + l2 ), l1 ) ); _dalitz->Fill( l1.get( 0 ), ( l1 + l2 ).mass2(), 1.0 ); root_part->deleteTree(); _phi->Fill( atan2( l1.get( 1 ), l1.get( 2 ) ) ); //_chi->Fill(EvtDecayAngleChi(b,k,pi,l1,l2)); //if (EvtDecayAngle((l1+l2+kstar),(l1+l2),l1)>0){ // _chictl->Fill(EvtDecayAngleChi(b,k,pi,l1,l2)); // } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "count:" << count << " " << ( l1 + l2 ).mass2() << std::endl; } while ( count++ < nevent ); for ( int j = 0; j < n; j++ ) { std::cout << "[" << q2low[j] << ".." << q2high[j] << "]=" << counts[j] << std::endl; } file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runHll( int nevent, EvtGen& myGenerator, char* mode ) { TString modename = mode; TString filename; filename = modename; filename = filename + "_nnlo.root"; TFile* file = new TFile( filename, "RECREATE" ); TString decname; decname += modename; decname.ToUpper(); decname = "exampleFiles/" + decname + ".DEC"; char udecay_name[100]; strcpy( udecay_name, decname ); TH2F* _dalitz = new TH2F( "h1", "q^2! vs Elep", 70, 0.0, 3.5, 60, 0.0, 30.0 ); TH1F* _ctl = new TH1F( "h2", "ctl", 50, -1.0, 1.0 ); TH1F* _q2 = new TH1F( "h3", "q2", 50, 0.0, 25.0 ); TH1F* _q2low = new TH1F( "h4", "q2 (low)", 50, 0.0, 1.0 ); TH1F* _q2lowlow = new TH1F( "h5", "q2 (lowlow)", 50, 0.0, 0.00001 ); TH1F* _phi = new TH1F( "h6", "phi", 50, -EvtConst::pi, EvtConst::pi ); TH1F* _chi = new TH1F( "h7", "chi", 50, 0.0, EvtConst::twoPi ); TH1F* _chictl = new TH1F( "h8", "chictl", 50, 0.0, EvtConst::twoPi ); EvtId B; if ( modename == "kee" || modename == "kmm" || modename == "kstksee" || modename == "kstksmm" || modename == "piee" || modename == "pimm" || modename == "rhoee" || modename == "rhomm" ) { B = EvtPDL::getId( std::string( "B+" ) ); } else { B = EvtPDL::getId( std::string( "B0" ) ); } int count = 1; EvtVector4R b, h, l1, l2; EvtVector4R hdaug1, hdaug2; myGenerator.readUDecay( udecay_name ); std::vector q2low( 7 ); std::vector q2high( 7 ); std::vector counts( 7 ); int n( 0 ); if ( modename == "kee" || modename == "ksee" || modename == "piee" || modename == "pi0ee" || modename == "etaee" || modename == "etapee" ) { //kee n = 6; q2low[0] = 0.0; q2high[0] = 4.5; q2low[1] = 4.5; q2high[1] = 8.41; q2low[2] = 8.41; q2high[2] = 10.24; q2low[3] = 10.24; q2high[3] = 12.96; q2low[4] = 12.96; q2high[4] = 14.06; q2low[5] = 14.06; q2high[5] = 30.0; } else if ( modename == "kmm" || modename == "ksmm" || modename == "pimm" || modename == "pi0mm" || modename == "etamm" || modename == "etapmm" ) { //kmm n = 6; q2low[0] = 0.0; q2high[0] = 4.5; q2low[1] = 4.5; q2high[1] = 9.0; q2low[2] = 9.0; q2high[2] = 10.24; q2low[3] = 10.24; q2high[3] = 12.96; q2low[4] = 12.96; q2high[4] = 14.06; q2low[5] = 14.06; q2high[5] = 30.0; } else if ( modename == "kstkee" || modename == "kstksee" || modename == "rhoee" || modename == "rho0ee" || modename == "omegaee" ) { //K*ee n = 7; q2low[0] = 0.0; q2high[0] = 0.1; q2low[1] = 0.1; q2high[1] = 4.5; q2low[2] = 4.5; q2high[2] = 8.41; q2low[3] = 8.41; q2high[3] = 10.24; q2low[4] = 10.24; q2high[4] = 12.96; q2low[5] = 12.96; q2high[5] = 14.06; q2low[6] = 14.06; q2high[6] = 30.0; } else if ( modename == "kstkmm" || modename == "kstksmm" || modename == "rhomm" || modename == "rho0mm" || modename == "omegamm" ) { //K*mm n = 7; q2low[0] = 0.0; q2high[0] = 0.1; q2low[1] = 0.1; q2high[1] = 4.5; q2low[2] = 4.5; q2high[2] = 9.0; q2low[3] = 9.0; q2high[3] = 10.24; q2low[4] = 10.24; q2high[4] = 12.96; q2low[5] = 12.96; q2high[5] = 14.06; q2low[6] = 14.06; q2high[6] = 30.0; } float q2binlow[n + 1]; for ( int i = 0; i < n; i++ ) { q2binlow[i] = q2low[i]; } q2binlow[n] = 30.0; TH1F* _q2var = new TH1F( "h9", "q2var", n, q2binlow ); do { EvtVector4R p_init( EvtPDL::getMass( B ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); // root_part->printTree(); //root_part->getDaug(0)->printTree(); //root_part->getDaug(1)->printTree(); //root_part->getDaug(2)->printTree(); h = root_part->getDaug( 0 )->getP4Lab(); l1 = root_part->getDaug( 1 )->getP4Lab(); l2 = root_part->getDaug( 2 )->getP4Lab(); double qsq = ( l1 + l2 ).mass2(); for ( int j = 0; j < n; j++ ) { if ( qsq > q2low[j] && qsq < q2high[j] ) counts[j]++; } _q2->Fill( ( l1 + l2 ).mass2() ); _q2var->Fill( ( l1 + l2 ).mass2() ); _q2low->Fill( ( l1 + l2 ).mass2() ); _q2lowlow->Fill( ( l1 + l2 ).mass2() ); _ctl->Fill( EvtDecayAngle( ( l1 + l2 + h ), ( l1 + l2 ), l1 ) ); _dalitz->Fill( l1.get( 0 ), ( l1 + l2 ).mass2(), 1.0 ); _phi->Fill( atan2( l1.get( 1 ), l1.get( 2 ) ) ); if ( modename == "kstkee" || modename == "kstkmm" || modename == "kstksee" || modename == "kstksmm" || modename == "rhoee" || modename == "rhomm" || modename == "rho0ee" || modename == "rho0mm" ) { b = root_part->getP4(); hdaug1 = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); hdaug2 = root_part->getDaug( 0 )->getDaug( 1 )->getP4Lab(); _chi->Fill( EvtDecayAngleChi( b, hdaug1, hdaug2, l1, l2 ) ); if ( EvtDecayAngle( ( l1 + l2 + h ), ( l1 + l2 ), l1 ) > 0 ) { _chictl->Fill( EvtDecayAngleChi( b, hdaug1, hdaug2, l1, l2 ) ); } } if ( count % 1000 == 0 ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "count:" << count << " " << ( l1 + l2 ).mass2() << std::endl; } root_part->deleteTree(); } while ( count++ < nevent ); for ( int j = 0; j < n; j++ ) { std::cout << "[" << q2low[j] << ".." << q2high[j] << "] = " << counts[j] << std::endl; } file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runVectorIsr( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); TFile* file = new TFile( "vectorisr.root", "RECREATE" ); TH1F* cosv = new TH1F( "h1", "Cos vector in e+e- frame", 50, -1.0, 1.0 ); TH1F* cosd1 = new TH1F( "h2", "Cos helang 1st dau of vector", 50, -1.0, 1.0 ); TH1F* cosd1d1 = new TH1F( "h3", "Cos helang 1st dau of 1st dau", 50, -1.0, 1.0 ); TH1F* cosd2d1 = new TH1F( "h4", "Cos helang 1st dau of 2nd dau", 50, -1.0, 1.0 ); TH2F* d1vsd1d1 = new TH2F( "h5", "Cos helangs d1 vs d1d1", 20, -1.0, 1.0, 20, -1.0, 1.0 ); TH2F* d2vsd2d1 = new TH2F( "h6", "Cos helangs d2 vs d2d1", 20, -1.0, 1.0, 20, -1.0, 1.0 ); TH2F* d1d1vsd2d1 = new TH2F( "h7", "Cos helangs d1d1 vs d2d1", 20, -1.0, 1.0, 20, -1.0, 1.0 ); TH1F* chidd = new TH1F( "h8", "Chi - angle between decay planes", 60, 0., 360.0 ); TH2F* chi12vsd1d1 = new TH2F( "h9", "Chi 1-2 vs d1d1", 30, 0., 360.0, 20, -1.0, 1.0 ); TH2F* chi12vsd2d1 = new TH2F( "h10", "Chi 1-2 vs d2d1", 30, 0., 360.0, 20, -1.0, 1.0 ); TH2F* chi21vsd1d1 = new TH2F( "h11", "Chi 2-1 vs d1d1", 30, 0., 360.0, 20, -1.0, 1.0 ); TH2F* chi21vsd2d1 = new TH2F( "h12", "Chi 2-1 vs d2d1", 30, 0., 360.0, 20, -1.0, 1.0 ); int count = 1; char udecay_name[100]; EvtVector4R cm, v, d1, d2, d1d1, d1d2, d2d1, d2d2; strcpy( udecay_name, "exampleFiles/VECTORISR.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); cm = root_part->getP4Lab(); v = root_part->getDaug( 0 )->getP4Lab(); d1 = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); d2 = root_part->getDaug( 0 )->getDaug( 1 )->getP4Lab(); cosv->Fill( v.get( 3 ) / v.d3mag() ); double cosdecayd1 = EvtDecayAngle( cm, v, d1 ); double cosdecayd2 = EvtDecayAngle( cm, v, d2 ); cosd1->Fill( cosdecayd1 ); // now get daughters of the daughters // // first daughter of first daughter if ( root_part->getDaug( 0 )->getDaug( 0 )->getNDaug() >= 2 ) { d1d1 = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->getP4Lab(); double cosdecayd1d1 = EvtDecayAngle( v, d1, d1d1 ); cosd1d1->Fill( cosdecayd1d1 ); d1vsd1d1->Fill( cosdecayd1, cosdecayd1d1, 1.0 ); } // first daughter of second daughter if ( root_part->getDaug( 0 )->getDaug( 1 )->getNDaug() >= 2 ) { d2d1 = root_part->getDaug( 0 )->getDaug( 1 )->getDaug( 0 )->getP4Lab(); double cosdecayd2d1 = EvtDecayAngle( v, d2, d2d1 ); cosd2d1->Fill( cosdecayd2d1 ); d2vsd2d1->Fill( cosdecayd2, cosdecayd2d1, 1.0 ); if ( root_part->getDaug( 0 )->getDaug( 0 )->getNDaug() >= 2 ) { d1d1 = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->getP4Lab(); double cosdecayd1d1 = EvtDecayAngle( v, d1, d1d1 ); d1d1vsd2d1->Fill( cosdecayd1d1, cosdecayd2d1, 1.0 ); //second daughters of daughters 1 and 2 d1d2 = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 1 )->getP4Lab(); d2d2 = root_part->getDaug( 0 )->getDaug( 1 )->getDaug( 1 )->getP4Lab(); double chi21 = 57.29578 * EvtDecayAngleChi( v, d2d1, d2d2, d1d1, d1d2 ); double chi12 = 57.29578 * EvtDecayAngleChi( v, d1d1, d1d2, d2d1, d2d2 ); chidd->Fill( chi12 ); chi12vsd1d1->Fill( chi12, cosdecayd1d1, 1.0 ); chi12vsd2d1->Fill( chi12, cosdecayd2d1, 1.0 ); chi21vsd1d1->Fill( chi21, cosdecayd1d1, 1.0 ); chi21vsd2d1->Fill( chi21, cosdecayd2d1, 1.0 ); } } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runBsquark( int nevent, EvtGen& myGenerator ) { static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); TFile* file = new TFile( "bsquark.root", "RECREATE" ); TH1F* elep = new TH1F( "h1", "Elep", 50, 0.0, 1.5 ); TH1F* q2 = new TH1F( "h2", "q2", 50, 0.0, 3.0 ); TH2F* dalitz = new TH2F( "h3", "q2 vs. Elep", 50, 0.0, 1.5, 50, 0.0, 3.0 ); TH1F* elepbar = new TH1F( "h11", "Elep bar", 50, 0.0, 1.5 ); TH1F* q2bar = new TH1F( "h12", "q2 bar", 50, 0.0, 3.0 ); TH2F* dalitzbar = new TH2F( "h13", "q2 vs. Elep bar", 50, 0.0, 1.5, 50, 0.0, 3.0 ); int count = 1; char udecay_name[100]; EvtVector4R cm, v, d1, d2, d1d1, d1d2, d2d1, d2d2; strcpy( udecay_name, "exampleFiles/BSQUARK.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( 10.55, 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle* p = root_part->nextIter(); while ( p ) { if ( p->getId() == B0 ) { //EvtParticle *dstar=p->getDaug(0); EvtParticle* lepton = p->getDaug( 1 ); EvtParticle* sneutrino = p->getDaug( 2 ); //EvtVector4R p4dstar=dstar->getP4(); EvtVector4R p4lepton = lepton->getP4(); EvtVector4R p4sneutrino = sneutrino->getP4(); elep->Fill( p4lepton.get( 0 ) ); q2->Fill( ( p4lepton + p4sneutrino ).mass2() ); dalitz->Fill( p4lepton.get( 0 ), ( p4lepton + p4sneutrino ).mass2(), 1.0 ); } if ( p->getId() == B0B ) { //EvtParticle *dstar=p->getDaug(0); EvtParticle* lepton = p->getDaug( 1 ); EvtParticle* sneutrino = p->getDaug( 2 ); //EvtVector4R p4dstar=dstar->getP4(); EvtVector4R p4lepton = lepton->getP4(); EvtVector4R p4sneutrino = sneutrino->getP4(); elepbar->Fill( p4lepton.get( 0 ) ); q2bar->Fill( ( p4lepton + p4sneutrino ).mass2() ); dalitzbar->Fill( p4lepton.get( 0 ), ( p4lepton + p4sneutrino ).mass2(), 1.0 ); } p = p->nextIter(); } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runK3gamma( int nevent, EvtGen& myGenerator ) { static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); TFile* file = new TFile( "k3gamma.root", "RECREATE" ); TH1F* costheta = new TH1F( "h1", "cosTheta", 100, -1.0, 1.0 ); int count = 1; char udecay_name[100]; EvtVector4R cm, v, d1, d2, d1d1, d1d2, d2d1, d2d2; strcpy( udecay_name, "exampleFiles/K3GAMMA.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle* k3 = root_part->getDaug( 0 ); EvtParticle* k = k3->getDaug( 0 ); EvtVector4R p4b = root_part->getP4Lab(); EvtVector4R p4k3 = k3->getP4Lab(); EvtVector4R p4k = k->getP4Lab(); costheta->Fill( EvtDecayAngle( p4b, p4k3, p4k ) ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runLambda( int nevent, EvtGen& myGenerator ) { static EvtId LAMBDA = EvtPDL::getId( std::string( "Lambda0" ) ); TFile* file = new TFile( "lambda.root", "RECREATE" ); TH1F* costheta = new TH1F( "h1", "cosTheta", 100, -1.0, 1.0 ); int count = 1; char udecay_name[100]; EvtVector4R cm, v, d1, d2, d1d1, d1d2, d2d1, d2d2; strcpy( udecay_name, "exampleFiles/LAMBDA.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( LAMBDA ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( LAMBDA, p_init ); EvtSpinDensity rho; rho.setDim( 2 ); rho.set( 0, 0, 1.0 ); rho.set( 0, 1, 0.0 ); rho.set( 1, 0, 0.0 ); rho.set( 1, 1, 0.0 ); root_part->setSpinDensityForwardHelicityBasis( rho ); myGenerator.generateDecay( root_part ); EvtParticle* p = root_part->getDaug( 0 ); //EvtVector4R p4lambda=root_part->getP4Lab(); EvtVector4R p4p = p->getP4Lab(); costheta->Fill( p4p.get( 3 ) / p4p.d3mag() ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runTauTauPiPi( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); TFile* file = new TFile( "tautaupipi.root", "RECREATE" ); TH1F* cospi1 = new TH1F( "h1", "cos theta pi1", 50, -1.0, 1.0 ); TH1F* cospi2 = new TH1F( "h2", "cos theta pi2", 50, -1.0, 1.0 ); TH1F* costheta = new TH1F( "h3", "cos theta", 50, -1.0, 1.0 ); std::ofstream outmix; outmix.open( "tautaupipi.dat" ); int count = 1; EvtVector4R tau1, tau2, pi1, pi2; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/TAUTAUPIPI.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); tau1 = root_part->getDaug( 0 )->getP4Lab(); tau2 = root_part->getDaug( 1 )->getP4Lab(); pi1 = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); pi2 = root_part->getDaug( 1 )->getDaug( 0 )->getP4Lab(); cospi1->Fill( EvtDecayAngle( tau1 + tau2, tau1, pi1 ) ); cospi2->Fill( EvtDecayAngle( tau1 + tau2, tau2, pi2 ) ); costheta->Fill( tau1.get( 3 ) / tau1.d3mag() ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runTauTauEE( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); TFile* file = new TFile( "tautauee.root", "RECREATE" ); TH1F* e1 = new TH1F( "h1", "e1", 55, 0.0, 5.5 ); TH1F* e2 = new TH1F( "h2", "e2", 55, 0.0, 5.5 ); TH2F* e1vse2 = new TH2F( "h3", "e1 vs e2", 55, 0.0, 5.5, 55, 0.0, 5.5 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/TAUTAUEE.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); e1->Fill( root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab().get( 0 ) ); e2->Fill( root_part->getDaug( 1 )->getDaug( 0 )->getP4Lab().get( 0 ) ); e1vse2->Fill( root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab().get( 0 ), root_part->getDaug( 1 )->getDaug( 0 )->getP4Lab().get( 0 ), 1.0 ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runTauTau2Pi2Pi( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); TFile* file = new TFile( "tautau2pi2pi.root", "RECREATE" ); TH1F* e1 = new TH1F( "h1", "mrho", 200, 0.0, 2.0 ); TH1F* e2 = new TH1F( "h2", "coshel", 200, -1.0, 1.0 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/TAUTAU2PI2PI.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtVector4R p4tau = root_part->getDaug( 0 )->getP4(); EvtVector4R p4rho = root_part->getDaug( 0 )->getDaug( 0 )->getP4() + root_part->getDaug( 0 )->getDaug( 1 )->getP4(); EvtVector4R p4pi = root_part->getDaug( 0 )->getDaug( 0 )->getP4(); e1->Fill( p4rho.mass() ); double dcostheta = EvtDecayAngle( p4tau, p4rho, p4pi ); e2->Fill( dcostheta ); p4tau = root_part->getDaug( 1 )->getP4(); p4rho = root_part->getDaug( 1 )->getDaug( 0 )->getP4() + root_part->getDaug( 1 )->getDaug( 1 )->getP4(); p4pi = root_part->getDaug( 1 )->getDaug( 0 )->getP4(); e1->Fill( p4rho.mass() ); dcostheta = EvtDecayAngle( p4tau, p4rho, p4pi ); e2->Fill( dcostheta ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runTauTau3Pi3Pi( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); TFile* file = new TFile( "tautau3pi3pi.root", "RECREATE" ); TH1F* e1 = new TH1F( "h1", "a1", 200, 0.0, 2.0 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/TAUTAU3PI3PI.DEC" ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtVector4R p4tau = root_part->getDaug( 0 )->getP4(); EvtVector4R p4a1 = root_part->getDaug( 0 )->getDaug( 0 )->getP4() + root_part->getDaug( 0 )->getDaug( 1 )->getP4() + root_part->getDaug( 0 )->getDaug( 2 )->getP4(); e1->Fill( p4a1.mass() ); p4tau = root_part->getDaug( 1 )->getP4(); p4a1 = root_part->getDaug( 1 )->getDaug( 0 )->getP4() + root_part->getDaug( 1 )->getDaug( 1 )->getP4() + root_part->getDaug( 1 )->getDaug( 2 )->getP4(); e1->Fill( p4a1.mass() ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runJPsiKstar( int nevent, EvtGen& myGenerator, int modeInt ) { std::ofstream outmix; outmix.open( "jpsikstar.dat" ); int count = 1; char udecay_name[100]; if ( modeInt == 0 ) strcpy( udecay_name, "exampleFiles/JPSIKSTAR.DEC" ); if ( modeInt == 1 ) strcpy( udecay_name, "exampleFiles/JPSIKSTAR1.DEC" ); if ( modeInt == 2 ) strcpy( udecay_name, "exampleFiles/JPSIKSTAR2.DEC" ); if ( modeInt == 3 ) strcpy( udecay_name, "exampleFiles/JPSIKSTAR3.DEC" ); if ( modeInt == 4 ) strcpy( udecay_name, "exampleFiles/JPSIKSTAR4.DEC" ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); myGenerator.readUDecay( udecay_name ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *btag, *bcp; if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } EvtId tag; if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } EvtParticle *p_b, *p_psi, *p_kstar, *p_pi0, *p_kz, *p_ep, *p_em; EvtVector4R p4_b, p4_psi, p4_kstar, p4_pi0, p4_kz, p4_ep, p4_em; p_b = bcp; p_psi = p_b->getDaug( 0 ); p_kstar = p_b->getDaug( 1 ); p_pi0 = p_kstar->getDaug( 0 ); p_kz = p_kstar->getDaug( 1 ); p_ep = p_psi->getDaug( 0 ); p_em = p_psi->getDaug( 1 ); p4_b = p_b->getP4Lab(); p4_psi = p_psi->getP4Lab(); p4_kstar = p_kstar->getP4Lab(); p4_pi0 = p_pi0->getP4Lab(); p4_kz = p_kz->getP4Lab(); p4_ep = p_ep->getP4Lab(); p4_em = p_em->getP4Lab(); outmix << tag.getId() << " "; outmix << root_part->getDaug( 0 )->getLifetime() << " "; outmix << root_part->getDaug( 1 )->getLifetime() << " "; outmix << EvtDecayAngle( p4_b, p4_ep + p4_em, p4_ep ) << " "; outmix << EvtDecayAngle( p4_b, p4_pi0 + p4_kz, p4_pi0 ) << " "; outmix << EvtDecayAngleChi( p4_b, p4_pi0, p4_kz, p4_ep, p4_em ) << "\n"; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runSVVCPLH( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "svvcplh.root", "RECREATE" ); TH1F* t = new TH1F( "h1", "t", 50, 0.0, 5.0 ); TH1F* cospsi = new TH1F( "h2", "cos theta e+", 50, -1.0, 1.0 ); TH1F* cosphi = new TH1F( "h3", "cos theta k+", 50, -1.0, 1.0 ); TH1F* chi = new TH1F( "h4", "chi", 50, 0.0, 2.0 * EvtConst::pi ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/SVVCPLH.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId BS0 = EvtPDL::getId( std::string( "B_s0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( BS0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( BS0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_b, *p_psi, *p_phi, *p_kp, *p_km, *p_ep, *p_em; EvtVector4R p4_b, p4_psi, p4_phi, p4_kp, p4_km, p4_ep, p4_em; p_b = root_part; if ( p_b->getNDaug() == 1 ) p_b = p_b->getDaug( 0 ); p_psi = p_b->getDaug( 0 ); p_phi = p_b->getDaug( 1 ); p_kp = p_phi->getDaug( 0 ); p_km = p_phi->getDaug( 1 ); p_ep = p_psi->getDaug( 0 ); p_em = p_psi->getDaug( 1 ); p4_b = p_b->getP4Lab(); p4_psi = p_psi->getP4Lab(); p4_phi = p_phi->getP4Lab(); p4_kp = p_kp->getP4Lab(); p4_km = p_km->getP4Lab(); p4_ep = p_ep->getP4Lab(); p4_em = p_em->getP4Lab(); t->Fill( root_part->getLifetime() ); cospsi->Fill( EvtDecayAngle( p4_b, p4_ep + p4_em, p4_ep ) ); cosphi->Fill( EvtDecayAngle( p4_b, p4_kp + p4_km, p4_kp ) ); chi->Fill( EvtDecayAngleChi( p4_b, p4_kp, p4_km, p4_ep, p4_em ) ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runSVSCPLH( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "svscplh.root", "RECREATE" ); TH1F* t = new TH1F( "h1", "t", 200, -5.0, 5.0 ); TH1F* tB0tag = new TH1F( "h2", "dt B0 tag (ps)", 200, -15.0, 15.0 ); TH1F* tB0Btag = new TH1F( "h3", "dt B0B tag (ps)", 200, -15.0, 15.0 ); TH1F* ctheta = new TH1F( "h4", "costheta", 50, -1.0, 1.0 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/SVSCPLH.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); std::ofstream outmix; outmix.open( "svscplh.dat" ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_tag, *p_cp, *p_jpsi, *p_ep; EvtVector4R p4_tag, p4_cp, p4_jpsi, p4_ep; p_tag = root_part->getDaug( 0 ); p_cp = root_part->getDaug( 1 ); p_jpsi = p_cp->getDaug( 0 ); p_ep = p_jpsi->getDaug( 0 ); p4_tag = p_tag->getP4Lab(); p4_cp = p_cp->getP4Lab(); p4_jpsi = p_jpsi->getP4Lab(); p4_ep = p_ep->getP4Lab(); double dt = p_cp->getLifetime() - p_tag->getLifetime(); dt = dt / ( 1e-12 * 3e11 ); t->Fill( dt ); if ( p_tag->getId() == B0 ) { tB0tag->Fill( dt ); outmix << dt << " 1" << std::endl; } if ( p_tag->getId() == B0B ) { tB0Btag->Fill( dt ); outmix << dt << " -1" << std::endl; } ctheta->Fill( EvtDecayAngle( p4_cp, p4_jpsi, p4_ep ) ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runSSDCP( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "ssdcp.root", "RECREATE" ); TH1F* t = new TH1F( "h1", "dt", 100, -15.0, 15.0 ); TH1F* tB0tag = new TH1F( "h2", "dt B0 tag (ps)", 100, -15.0, 15.0 ); TH1F* tB0Btag = new TH1F( "h3", "dt B0B tag (ps)", 100, -15.0, 15.0 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/SSDCP.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); std::ofstream outmix; do { EvtVector4R pinit( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, pinit ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_tag, *p_cp, *p_jpsi; EvtVector4R p4_tag, p4_cp, p4_jpsi, p4_ep; p_tag = root_part->getDaug( 0 ); p_cp = root_part->getDaug( 1 ); p_jpsi = p_cp->getDaug( 0 ); //p_ep=p_jpsi->getDaug(0); p4_tag = p_tag->getP4Lab(); p4_cp = p_cp->getP4Lab(); p4_jpsi = p_jpsi->getP4Lab(); //p4_ep=p_ep->getP4Lab(); double dt = p_cp->getLifetime() - p_tag->getLifetime(); dt = dt / ( 1e-12 * EvtConst::c ); t->Fill( dt ); if ( p_tag->getId() == B0 ) { tB0tag->Fill( dt ); } if ( p_tag->getId() == B0B ) { tB0Btag->Fill( dt ); } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runKstarstargamma( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "kstarstargamma.root", "RECREATE" ); TH1F* m = new TH1F( "h1", "mkpi", 100, 0.5, 2.5 ); TH1F* ctheta = new TH1F( "h2", "ctheta", 100, -1.0, 1.0 ); int count = 1; myGenerator.readUDecay( "exampleFiles/KSTARSTARGAMMA.DEC" ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); std::ofstream outmix; do { EvtVector4R pinit( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, pinit ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_kaon, *p_pion; EvtVector4R p4_kaon, p4_pion; p_kaon = root_part->getDaug( 0 ); p_pion = root_part->getDaug( 1 ); p4_kaon = p_kaon->getP4Lab(); p4_pion = p_pion->getP4Lab(); m->Fill( ( p4_kaon + p4_pion ).mass() ); ctheta->Fill( EvtDecayAngle( pinit, p4_kaon + p4_pion, p4_kaon ) ); //EvtGenReport(EVTGEN_INFO,"EvtGen") << "ctheta:"<deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runDSTARPI( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "dstarpi.root", "RECREATE" ); TH1F* t = new TH1F( "h1", "dt", 100, -15.0, 15.0 ); TH1F* tB0tagpip = new TH1F( "h2", "dt B0 tag pi+ (ps)", 100, -15.0, 15.0 ); TH1F* tB0Btagpip = new TH1F( "h3", "dt B0B tag pi+(ps)", 100, -15.0, 15.0 ); TH1F* tB0tagpim = new TH1F( "h4", "dt B0 tag pi- (ps)", 100, -15.0, 15.0 ); TH1F* tB0Btagpim = new TH1F( "h5", "dt B0B tag pi- (ps)", 100, -15.0, 15.0 ); int count = 1; myGenerator.readUDecay( "exampleFiles/DSTARPI.DEC" ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); static EvtId PIP = EvtPDL::getId( std::string( "pi+" ) ); static EvtId PIM = EvtPDL::getId( std::string( "pi-" ) ); std::ofstream outmix; do { EvtVector4R pinit( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, pinit ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_tag, *p_cp, *p_pi; p_tag = root_part->getDaug( 0 ); p_cp = root_part->getDaug( 1 ); //p_dstar=p_cp->getDaug(1); p_pi = p_cp->getDaug( 0 ); double dt = p_cp->getLifetime() - p_tag->getLifetime(); dt = dt / ( 1e-12 * EvtConst::c ); t->Fill( dt ); if ( p_tag->getId() == B0 ) { if ( p_pi->getId() == PIP ) tB0tagpip->Fill( dt ); if ( p_pi->getId() == PIM ) tB0tagpim->Fill( dt ); } if ( p_tag->getId() == B0B ) { if ( p_pi->getId() == PIP ) tB0Btagpip->Fill( dt ); if ( p_pi->getId() == PIM ) tB0Btagpim->Fill( dt ); } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runETACPHIPHI( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "etacphiphi.root", "RECREATE" ); TH2F* cosphi12 = new TH2F( "h1", "cos phi1 vs phi2", 50, -1.0, 1.0, 50, -1.0, 1.0 ); TH1F* cosphi1 = new TH1F( "h2", "cos phi1", 50, -1.0, 1.0 ); TH1F* cosphi2 = new TH1F( "h3", "cos phi2", 50, -1.0, 1.0 ); TH1F* chi = new TH1F( "h4", "chi", 50, 0.0, 2.0 * EvtConst::pi ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/ETACPHIPHI.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId ETAC = EvtPDL::getId( std::string( "eta_c" ) ); do { EvtVector4R p_init( EvtPDL::getMass( ETAC ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( ETAC, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_etac, *p_phi1, *p_phi2, *p_kp1, *p_km1, *p_kp2, *p_km2; EvtVector4R p4_etac, p4_phi1, p4_phi2, p4_kp1, p4_km1, p4_kp2, p4_km2; p_etac = root_part; p_phi1 = p_etac->getDaug( 0 ); p_phi2 = p_etac->getDaug( 1 ); p_kp1 = p_phi1->getDaug( 0 ); p_km1 = p_phi1->getDaug( 1 ); p_kp2 = p_phi2->getDaug( 0 ); p_km2 = p_phi2->getDaug( 1 ); p4_etac = p_etac->getP4Lab(); p4_phi1 = p_phi1->getP4Lab(); p4_phi2 = p_phi2->getP4Lab(); p4_kp1 = p_kp1->getP4Lab(); p4_km1 = p_km1->getP4Lab(); p4_kp2 = p_kp2->getP4Lab(); p4_km2 = p_km2->getP4Lab(); cosphi12->Fill( EvtDecayAngle( p4_etac, p4_phi1, p4_kp1 ), EvtDecayAngle( p4_etac, p4_phi2, p4_kp2 ), 1.0 ); cosphi1->Fill( EvtDecayAngle( p4_etac, p4_phi1, p4_kp1 ) ); cosphi2->Fill( EvtDecayAngle( p4_etac, p4_phi2, p4_kp2 ) ); chi->Fill( EvtDecayAngleChi( p4_etac, p4_kp1, p4_km1, p4_kp2, p4_km2 ) ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runVVPiPi( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "vvpipi.root", "RECREATE" ); TH1F* cospsi = new TH1F( "h1", "cos theta J/psi ", 50, -1.0, 1.0 ); TH1F* cose = new TH1F( "h2", "cos theta e+ ", 50, -1.0, 1.0 ); TH1F* mpipi = new TH1F( "h3", "m pipi ", 50, 0.0, 1.0 ); TH2F* cosevspsi = new TH2F( "h4", "cos theta e+vs cos thete J/psi ", 25, -1.0, 1.0, 25, -1.0, 1.0 ); TH1F* cose1 = new TH1F( "h5", "cos theta e+ 1 ", 50, -1.0, 1.0 ); TH1F* cose2 = new TH1F( "h6", "cos theta e+ 2 ", 50, -1.0, 1.0 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/VVPIPI.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_b, *p_psip, *p_psi, *p_ep, *p_pi1, *p_pi2; EvtVector4R p4_b, p4_psip, p4_psi, p4_ep, p4_pi1, p4_pi2; p_b = root_part; p_psip = p_b->getDaug( 0 ); p_psi = p_psip->getDaug( 0 ); p_pi1 = p_psip->getDaug( 1 ); p_pi2 = p_psip->getDaug( 2 ); p_ep = p_psi->getDaug( 0 ); p4_b = p_b->getP4Lab(); p4_psip = p_psip->getP4Lab(); p4_psi = p_psi->getP4Lab(); p4_pi1 = p_pi1->getP4Lab(); p4_pi2 = p_pi2->getP4Lab(); p4_ep = p_ep->getP4Lab(); cospsi->Fill( EvtDecayAngle( p4_b, p4_psip, p4_psi ) ); cose->Fill( EvtDecayAngle( p4_psip, p4_psi, p4_ep ) ); mpipi->Fill( ( p4_pi1 + p4_pi2 ).mass() ); cosevspsi->Fill( EvtDecayAngle( p4_b, p4_psip, p4_psi ), EvtDecayAngle( p4_psip, p4_psi, p4_ep ), 1.0 ); if ( std::fabs( EvtDecayAngle( p4_b, p4_psip, p4_psi ) ) > 0.95 ) { cose1->Fill( EvtDecayAngle( p4_psip, p4_psi, p4_ep ) ); } if ( std::fabs( EvtDecayAngle( p4_b, p4_psip, p4_psi ) ) < 0.05 ) { cose2->Fill( EvtDecayAngle( p4_psip, p4_psi, p4_ep ) ); } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runSVVHelAmp( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "svvhelamp.root", "RECREATE" ); TH1F* cospip = new TH1F( "h1", "cos theta pi+", 50, -1.0, 1.0 ); TH1F* cospim = new TH1F( "h2", "cos theta pi-", 50, -1.0, 1.0 ); TH1F* chi = new TH1F( "h3", "chi pi+ to pi- in D+ direction", 50, 0.0, EvtConst::twoPi ); TH1F* chicospipp = new TH1F( "h4", "chi pi+ to pi- in D+ direction (cospip>0)", 50, 0.0, EvtConst::twoPi ); TH1F* chicospipn = new TH1F( "h5", "chi pi+ to pi- in D+ direction (cospip<0", 50, 0.0, EvtConst::twoPi ); TH1F* chipp = new TH1F( "h6", "chi pi+ to pi- in D+ direction (cospip>0,cospim>0)", 50, 0.0, EvtConst::twoPi ); TH1F* chipn = new TH1F( "h7", "chi pi+ to pi- in D+ direction (cospip>0,cospim<0)", 50, 0.0, EvtConst::twoPi ); TH1F* chinp = new TH1F( "h8", "chi pi+ to pi- in D+ direction (cospip<0,cospim>0)", 50, 0.0, EvtConst::twoPi ); TH1F* chinn = new TH1F( "h9", "chi pi+ to pi- in D+ direction (cospip<0,cospim<0)", 50, 0.0, EvtConst::twoPi ); TH1F* chinnnn = new TH1F( "h10", "chi pi+ to pi- in D+ direction (cospip<-0.5,cospim<-0.5)", 50, 0.0, EvtConst::twoPi ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/SVVHELAMP.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_b, *p_dstp, *p_dstm, *p_pip, *p_pim, *p_d0, *p_d0b; EvtVector4R p4_b, p4_dstp, p4_dstm, p4_pip, p4_pim, p4_d0, p4_d0b; p_b = root_part; p_dstp = p_b->getDaug( 0 ); p_dstm = p_b->getDaug( 1 ); p_pip = p_dstp->getDaug( 1 ); p_pim = p_dstm->getDaug( 1 ); p_d0 = p_dstp->getDaug( 0 ); p_d0b = p_dstm->getDaug( 0 ); p4_b = p_b->getP4Lab(); p4_dstp = p_dstp->getP4Lab(); p4_dstm = p_dstm->getP4Lab(); p4_pip = p_pip->getP4Lab(); p4_pim = p_pim->getP4Lab(); p4_d0 = p_d0->getP4Lab(); p4_d0b = p_d0b->getP4Lab(); double costhpip = EvtDecayAngle( p4_b, p4_pip + p4_d0, p4_pip ); double costhpim = EvtDecayAngle( p4_b, p4_pim + p4_d0b, p4_pim ); double chiang = EvtDecayAngleChi( p4_b, p4_pip, p4_d0, p4_pim, p4_d0b ); cospip->Fill( costhpip ); cospim->Fill( costhpim ); chi->Fill( chiang ); if ( costhpip > 0 ) chicospipp->Fill( chiang ); if ( costhpip < 0 ) chicospipn->Fill( chiang ); if ( costhpip > 0 && costhpim > 0 ) chipp->Fill( chiang ); if ( costhpip > 0 && costhpim < 0 ) chipn->Fill( chiang ); if ( costhpip < 0 && costhpim > 0 ) chinp->Fill( chiang ); if ( costhpip < 0 && costhpim < 0 ) chinn->Fill( chiang ); if ( costhpip < -0.5 && costhpim < -0.5 ) chinnnn->Fill( chiang ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPartWave( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "partwave.root", "RECREATE" ); TH1F* cospip = new TH1F( "h1", "cos theta pi+", 50, -1.0, 1.0 ); TH1F* cospim = new TH1F( "h2", "cos theta pi-", 50, -1.0, 1.0 ); TH1F* chi = new TH1F( "h3", "chi pi+ to pi- in D+ direction", 50, 0.0, EvtConst::twoPi ); TH1F* chicospipp = new TH1F( "h4", "chi pi+ to pi- in D+ direction (cospip>0)", 50, 0.0, EvtConst::twoPi ); TH1F* chicospipn = new TH1F( "h5", "chi pi+ to pi- in D+ direction (cospip<0", 50, 0.0, EvtConst::twoPi ); TH1F* chipp = new TH1F( "h6", "chi pi+ to pi- in D+ direction (cospip>0,cospim>0)", 50, 0.0, EvtConst::twoPi ); TH1F* chipn = new TH1F( "h7", "chi pi+ to pi- in D+ direction (cospip>0,cospim<0)", 50, 0.0, EvtConst::twoPi ); TH1F* chinp = new TH1F( "h8", "chi pi+ to pi- in D+ direction (cospip<0,cospim>0)", 50, 0.0, EvtConst::twoPi ); TH1F* chinn = new TH1F( "h9", "chi pi+ to pi- in D+ direction (cospip<0,cospim<0)", 50, 0.0, EvtConst::twoPi ); TH1F* chinnnn = new TH1F( "h10", "chi pi+ to pi- in D+ direction (cospip<-0.5,cospim<-0.5)", 50, 0.0, EvtConst::twoPi ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/PARTWAVE.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_b, *p_dstp, *p_dstm, *p_pip, *p_pim, *p_d0, *p_d0b; EvtVector4R p4_b, p4_dstp, p4_dstm, p4_pip, p4_pim, p4_d0, p4_d0b; p_b = root_part; p_dstp = p_b->getDaug( 0 ); p_dstm = p_b->getDaug( 1 ); p_pip = p_dstp->getDaug( 1 ); p_pim = p_dstm->getDaug( 1 ); p_d0 = p_dstp->getDaug( 0 ); p_d0b = p_dstm->getDaug( 0 ); p4_b = p_b->getP4Lab(); p4_dstp = p_dstp->getP4Lab(); p4_dstm = p_dstm->getP4Lab(); p4_pip = p_pip->getP4Lab(); p4_pim = p_pim->getP4Lab(); p4_d0 = p_d0->getP4Lab(); p4_d0b = p_d0b->getP4Lab(); double costhpip = EvtDecayAngle( p4_b, p4_pip + p4_d0, p4_pip ); double costhpim = EvtDecayAngle( p4_b, p4_pim + p4_d0b, p4_pim ); double chiang = EvtDecayAngleChi( p4_b, p4_pip, p4_d0, p4_pim, p4_d0b ); cospip->Fill( costhpip ); cospim->Fill( costhpim ); chi->Fill( chiang ); if ( costhpip > 0 ) chicospipp->Fill( chiang ); if ( costhpip < 0 ) chicospipn->Fill( chiang ); if ( costhpip > 0 && costhpim > 0 ) chipp->Fill( chiang ); if ( costhpip > 0 && costhpim < 0 ) chipn->Fill( chiang ); if ( costhpip < 0 && costhpim > 0 ) chinp->Fill( chiang ); if ( costhpip < 0 && costhpim < 0 ) chinn->Fill( chiang ); if ( costhpip < -0.5 && costhpim < -0.5 ) chinnnn->Fill( chiang ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPartWave2( int nevent, EvtGen& myGenerator ) { TFile file( "partwave2.root", "RECREATE" ); TH1F* cthetapi = new TH1F( "h1", "cos theta pi", 50, -1.0, 1.0 ); TH1F* cthetapi2 = new TH1F( "h2", "cos theta pi (|cosrho|<0.1)", 50, -1.0, 1.0 ); TH1F* cthetan = new TH1F( "h3", "cos thetan", 50, -1.0, 1.0 ); //TH1F* cthetan2 = new TH1F("h4","cos thetan costhetapi>0 ", // 50,-1.0,1.0); TH1F* cthetarho = new TH1F( "h4", "cos thetarho ", 50, -1.0, 1.0 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/PARTWAVE2.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_b, *p_jpsi, *p_rho, *p_pi1, *p_pi2; EvtVector4R p4_b, p4_jpsi, p4_rho, p4_pi1, p4_pi2; p_b = root_part; p_jpsi = root_part->getDaug( 0 ); p_rho = 0; if ( p_jpsi->getDaug( 0 )->getNDaug() == 2 ) { p_rho = p_jpsi->getDaug( 0 ); } if ( p_jpsi->getDaug( 1 )->getNDaug() == 2 ) { p_rho = p_jpsi->getDaug( 1 ); } assert( p_rho != 0 ); p_pi1 = p_rho->getDaug( 0 ); p_pi2 = p_rho->getDaug( 1 ); p4_b = p_b->getP4Lab(); p4_jpsi = p_jpsi->getP4Lab(); p4_rho = p_rho->getP4Lab(); p4_pi1 = p_pi1->getP4Lab(); p4_pi2 = p_pi2->getP4Lab(); double costhetan = EvtDecayPlaneNormalAngle( p4_b, p4_jpsi, p4_pi1, p4_pi2 ); //EvtGenReport(EVTGEN_INFO,"EvtGen") << "costhetan:"<Fill( costhetan ); double costhpi = EvtDecayAngle( p4_jpsi, p4_rho, p4_pi1 ); double costhrho = EvtDecayAngle( p4_b, p4_jpsi, p4_rho ); //EvtGenReport(EVTGEN_INFO,"EvtGen") << "costhetarho:"<Fill( costhrho ); //if (((p4_rho.get(3)/p4_rho.d3mag()))<-0.95) cthetan2->Fill( costhetan ); cthetapi->Fill( costhpi ); if ( ( p4_rho.get( 3 ) / p4_rho.d3mag() ) > 0.9 ) { cthetapi2->Fill( costhpi ); } root_part->deleteTree(); } while ( count++ < nevent ); file.Write(); file.Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runTwoBody( int nevent, EvtGen& myGenerator, std::string decFile, std::string rootFile ) { TFile* file = new TFile( rootFile.c_str(), "RECREATE" ); int count = 0; myGenerator.readUDecay( decFile.c_str() ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); vector histograms; do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); //root_part->printTree(); myGenerator.generateDecay( root_part ); int nhist = 0; EvtParticle* p = root_part; do { int nDaug = p->getNDaug(); if ( !( nDaug == 0 || nDaug == 2 ) ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "nDaug=" << nDaug << " but can only handle 0 or 2!" << std::endl; abort(); } if ( nDaug == 2 ) { if ( p->getParent() == 0 ) { EvtVector4R p4 = p->getDaug( 0 )->getP4(); double ctheta = p4.get( 3 ) / p4.d3mag(); double phi = atan2( p4.get( 2 ), p4.get( 1 ) ); if ( count == 0 ) { histograms.push_back( new TH1F( "h1", "cos theta", 50, -1.0, 1.0 ) ); histograms.push_back( new TH1F( "h2", "phi", 50, -EvtConst::pi, EvtConst::pi ) ); } histograms[nhist++]->Fill( ctheta ); histograms[nhist++]->Fill( phi ); } else { double ctheta = EvtDecayAngle( p->getParent()->getP4Lab(), p->getP4Lab(), p->getDaug( 0 )->getP4Lab() ); if ( count == 0 ) { // char* tmp=new char[10]; // std::ostrstream strm(tmp,9); // strm << (nhist+1) << '\0'<< std::endl; // histograms.push_back(new TH1F(TString("h")+tmp,TString("cos theta")+tmp,50,-1.0,1.0)); std::ostringstream strm; strm << ( nhist + 1 ); histograms.push_back( new TH1F( TString( "h" ) + strm.str().c_str(), TString( "cos theta" ) + strm.str().c_str(), 50, -1.0, 1.0 ) ); } histograms[nhist++]->Fill( ctheta ); if ( p->getDaug( 0 )->getNDaug() == 2 ) { double costhetan = EvtDecayPlaneNormalAngle( p->getParent()->getP4Lab(), p->getP4Lab(), p->getDaug( 0 )->getDaug( 0 )->getP4Lab(), p->getDaug( 0 )->getDaug( 1 )->getP4Lab() ); if ( count == 0 ) { // char* tmp=new char[10]; // std::ostrstream strm(tmp,9); // strm << (nhist+1) << '\0'<< std::endl; // histograms.push_back(new TH1F(TString("h")+tmp,TString("cos thetan")+tmp,50,-1.0,1.0)); std::ostringstream strm; strm << ( nhist + 1 ); histograms.push_back( new TH1F( TString( "h" ) + strm.str().c_str(), TString( "cos theta" ) + strm.str().c_str(), 50, -1.0, 1.0 ) ); } histograms[nhist++]->Fill( costhetan ); } if ( p->getDaug( 1 )->getNDaug() == 2 ) { double costhetan = EvtDecayPlaneNormalAngle( p->getParent()->getP4Lab(), p->getP4Lab(), p->getDaug( 1 )->getDaug( 0 )->getP4Lab(), p->getDaug( 1 )->getDaug( 1 )->getP4Lab() ); if ( count == 0 ) { // char* tmp=new char[10]; // std::ostrstream strm(tmp,9); // strm << (nhist+1) << '\0'<< std::endl; // histograms.push_back(new TH1F(TString("h")+tmp,TString("cos thetan")+tmp,50,-1.0,1.0)); std::ostringstream strm; strm << ( nhist + 1 ); histograms.push_back( new TH1F( TString( "h" ) + strm.str().c_str(), TString( "cos theta" ) + strm.str().c_str(), 50, -1.0, 1.0 ) ); } histograms[nhist++]->Fill( costhetan ); } } } p = p->nextIter( root_part ); } while ( p != 0 ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPiPi( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "pipi.dat" ); TFile* file = new TFile( "pipi.root", "RECREATE" ); TH1F* tB0Hist = new TH1F( "h1", "dt in B->pipi with B0 tag", 50, -5.0, 5.0 ); TH1F* tB0BHist = new TH1F( "h2", "dt in B->pipi with B0B tag", 50, -5.0, 5.0 ); TH1F* tB0 = new TH1F( "h3", "t in B->pipi for B0 tag", 25, 0.0, 5.0 ); TH1F* tB0B = new TH1F( "h4", "t in B->pipi for B0B tag", 25, 0.0, 5.0 ); char udecay_name[100]; strcpy( udecay_name, "exampleFiles/PIPI.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); EvtParticle *bcp, *btag; int count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } EvtId tag; //cp tag if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } // int a1=bcp->getDaug(0)->getId(); if ( tag == B0 ) tB0Hist->Fill( bcp->getLifetime() - btag->getLifetime() ); if ( tag == B0 ) tB0->Fill( btag->getLifetime() ); if ( tag == B0B ) tB0BHist->Fill( bcp->getLifetime() - btag->getLifetime() ); if ( tag == B0B ) tB0B->Fill( btag->getLifetime() ); outmix << bcp->getLifetime() << " " << btag->getLifetime() << " " << tag.getId() << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runA1Pi( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "a1pi.dat" ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/A1PI.DEC" ); myGenerator.readUDecay( udecay_name ); EvtParticle *bcp, *btag; EvtParticle *a1, *rho0, *pi1, *pi2, *pi3, *pi4; EvtVector4R p4bcp, p4a1, p4rho0, p4pi1, p4pi2, p4pi3, p4pi4; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } a1 = bcp->getDaug( 0 ); pi1 = bcp->getDaug( 1 ); rho0 = a1->getDaug( 0 ); pi2 = a1->getDaug( 1 ); pi3 = rho0->getDaug( 0 ); pi4 = rho0->getDaug( 1 ); p4bcp = bcp->getP4Lab(); p4a1 = a1->getP4Lab(); p4pi1 = pi1->getP4Lab(); p4rho0 = rho0->getP4Lab(); p4pi2 = pi2->getP4Lab(); p4pi3 = pi3->getP4Lab(); p4pi4 = pi4->getP4Lab(); EvtId tag; //cp tag if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } outmix << bcp->getLifetime() << " " << btag->getLifetime() << " " << EvtDecayAngle( p4bcp, p4rho0 + p4pi2, p4rho0 ) << " " << EvtDecayAngle( p4a1, p4pi3 + p4pi4, p4pi3 ) << " " << EvtPDL::getStdHep( tag ) << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runCPTest( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "cptest.dat" ); int count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); char udecay_name[100]; strcpy( udecay_name, "exampleFiles/CPTEST.DEC" ); //EvtGen myGenerator(decay_name,pdttable_name,myRandomEngine); myGenerator.readUDecay( udecay_name ); EvtParticle *bcp, *btag; do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } EvtId tag; //cp tag if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } outmix << bcp->getLifetime() << " " << btag->getLifetime() << " " << tag.getId() << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runBtoXsgamma( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); TFile* file = new TFile( "BtoXsgamma.root", "RECREATE" ); int count = 1; EvtParticle* root_part; EvtVectorParticle* vector_part; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/BTOXSGAMMA.DEC" ); myGenerator.readUDecay( udecay_name ); // Plot kinematics for b->s,gamma int strangeid, antistrangeid; int Bmulti, bId1a, bId1b, bId2a, bId2b, b1Id, b2Id; do { vector_part = new EvtVectorParticle; EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); vector_part->init( UPS4, p_init ); root_part = (EvtParticle*)vector_part; root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle* B1 = root_part->getDaug( 0 ); Bmulti = B1->getNDaug(); if ( Bmulti == 1 ) B1 = B1->getDaug( 0 ); EvtId BId1a = B1->getDaug( 0 )->getId(); bId1a = EvtPDL::getStdHep( BId1a ); EvtId BId1b = B1->getDaug( 1 )->getId(); bId1b = EvtPDL::getStdHep( BId1b ); if ( Bmulti == 1 ) EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "B1" << " bId1a=" << bId1a << " bId1b=" << bId1b << " ndaug=" << B1->getNDaug() << " Bid=" << EvtPDL::getStdHep( B1->getId() ) << std::endl; EvtParticle* B2 = root_part->getDaug( 1 ); Bmulti = B2->getNDaug(); if ( Bmulti == 1 ) B2 = B2->getDaug( 0 ); // B has a daughter which is a string EvtId BId2a = B2->getDaug( 0 )->getId(); bId2a = EvtPDL::getStdHep( BId2a ); EvtId BId2b = B2->getDaug( 1 )->getId(); bId2b = EvtPDL::getStdHep( BId2b ); if ( Bmulti == 1 ) EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "B2" << " bId2a=" << bId2a << " bId2b=" << bId2b << " ndaug=" << B2->getNDaug() << " Bid=" << EvtPDL::getStdHep( B2->getId() ) << std::endl; EvtId B1Id = B1->getId(); b1Id = EvtPDL::getStdHep( B1Id ); EvtId B2Id = B2->getId(); b2Id = EvtPDL::getStdHep( B2Id ); strangeid = 0; antistrangeid = 0; if ( ( b1Id == 511 ) || ( b1Id == -511 ) || ( b2Id == 511 ) || ( b2Id == -511 ) ) { strangeid = 30343; antistrangeid = -30343; } else if ( ( b1Id == 521 ) || ( b1Id == -521 ) || ( b2Id == 521 ) || ( b2Id == -521 ) ) { strangeid = 30353; antistrangeid = -30353; } else if ( ( b1Id == 531 ) || ( b1Id == -531 ) || ( b2Id == 531 ) || ( b2Id == -531 ) ) { strangeid = 30363; antistrangeid = -30363; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "bId1a " << bId1a << " bId1b " << bId1b << " bId2a " << bId2a << " bId2b " << bId2b << " for event " << count << std::endl; EvtParticle* Bpeng = 0; //int bnum=0; int pengcount = 0; if ( ( ( bId1a == strangeid ) && ( bId1b == 22 ) ) || ( ( bId1a == antistrangeid ) && ( bId1b == 22 ) ) || ( ( bId1b == strangeid ) && ( bId1a == 22 ) ) || ( ( bId1b == antistrangeid ) && ( bId1a == 22 ) ) ) { Bpeng = B1; //bnum=1; pengcount++; } if ( ( ( bId2a == strangeid ) && ( bId2b == 22 ) ) || ( ( bId2a == antistrangeid ) && ( bId2b == 22 ) ) || ( ( bId2b == strangeid ) && ( bId2a == 22 ) ) || ( ( bId2b == antistrangeid ) && ( bId2a == 22 ) ) ) { Bpeng = B2; //bnum=2; pengcount++; } if ( pengcount == 0 ) { Bpeng = B1; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "No penguin decay for event " << count << std::endl; //bnum=0; } else if ( pengcount == 2 ) { Bpeng = B1; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Two penguin decays in event " << count << std::endl; //bnum=0; } Bmulti = Bpeng->getNDaug(); EvtParticle* Xs = Bpeng->getDaug( 0 ); //EvtParticle *gam = Bpeng->getDaug(1); //EvtVector4R p4Xs = Xs->getP4Lab(); //EvtId BId = Bpeng->getId(); //EvtId XsId = Xs->getId(); int Xsmulti = Xs->getNDaug(); //EvtId gamId = gam->getId(); //int bId = EvtPDL::getStdHep(BId); //int XId = EvtPDL::getStdHep(XsId); //int gId = EvtPDL::getStdHep(gamId); //float XsMass = p4Xs.mass(); //double gmass = p4gam.mass(); //double genergy = p4gam.get(0); // debug stuff: EvtGenReport(EVTGEN_INFO,"EvtGen") << "bnum=" << bnum << " pengcount=" << pengcount << " bId=" << bId << " Bmulti=" << Bmulti << " XsId=" << XId << " gId=" << gId << std::endl; //need to change this to root...I don't have the energy now //tuple->column("bnum", bnum); //tuple->column("pengcount", pengcount); //tuple->column("bId", bId); //tuple->column("Bmulti", Bmulti); //tuple->column("XsId", XId); //tuple->column("gId", gId); //tuple->column("XsMass", XsMass); //tuple->column("Xsmulti", Xsmulti, 0,"Xs", HTRange(0,200)); //tuple->column("gmass", gmass); //tuple->column("genergy", genergy); //HTValOrderedVector XDaugId, XDaugNephewId; //HTValOrderedVector XsDaugMass, XsDaugNephewMass; int nTot( 0 ); for ( int i = 0; i < Xsmulti; i++ ) { EvtParticle* XsDaug = Xs->getDaug( i ); //EvtVector4R p4XsDaug = XsDaug->getP4Lab(); EvtId XsDaugId = XsDaug->getId(); //XDaugId.push_back(EvtPDL::getStdHep(XsDaugId)); //XsDaugMass.push_back( p4XsDaug.mass()); int Daumulti = XsDaug->getNDaug(); if ( abs( EvtPDL::getStdHep( XsDaugId ) ) == 321 || EvtPDL::getStdHep( XsDaugId ) == 310 || EvtPDL::getStdHep( XsDaugId ) == 111 || abs( EvtPDL::getStdHep( XsDaugId ) ) == 211 || Daumulti == 0 ) { nTot++; //EvtVector4R p4XsDaugNephew = XsDaug->getP4Lab(); //EvtId XsDaugNephewId =XsDaug->getId() ; //XDaugNephewId.push_back(EvtPDL::getStdHep(XsDaugId)); //XsDaugNephewMass.push_back( p4XsDaug.mass()); } else if ( Daumulti != 0 ) { for ( int k = 0; k < Daumulti; k++ ) { EvtParticle* XsDaugNephew = XsDaug->getDaug( k ); EvtId XsDaugNephewId = XsDaugNephew->getId(); int Nephmulti = XsDaugNephew->getNDaug(); if ( Nephmulti == 0 || abs( EvtPDL::getStdHep( XsDaugNephewId ) ) == 321 || EvtPDL::getStdHep( XsDaugNephewId ) == 310 || EvtPDL::getStdHep( XsDaugNephewId ) == 111 || abs( EvtPDL::getStdHep( XsDaugNephewId ) ) == 211 ) { nTot++; //EvtVector4R p4XsDaugNephew = XsDaugNephew->getP4Lab(); //XDaugNephewId.push_back(EvtPDL::getStdHep(XsDaugNephewId)); //XsDaugNephewMass.push_back( p4XsDaugNephew.mass()); } else { for ( int g = 0; g < Nephmulti; g++ ) { nTot++; //EvtParticle *XsDaugNephewNephew = XsDaugNephew->getDaug(g); //EvtVector4R p4XsDaugNephewNephew = XsDaugNephewNephew->getP4Lab(); //EvtId XsDaugNephewNephewId = XsDaugNephewNephew->getId(); //XDaugNephewId.push_back(EvtPDL::getStdHep(XsDaugNephewNephewId)); //XsDaugNephewMass.push_back( p4XsDaugNephewNephew.mass()); } } } } } //tuple->column("XsDaugId", XDaugId,"Xsmulti", 0, "Xs"); //tuple->column("XsDaugMass", XsDaugMass,"Xsmulti", 0, "Xs"); //tuple->column("nTot", nTot, 0,"nTot", HTRange(0,200)); //tuple->column("XsDaugNephewId", XDaugNephewId,"nTot", 0, "nTot"); //tuple->column("XsDaugNephewMass", XsDaugNephewMass,"nTot", 0, "nTot"); //tuple->dumpData(); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "End EvtGen. Ran on " << nevent << " events." << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runBtoK1273gamma( int nevent, EvtGen& myGenerator ) { static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); TFile* file = new TFile( "BtoK1273gamma.root", "RECREATE" ); //HepTuple *tuple = hfile.ntuple("BtoK1273gamma", 1); int count = 1; EvtParticle* root_part; EvtVectorParticle* vector_part; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/BTOK1273GAMMA.DEC" ); myGenerator.readUDecay( udecay_name ); // Plot kinematics for b->s,gamma int strangeid, antistrangeid; int Bmulti, bId1a, bId1b, bId2a, bId2b, b1Id, b2Id; do { vector_part = new EvtVectorParticle; EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); vector_part->init( UPS4, p_init ); root_part = (EvtParticle*)vector_part; root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle* B1 = root_part->getDaug( 0 ); Bmulti = B1->getNDaug(); if ( Bmulti == 1 ) B1 = B1->getDaug( 0 ); EvtId BId1a = B1->getDaug( 0 )->getId(); bId1a = EvtPDL::getStdHep( BId1a ); EvtId BId1b = B1->getDaug( 1 )->getId(); bId1b = EvtPDL::getStdHep( BId1b ); if ( Bmulti == 1 ) EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "B1" << " bId1a=" << bId1a << " bId1b=" << bId1b << " ndaug=" << B1->getNDaug() << " Bid=" << EvtPDL::getStdHep( B1->getId() ) << std::endl; EvtParticle* B2 = root_part->getDaug( 1 ); Bmulti = B2->getNDaug(); if ( Bmulti == 1 ) B2 = B2->getDaug( 0 ); // B has a daughter which is a string EvtId BId2a = B2->getDaug( 0 )->getId(); bId2a = EvtPDL::getStdHep( BId2a ); EvtId BId2b = B2->getDaug( 1 )->getId(); bId2b = EvtPDL::getStdHep( BId2b ); if ( Bmulti == 1 ) EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "B2" << " bId2a=" << bId2a << " bId2b=" << bId2b << " ndaug=" << B2->getNDaug() << " Bid=" << EvtPDL::getStdHep( B2->getId() ) << std::endl; EvtId B1Id = B1->getId(); b1Id = EvtPDL::getStdHep( B1Id ); EvtId B2Id = B2->getId(); b2Id = EvtPDL::getStdHep( B2Id ); strangeid = 0; antistrangeid = 0; if ( ( b1Id == 511 ) || ( b1Id == -511 ) || ( b2Id == 511 ) || ( b2Id == -511 ) ) { strangeid = 10313; antistrangeid = -10313; } else if ( ( b1Id == 521 ) || ( b1Id == -521 ) || ( b2Id == 521 ) || ( b2Id == -521 ) ) { strangeid = 10323; antistrangeid = -10323; } EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "bId1a " << bId1a << " bId1b " << bId1b << " bId2a " << bId2a << " bId2b " << bId2b << " for event " << count << std::endl; EvtParticle* Bpeng = 0; //int bnum=0; int pengcount = 0; if ( ( ( bId1a == strangeid ) && ( bId1b == 22 ) ) || ( ( bId1a == antistrangeid ) && ( bId1b == 22 ) ) || ( ( bId1b == strangeid ) && ( bId1a == 22 ) ) || ( ( bId1b == antistrangeid ) && ( bId1a == 22 ) ) ) { Bpeng = B1; //bnum=1; pengcount++; } if ( ( ( bId2a == strangeid ) && ( bId2b == 22 ) ) || ( ( bId2a == antistrangeid ) && ( bId2b == 22 ) ) || ( ( bId2b == strangeid ) && ( bId2a == 22 ) ) || ( ( bId2b == antistrangeid ) && ( bId2a == 22 ) ) ) { Bpeng = B2; //bnum=2; pengcount++; } if ( pengcount == 0 ) { Bpeng = B1; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "No penguin decay for event " << count << std::endl; //bnum=0; } else if ( pengcount == 2 ) { Bpeng = B1; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Two penguin decays in event " << count << std::endl; //bnum=0; } Bmulti = Bpeng->getNDaug(); //EvtParticle *Ks = Bpeng->getDaug(0); //EvtParticle *gam = Bpeng->getDaug(1); //EvtVector4R p4Ks = Ks->getP4Lab(); //const EvtVector4R& p4gam = gam->getP4(); // gamma 4-mom in parent's rest frame //EvtId BId = Bpeng->getId(); //EvtId KsId = Ks->getId(); //int Ksmulti = Ks->getNDaug(); //EvtId gamId = gam->getId(); //int bId = EvtPDL::getStdHep(BId); //int XId = EvtPDL::getStdHep(KsId); //int gId = EvtPDL::getStdHep(gamId); //double KsMass = p4Ks.mass(); //double gmass = p4gam.mass(); //double genergy = p4gam.get(0); // debug stuff: EvtGenReport(EVTGEN_INFO,"EvtGen") << "bnum=" << bnum << " pengcount=" << pengcount << " bId=" << bId << " Bmulti=" << Bmulti << " KsId=" << XId << " gId=" << gId << std::endl; //tuple->column("bnum", bnum); //tuple->column("pengcount", pengcount); //tuple->column("bId", bId); //tuple->column("Bmulti", Bmulti); //tuple->column("KsId", XId); //tuple->column("gId", gId); //tuple->column("KsMass", KsMass); //tuple->column("Ksmulti", Ksmulti); //tuple->column("gmass", gmass); //tuple->column("genergy", genergy); //for(int i=0;igetDaug(i); //EvtVector4R p4KsDaug = KsDaug->getP4Lab(); //EvtId KsDaugId = KsDaug->getId(); //int XDaugId = EvtPDL::getStdHep(KsDaugId); //double KsDaugMass = p4KsDaug.mass(); //tuple->column("KsDaugId", XDaugId); //tuple->column("KsDaugMass", KsDaugMass); //} //tuple->dumpData(); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "End EvtGen. Ran on " << nevent << " events." << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runCheckRotBoost() { EvtDiracSpinor sp1, sp2; //Generate ryd/lange random spinors. sp1.set( EvtComplex( 1.0, -2.0 ), EvtComplex( 3.0, 1.0 ), EvtComplex( -4.5, 0.5 ), EvtComplex( 0.2, -0.5 ) ); sp2.set( EvtComplex( 0.1, -1.0 ), EvtComplex( 1.2, -0.5 ), EvtComplex( 3.6, 1.8 ), EvtComplex( -0.2, -0.6 ) ); EvtComplex s = EvtLeptonSCurrent( sp1, sp2 ); EvtComplex p = EvtLeptonPCurrent( sp1, sp2 ); EvtVector4C a = EvtLeptonACurrent( sp1, sp2 ); EvtVector4C v = EvtLeptonVCurrent( sp1, sp2 ); EvtVector4C va = EvtLeptonVACurrent( sp1, sp2 ); EvtTensor4C t = EvtLeptonTCurrent( sp1, sp2 ); //start with boosts... EvtVector4R ranBoost( 2.0, 0.4, -0.8, 0.3 ); EvtDiracSpinor sp1Boost = boostTo( sp1, ranBoost ); EvtDiracSpinor sp2Boost = boostTo( sp2, ranBoost ); EvtComplex sBoost = EvtLeptonSCurrent( sp1Boost, sp2Boost ); EvtComplex pBoost = EvtLeptonPCurrent( sp1Boost, sp2Boost ); EvtVector4C aBoost = EvtLeptonACurrent( sp1Boost, sp2Boost ); EvtVector4C vBoost = EvtLeptonVCurrent( sp1Boost, sp2Boost ); EvtVector4C vaBoost = EvtLeptonVACurrent( sp1Boost, sp2Boost ); EvtTensor4C tBoost = EvtLeptonTCurrent( sp1Boost, sp2Boost ); EvtVector4C aDirBoost = boostTo( a, ranBoost ); EvtVector4C vDirBoost = boostTo( v, ranBoost ); EvtVector4C vaDirBoost = boostTo( va, ranBoost ); EvtTensor4C tDirBoost( t ); tDirBoost.applyBoostTo( ranBoost ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Comparing after doing a random boost" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Scalar " << s << " " << sBoost << s - sBoost << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "PseudoScalar " << p << " " << pBoost << p - pBoost << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "AxialVector " << aDirBoost << " " << aBoost << aDirBoost - aBoost << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Vector " << vDirBoost << " " << vBoost << vDirBoost - vBoost << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "V-A " << vaDirBoost << " " << vaBoost << vaDirBoost - vaBoost << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Tensor " << tDirBoost << " " << tBoost << tDirBoost - tBoost << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Done comparing after doing a random boost" << std::endl; //Now do rotations... //start with boosts... double alpha = 0.4; double beta = -0.61; double gamma = 3.0; EvtDiracSpinor sp1Rot = rotateEuler( sp1, alpha, beta, gamma ); EvtDiracSpinor sp2Rot = rotateEuler( sp2, alpha, beta, gamma ); EvtComplex sRot = EvtLeptonSCurrent( sp1Rot, sp2Rot ); EvtComplex pRot = EvtLeptonPCurrent( sp1Rot, sp2Rot ); EvtVector4C aRot = EvtLeptonACurrent( sp1Rot, sp2Rot ); EvtVector4C vRot = EvtLeptonVCurrent( sp1Rot, sp2Rot ); EvtVector4C vaRot = EvtLeptonVACurrent( sp1Rot, sp2Rot ); EvtTensor4C tRot = EvtLeptonTCurrent( sp1Rot, sp2Rot ); EvtVector4C aDirRot( a ); EvtVector4C vDirRot( v ); EvtVector4C vaDirRot( va ); EvtTensor4C tDirRot( t ); aDirRot.applyRotateEuler( alpha, beta, gamma ); vDirRot.applyRotateEuler( alpha, beta, gamma ); vaDirRot.applyRotateEuler( alpha, beta, gamma ); tDirRot.applyRotateEuler( alpha, beta, gamma ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Comparing after doing a random rotation" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Scalar " << s << " " << sRot << s - sRot << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "PseudoScalar " << p << " " << pRot << p - pRot << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "AxialVector " << aDirRot << " " << aRot << aDirRot - aRot << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Vector " << vDirRot << " " << vRot << vDirRot - vRot << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "V-A " << vaDirRot << " " << vaRot << vaDirRot - vaRot << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Tensor " << tDirRot << " " << tRot << tDirRot - tRot << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Done comparing after doing a random rotation" << std::endl; EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } int countInclusive( std::string name, EvtParticle* root_part, TH1F* mom, TH1F* mass ) { EvtParticle* p = root_part; int temp = 0; EvtId searchFor = EvtPDL::getId( name ); do { EvtId type = p->getId(); if ( type == searchFor ) { temp += 1; if ( mom ) mom->Fill( p->getP4Lab().d3mag() ); if ( mass ) mass->Fill( p->mass() ); //if ( theBs.contains(p->getParent()->getId()) ) { //dirPsimom->Fill(p->getP4Lab().d3mag()); //} //EvtGenReport(EVTGEN_INFO,"EvtGen") << "LANGE " << p->getP4Lab().d3mag() << " " << p->getP4Lab().get(3)/p->getP4Lab().d3mag() << std::endl; } p = p->nextIter( root_part ); } while ( p != 0 ); return temp; } int countInclusiveSubTree( std::string name, EvtParticle* root_part, EvtIdSet setIds, TH1F* /*mom*/ ) { int temp = 0; EvtParticle* p = root_part; do { if ( setIds.contains( p->getId() ) ) { temp += countInclusive( name, p ); } //p->printTree(); p = p->nextIter( root_part ); } while ( p != 0 ); //EvtGenReport(EVTGEN_INFO,"EvtGen") << "done"<getId(); if ( type == searchFor ) { if ( p->getParent() ) { if ( setIds.contains( p->getParent()->getId() ) ) { temp += 1; if ( mom ) mom->Fill( p->getP4Lab().d3mag() ); } } } p = p->nextIter( root_part ); } while ( p != 0 ); return temp; } void runBMix( int nevent, EvtGen& myGenerator, std::string userFile, std::string rootFile ) { TFile* file = new TFile( rootFile.c_str(), "RECREATE" ); TH1F* b0_b0 = new TH1F( "h1", "dt B0-B0", 100, -15.0, 15.0 ); TH1F* b0b_b0b = new TH1F( "h2", "dt B0B-B0B", 100, -15.0, 15.0 ); TH1F* b0b_b0 = new TH1F( "h3", "dt B0B-B0", 100, -15.0, 15.0 ); TH1F* b0_b0b = new TH1F( "h4", "dt B0-B0B", 100, -15.0, 15.0 ); int count = 1; myGenerator.readUDecay( userFile.c_str() ); EvtId b0 = EvtPDL::getId( "B0" ); EvtId b0b = EvtPDL::getId( "anti-B0" ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); std::ofstream outmix; TString outFileName( rootFile.c_str() ); outFileName.ReplaceAll( ".root", ".dat" ); outmix.open( outFileName.Data() ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtId id1 = root_part->getDaug( 0 )->getId(); EvtId id2 = root_part->getDaug( 1 )->getId(); double t1 = root_part->getDaug( 0 )->getLifetime(); double t2 = root_part->getDaug( 1 )->getLifetime(); double dt = ( t1 - t2 ) / ( 1e-12 * 3e11 ); if ( id1 == b0 && id2 == b0 ) { b0_b0->Fill( dt ); outmix << dt << " 1" << std::endl; } if ( id1 == b0b && id2 == b0b ) { b0b_b0b->Fill( dt ); outmix << dt << " 2" << std::endl; } if ( id1 == b0b && id2 == b0 ) { b0b_b0->Fill( dt ); outmix << dt << " 0" << std::endl; } if ( id1 == b0 && id2 == b0b ) { b0_b0b->Fill( dt ); outmix << dt << " 0" << std::endl; } root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runDDalitz( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "ddalitz.root", "RECREATE" ); TH2F* dalitz = new TH2F( "h1", "m^2!?[K-[p]+! vs m^2!?[K-[p]0!", 70, 0.0, 3.5, 70, 0.0, 3.5 ); TH2F* dalitz2 = new TH2F( "h5", "m^2!([p]^-![p]^0!) vs m^2!([K-[p]+!", 100, 0.0, 3.5, 100, 0.0, 2.0 ); TH1F* m12 = new TH1F( "h2", "m?[K-[p]+!", 100, 0.0, 3.0 ); TH1F* m13 = new TH1F( "h3", "m?[K-[p]0!", 100, 0.0, 3.0 ); TH1F* m23 = new TH1F( "h4", "m?[[p]+[p]0!", 100, 0.0, 2.0 ); int count; myGenerator.readUDecay( "exampleFiles/DDALITZ.DEC" ); count = 1; static EvtId D0 = EvtPDL::getId( std::string( "D0" ) ); std::ofstream outmix; outmix.open( "ddalitz.dat" ); do { EvtVector4R p_init( EvtPDL::getMass( D0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( D0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtVector4R p1 = root_part->getDaug( 0 )->getP4Lab(); EvtVector4R p2 = root_part->getDaug( 1 )->getP4Lab(); EvtVector4R p3 = root_part->getDaug( 2 )->getP4Lab(); dalitz->Fill( ( p1 + p2 ).mass2(), ( p1 + p3 ).mass2(), 1.0 ); dalitz2->Fill( ( p1 + p2 ).mass2(), ( p2 + p3 ).mass2(), 1.0 ); m12->Fill( ( p1 + p2 ).mass2() ); m13->Fill( ( p1 + p3 ).mass2() ); m23->Fill( ( p2 + p3 ).mass2() ); outmix << ( p1 + p2 ).mass2() << " " << ( p2 + p3 ).mass2() << " " << ( p1 + p3 ).mass2() << std::endl; root_part->deleteTree(); if ( count == nevent - 1 ) { std::ofstream testi( "testi.dat" ); double val = m12->GetMean(); double errval = m12->GetMeanError(); testi << "evtgenlhc_test1 1 " << val << " " << errval << std::endl; val = m23->GetMean(); errval = m23->GetMeanError(); testi << "evtgenlhc_test1 2 " << val << " " << errval << std::endl; } } while ( count++ < nevent ); file->Write(); file->Close(); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPiPiPi( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "pipipi.dat" ); int count; EvtVector4R p4pip, p4pim, p4pi0; myGenerator.readUDecay( "exampleFiles/PIPIPI.DEC" ); count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); p4pip = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); p4pim = root_part->getDaug( 0 )->getDaug( 1 )->getP4Lab(); p4pi0 = root_part->getDaug( 0 )->getDaug( 2 )->getP4Lab(); outmix << root_part->getDaug( 0 )->getLifetime() << " " << root_part->getDaug( 1 )->getLifetime() << " "; outmix << ( p4pip + p4pim ).mass2() << " " << ( p4pip + p4pi0 ).mass2() << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runBHadronic( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "bhadronic.dat" ); int count; myGenerator.readUDecay( "exampleFiles/BHADRONIC.DEC" ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle* p; // root_part->printTree(); p = root_part; do { outmix << p->getId().getId() << " " << p->getP4Lab().d3mag() << std::endl; p = p->nextIter(); } while ( p != 0 ); root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runSingleB( int nevent, EvtGen& myGenerator ) { int count; static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); count = 1; do { EvtVector4R p_init( EvtPDL::getMass( B0 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B0, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); root_part->deleteTree(); } while ( count++ < nevent ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPiPiPiPi( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "pipipipi.dat" ); int count; EvtVector4R p4pi1, p4pi2, p4pi3, p4pi4; myGenerator.readUDecay( "exampleFiles/PIPIPIPI.DEC" ); count = 1; EvtParticle *bcp, *btag; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } EvtId tag; //cp tag if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } p4pi1 = bcp->getDaug( 0 )->getP4Lab(); p4pi2 = bcp->getDaug( 1 )->getP4Lab(); p4pi3 = bcp->getDaug( 2 )->getP4Lab(); p4pi4 = bcp->getDaug( 3 )->getP4Lab(); EvtVector4R p4bcp, p4rho0, p4a2; p4rho0 = p4pi1 + p4pi2; p4a2 = p4rho0 + p4pi3; p4bcp = p4a2 + p4pi4; outmix << bcp->getLifetime() << " " << btag->getLifetime() << " " << tag.getId() << " " << ( p4pi1 + p4pi2 + p4pi3 ).mass() << " " << ( p4pi1 + p4pi2 ).mass() << " " << EvtDecayAngle( p4bcp, p4rho0 + p4pi3, p4rho0 ) << " " << EvtDecayAngle( p4a2, p4pi1 + p4pi2, p4pi1 ) << std::endl; root_part->deleteTree(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "count:" << count << std::endl; } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runA2Pi( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "a2pi.dat" ); int count; myGenerator.readUDecay( "exampleFiles/A2PI.DEC" ); EvtParticle *bcp, *btag; EvtParticle *a2, *rho0, *pi1, *pi2, *pi3, *pi4; EvtVector4R p4bcp, p4a2, p4rho0, p4pi1, p4pi2, p4pi3, p4pi4; count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } a2 = bcp->getDaug( 0 ); pi1 = bcp->getDaug( 1 ); rho0 = a2->getDaug( 0 ); pi2 = a2->getDaug( 1 ); pi3 = rho0->getDaug( 0 ); pi4 = rho0->getDaug( 1 ); p4bcp = bcp->getP4Lab(); p4a2 = a2->getP4Lab(); p4pi1 = pi1->getP4Lab(); p4rho0 = rho0->getP4Lab(); p4pi2 = pi2->getP4Lab(); p4pi3 = pi3->getP4Lab(); p4pi4 = pi4->getP4Lab(); EvtId tag; //cp tag if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } outmix << bcp->getLifetime() << " " << btag->getLifetime() << " " << EvtDecayAngle( p4bcp, p4rho0 + p4pi2, p4rho0 ) << " " << EvtDecayAngle( p4a2, p4pi3 + p4pi4, p4pi3 ) << " " << EvtPDL::getStdHep( tag ) << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runHelAmp( int nevent, EvtGen& myGenerator, std::string userFile, std::string rootFile ) { TFile* file = new TFile( rootFile.c_str(), "RECREATE" ); TH1F* costheta = new TH1F( "h1", "costheta", 100, -1.0, 1.0 ); TH1F* costheta2 = new TH1F( "h2", "costheta2", 100, -1.0, 1.0 ); int count; myGenerator.readUDecay( userFile.c_str() ); count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtVector4R d14 = root_part->getDaug( 0 )->getP4Lab(); double c = d14.get( 3 ) / d14.d3mag(); costheta->Fill( c ); EvtVector4R p = root_part->getP4Lab(); EvtVector4R q = root_part->getDaug( 0 )->getP4Lab(); EvtVector4R d = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); costheta2->Fill( EvtDecayAngle( p, q, d ) ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runHelAmp2( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "helamp2.root", "RECREATE" ); TH1F* costheta = new TH1F( "h1", "costheta", 100, -1.0, 1.0 ); int count; myGenerator.readUDecay( "exampleFiles/HELAMP2.DEC" ); count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtVector4R p = root_part->getDaug( 0 )->getDaug( 0 )->getP4Lab(); EvtVector4R q = root_part->getDaug( 0 )->getDaug( 0 )->getDaug( 0 )->getP4Lab(); EvtVector4R d = root_part->getDaug( 0 ) ->getDaug( 0 ) ->getDaug( 0 ) ->getDaug( 0 ) ->getP4Lab(); costheta->Fill( EvtDecayAngle( p, q, d ) ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runD2Pi( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "d2pi.root", "RECREATE" ); TH1F* cospi = new TH1F( "h1", "cos[Q]?[p]!", 50, -1.0, 1.0 ); TH1F* ptpi = new TH1F( "h2", "Pt of pion", 50, 0.0, 1.5 ); TH1F* ppi = new TH1F( "h3", "P?[p]! in [Y](4S) rest frame", 50, 0.0, 1.5 ); int count; myGenerator.readUDecay( "exampleFiles/D2PI.DEC" ); EvtParticle* b; EvtParticle *d2, *pi; EvtVector4R p4b, p4d2, p4pi; count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); b = root_part->getDaug( 0 ); d2 = b->getDaug( 0 ); pi = d2->getDaug( 1 ); p4b = b->getP4Lab(); p4d2 = d2->getP4Lab(); p4pi = pi->getP4Lab(); cospi->Fill( EvtDecayAngle( p4b, p4d2, p4pi ) ); ptpi->Fill( sqrt( p4pi.get( 2 ) * p4pi.get( 2 ) + p4pi.get( 3 ) * p4pi.get( 3 ) ) ); ppi->Fill( p4pi.d3mag() ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPiPiCPT( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "pipicpt.dat" ); int count; myGenerator.readUDecay( "exampleFiles/PIPICPT.DEC" ); EvtParticle *bcp, *btag; count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } EvtId tag; //cp tag if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } outmix << bcp->getLifetime() << " " << btag->getLifetime() << " " << tag.getId() << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runJpsiKs( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "jpsiks.dat" ); int count; myGenerator.readUDecay( "exampleFiles/JPSIKS.DEC" ); EvtParticle *bcp, *btag; count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId B0 = EvtPDL::getId( std::string( "B0" ) ); static EvtId B0B = EvtPDL::getId( std::string( "anti-B0" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); if ( root_part->getDaug( 0 )->getNDaug() == 3 ) { btag = root_part->getDaug( 0 ); bcp = root_part->getDaug( 1 ); } else { bcp = root_part->getDaug( 0 ); btag = root_part->getDaug( 1 ); } EvtId tag; //cp tag if ( btag->getId() == B0B ) { tag = B0; } else { tag = B0B; } outmix << bcp->getLifetime() << " " << btag->getLifetime() << " " << tag.getId() << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runDump( int nevent, EvtGen& myGenerator ) { int count; std::ofstream outmix; outmix.open( "dump.dat" ); EvtParticle* p; myGenerator.readUDecay( "exampleFiles/DUMP.DEC" ); count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId PIP = EvtPDL::getId( std::string( "pi+" ) ); static EvtId PIM = EvtPDL::getId( std::string( "pi-" ) ); static EvtId EP = EvtPDL::getId( std::string( "e+" ) ); static EvtId KP = EvtPDL::getId( std::string( "K+" ) ); static EvtId MUP = EvtPDL::getId( std::string( "mu+" ) ); static EvtId EM = EvtPDL::getId( std::string( "e-" ) ); static EvtId KM = EvtPDL::getId( std::string( "K-" ) ); static EvtId MUM = EvtPDL::getId( std::string( "mu-" ) ); static EvtId GAMM = EvtPDL::getId( std::string( "gamma" ) ); static EvtId K0L = EvtPDL::getId( std::string( "K_L0" ) ); do { if ( count == 100 * ( count / 100 ) ) { EvtGenReport( EVTGEN_INFO, "EvtGen" ) << count << std::endl; } EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); p = root_part; EvtParticle* otherb = root_part->getDaug( 1 ); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "Event:" << count << std::endl; root_part->printTree(); outmix << "B" << " " << otherb->getP4Lab().get( 0 ) << " " << otherb->getP4Lab().get( 1 ) << " " << otherb->getP4Lab().get( 2 ) << " " << otherb->getP4Lab().get( 3 ) << std::endl; do { if ( p->getId() == PIP || p->getId() == EP || p->getId() == KP || p->getId() == MUP ) { outmix << "chg +1" << " " << p->getP4Lab().get( 1 ) << " " << p->getP4Lab().get( 2 ) << " " << p->getP4Lab().get( 3 ) << std::endl; } if ( p->getId() == PIM || p->getId() == EM || p->getId() == KM || p->getId() == MUM ) { outmix << "chg -1" << " " << p->getP4Lab().get( 1 ) << " " << p->getP4Lab().get( 2 ) << " " << p->getP4Lab().get( 3 ) << std::endl; } if ( p->getId() == GAMM || p->getId() == K0L ) { outmix << "neu" << " " << p->getP4Lab().get( 1 ) << " " << p->getP4Lab().get( 2 ) << " " << p->getP4Lab().get( 3 ) << std::endl; } p = p->nextIter(); } while ( p != 0 ); outmix << "event" << std::endl; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runGenericCont( int nevent, EvtGen& myGenerator ) { int count; std::ofstream outmix; outmix.open( "genericcont.dat" ); EvtParticle* p; myGenerator.readUDecay( "exampleFiles/GENERIC.DEC" ); count = 1; static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); static EvtId VPHO = EvtPDL::getId( std::string( "vpho" ) ); do { if ( count == 1000 * ( count / 1000 ) ) { EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << count << std::endl; } EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( VPHO, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); p = root_part; do { outmix << p->getId().getId() << " " << p->getP4Lab().d3mag() << std::endl; p = p->nextIter(); } while ( p != 0 ); //root_part->printTree(); root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runD1( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "d1.dat" ); int count = 1; myGenerator.readUDecay( "exampleFiles/D1.DEC" ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); EvtParticle *p_b, *p_d1, *p_e, *p_nu, *p_pi1, *p_dstar, *p_pi2, *p_d; EvtVector4R p4_b, p4_d1, p4_e, p4_nu, p4_pi1, p4_dstar, p4_pi2, p4_d; // code for analyzing B->D1 e nu ; D1 -> D* pi ; D* -> D pi p_b = root_part->getDaug( 1 ); p_d1 = p_b->getDaug( 0 ); p_e = p_b->getDaug( 1 ); p_nu = p_b->getDaug( 2 ); p_dstar = p_d1->getDaug( 0 ); p_pi1 = p_d1->getDaug( 1 ); p_d = p_dstar->getDaug( 0 ); p_pi2 = p_dstar->getDaug( 1 ); p4_b = p_b->getP4Lab(); p4_d1 = p_d1->getP4Lab(); p4_e = p_e->getP4Lab(); p4_nu = p_nu->getP4Lab(); p4_dstar = p_dstar->getP4Lab(); p4_pi1 = p_pi1->getP4Lab(); p4_pi2 = p_pi2->getP4Lab(); p4_d = p_d->getP4Lab(); outmix << p4_e.get( 0 ) << " "; outmix << ( p4_e + p4_nu ) * ( p4_e + p4_nu ) << " "; outmix << EvtDecayAngle( p4_b, p4_e + p4_nu, p4_e ) << " "; outmix << EvtDecayAngle( p4_b, p4_dstar + p4_pi1, p4_dstar ) << " "; outmix << EvtDecayAngle( p4_d1, p4_d + p4_pi2, p4_d ) << " "; outmix << EvtDecayAngleChi( p4_b, p4_e, p4_nu, p4_dstar, p4_pi1 ) << "\n"; root_part->deleteTree(); EvtGenReport( EVTGEN_DEBUG, "EvtGen" ) << "count:" << count << std::endl; } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runMix( int nevent, EvtGen& myGenerator ) { std::ofstream outmix; outmix.open( "mix.dat" ); int count = 1; myGenerator.readUDecay( "exampleFiles/MIX.DEC" ); static EvtId UPS4 = EvtPDL::getId( std::string( "Upsilon(4S)" ) ); do { EvtVector4R p_init( EvtPDL::getMass( UPS4 ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( UPS4, p_init ); root_part->setVectorSpinDensity(); myGenerator.generateDecay( root_part ); outmix << root_part->getDaug( 0 )->getId().getId() << " "; outmix << root_part->getDaug( 0 )->getLifetime() << " "; outmix << root_part->getDaug( 1 )->getId().getId() << " "; outmix << root_part->getDaug( 1 )->getLifetime() << "\n"; root_part->deleteTree(); } while ( count++ < nevent ); outmix.close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runBaryonic( int nEvent, EvtGen& myGenerator ) { TFile* f = new TFile( "baryonic.root", "RECREATE" ); TH1D* q2Hist = new TH1D( "q2Hist", "q square", 50, 0.0, 25.00 ); EvtId BMINUS = EvtPDL::getId( "B-" ); EvtVector4R p_init( EvtPDL::getMass( BMINUS ), 0.0, 0.0, 0.0 ); EvtParticle* root_part; myGenerator.readUDecay( "exampleFiles/BARYONIC.DEC" ); EvtVector4R l; EvtVector4R p; EvtVector4R g; EvtVector4R sum; for ( int i = 0; i < nEvent; ++i ) { root_part = EvtParticleFactory::particleFactory( BMINUS, p_init ); root_part->setDiagonalSpinDensity(); myGenerator.generateDecay( root_part ); l = root_part->getDaug( 0 )->getP4Lab(); // lambda momentum p = root_part->getDaug( 1 )->getP4Lab(); // pBar momentum g = root_part->getDaug( 2 )->getP4Lab(); // gamma momentum sum = p + g; q2Hist->Fill( sum.mass2() ); root_part->deleteTree(); } f->Write(); f->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void runPhspDecaytimeCut( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "phspdecaytimecut.root", "RECREATE" ); TH1F* thist = new TH1F( "h1", "t [ps]", 100, 0.0, 10.0 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/PhspDecaytimeCut.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId B = EvtPDL::getId( std::string( "B+" ) ); std::ofstream outmix; do { EvtVector4R pinit( EvtPDL::getMass( B ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B, pinit ); myGenerator.generateDecay( root_part ); double t = root_part->getLifetime() / ( 1e-12 * EvtConst::c ); thist->Fill( t ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } void run3BPhspRegion( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "3BodyPhspRegion.root", "RECREATE" ); TH1F* pxhist = new TH1F( "h1", "p_x ", 100, -3.0, 3.0 ); TH1F* pyhist = new TH1F( "h2", "p_y ", 100, -3.0, 3.0 ); TH1F* pzhist = new TH1F( "h3", "p_z ", 100, -3.0, 3.0 ); TH2F* dalitz = new TH2F( "h4", "Dalitz", 50, 12.5, 27., 50, 0.35, 4.8 ); TH2F* pxpyhist = new TH2F( "h5", "px-py", 50, -1.8, 1.8, 50, -1.8, 1.8 ); TH2F* pxpzhist = new TH2F( "h6", "px-pz", 50, -1.8, 1.8, 50, -1.8, 1.8 ); TH2F* pypzhist = new TH2F( "h7", "py-pz", 50, -1.8, 1.8, 50, -1.8, 1.8 ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/3BodyPhspRegion.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId B = EvtPDL::getId( std::string( "B+" ) ); std::ofstream outmix; do { EvtVector4R pinit( EvtPDL::getMass( B ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B, pinit ); myGenerator.generateDecay( root_part ); EvtParticle* daug1 = root_part->getDaug( 0 ); EvtParticle* daug2 = root_part->getDaug( 1 ); EvtParticle* daug3 = root_part->getDaug( 2 ); pxhist->Fill( daug1->getP4().get( 1 ) ); pyhist->Fill( daug1->getP4().get( 2 ) ); pzhist->Fill( daug1->getP4().get( 3 ) ); pxpyhist->Fill( daug1->getP4().get( 1 ), daug1->getP4().get( 2 ) ); pxpzhist->Fill( daug1->getP4().get( 1 ), daug1->getP4().get( 3 ) ); pypzhist->Fill( daug1->getP4().get( 2 ), daug1->getP4().get( 3 ) ); double m12 = ( daug1->getP4() + daug2->getP4() ).mass(); double m23 = ( daug2->getP4() + daug3->getP4() ).mass(); dalitz->Fill( m12 * m12, m23 * m23 ); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } -void runFlatSqDalitz( int nevent, EvtGen& myGenerator ) -{ - TFile* file = new TFile( "flatSqDalitz.root", "RECREATE" ); - - TH2F* dalitz = new TH2F( "h4", "Dalitz", 50, 0.0, 1.0, 50, 0.0, 1.0 ); - - int count = 1; - - char udecay_name[100]; - strcpy( udecay_name, "exampleFiles/flatSqDalitz.dec" ); - myGenerator.readUDecay( udecay_name ); - - static EvtId B = EvtPDL::getId( std::string( "Lambda_b0" ) ); - - do { - EvtVector4R pinit( EvtPDL::getMass( B ), 0.0, 0.0, 0.0 ); - - EvtParticle* root_part = EvtParticleFactory::particleFactory( B, pinit ); - - myGenerator.generateDecay( root_part ); - - double mB = root_part->mass(); - double m1 = root_part->getDaug( 0 )->mass(); - double m2 = root_part->getDaug( 1 )->mass(); - double m3 = root_part->getDaug( 2 )->mass(); - double mBSq{ mB * mB }; - double m1Sq{ m1 * m1 }; - double m2Sq{ m2 * m2 }; - double m3Sq{ m3 * m3 }; - - EvtParticle* daug1 = root_part->getDaug( 0 ); - EvtParticle* daug2 = root_part->getDaug( 1 ); - EvtParticle* daug3 = root_part->getDaug( 2 ); - double m12 = ( daug1->getP4() + daug2->getP4() ).mass(); - double m13 = ( daug1->getP4() + daug3->getP4() ).mass(); - double m12Sq{ m12 * m12 }; - double m13Sq{ m13 * m13 }; - - double m12norm = - 2 * ( ( m12 - ( m1 + m2 ) ) / ( mB - ( m1 + m2 + m3 ) ) ) - 1; - double mPrime = acos( m12norm ) / EvtConst::pi; - double en1 = ( m12Sq - m2Sq + m1Sq ) / ( 2.0 * m12 ); - double en3 = ( mBSq - m12Sq - m3Sq ) / ( 2.0 * m12 ); - double p1 = std::sqrt( en1 * en1 - m1Sq ); - double p3 = std::sqrt( en3 * en3 - m3Sq ); - double cosTheta = ( -m13Sq + m1Sq + m3Sq + 2. * en1 * en3 ) / - ( 2. * p1 * p3 ); - double thPrime = acos( cosTheta ) / EvtConst::pi; - - dalitz->Fill( mPrime, thPrime ); - - root_part->deleteTree(); - } while ( count++ < nevent ); - - file->Write(); - file->Close(); - EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; -} - void runFourBody( int nevent, EvtGen& myGenerator ) { TFile* file = new TFile( "fourBody.root", "RECREATE" ); double m12, m13, m14, m23, m24, m34, m123, m124, m234; double mB, m1, m2, m3, m4; double pBe, pBx, pBy, pBz; double p1e, p1x, p1y, p1z; double p2e, p2x, p2y, p2z; double p3e, p3x, p3y, p3z; double p4e, p4x, p4y, p4z; double theta1, theta3, chi; - TTree* tree = new TTree( "tree", ""); - tree->Branch("m12", &m12, "m12/D"); - tree->Branch("m13", &m13, "m13/D"); - tree->Branch("m14", &m14, "m14/D"); - tree->Branch("m23", &m23, "m23/D"); - tree->Branch("m24", &m24, "m24/D"); - tree->Branch("m34", &m34, "m34/D"); - tree->Branch("m123", &m123, "m123/D"); - tree->Branch("m124", &m124, "m124/D"); - tree->Branch("m234", &m234, "m234/D"); - tree->Branch("mB", &mB, "mB/D"); - tree->Branch("m1", &m1, "m1/D"); - tree->Branch("m2", &m2, "m2/D"); - tree->Branch("m3", &m3, "m3/D"); - tree->Branch("m4", &m4, "m4/D"); - tree->Branch("pBe", &pBe, "pBe/D"); - tree->Branch("pBx", &pBx, "pBx/D"); - tree->Branch("pBy", &pBy, "pBy/D"); - tree->Branch("pBz", &pBz, "pBz/D"); - tree->Branch("p1e", &p1e, "p1e/D"); - tree->Branch("p1x", &p1x, "p1x/D"); - tree->Branch("p1y", &p1y, "p1y/D"); - tree->Branch("p1z", &p1z, "p1z/D"); - tree->Branch("p2e", &p2e, "p2e/D"); - tree->Branch("p2x", &p2x, "p2x/D"); - tree->Branch("p2y", &p2y, "p2y/D"); - tree->Branch("p2z", &p2z, "p2z/D"); - tree->Branch("p3e", &p3e, "p3e/D"); - tree->Branch("p3x", &p3x, "p3x/D"); - tree->Branch("p3y", &p3y, "p3y/D"); - tree->Branch("p3z", &p3z, "p3z/D"); - tree->Branch("p4e", &p4e, "p4e/D"); - tree->Branch("p4x", &p4x, "p4x/D"); - tree->Branch("p4y", &p4y, "p4y/D"); - tree->Branch("p4z", &p4z, "p4z/D"); - tree->Branch("theta1", &theta1, "theta1/D"); - tree->Branch("theta3", &theta3, "theta3/D"); - tree->Branch("chi", &chi, "chi/D"); + TTree* tree = new TTree( "tree", "" ); + tree->Branch( "m12", &m12, "m12/D" ); + tree->Branch( "m13", &m13, "m13/D" ); + tree->Branch( "m14", &m14, "m14/D" ); + tree->Branch( "m23", &m23, "m23/D" ); + tree->Branch( "m24", &m24, "m24/D" ); + tree->Branch( "m34", &m34, "m34/D" ); + tree->Branch( "m123", &m123, "m123/D" ); + tree->Branch( "m124", &m124, "m124/D" ); + tree->Branch( "m234", &m234, "m234/D" ); + tree->Branch( "mB", &mB, "mB/D" ); + tree->Branch( "m1", &m1, "m1/D" ); + tree->Branch( "m2", &m2, "m2/D" ); + tree->Branch( "m3", &m3, "m3/D" ); + tree->Branch( "m4", &m4, "m4/D" ); + tree->Branch( "pBe", &pBe, "pBe/D" ); + tree->Branch( "pBx", &pBx, "pBx/D" ); + tree->Branch( "pBy", &pBy, "pBy/D" ); + tree->Branch( "pBz", &pBz, "pBz/D" ); + tree->Branch( "p1e", &p1e, "p1e/D" ); + tree->Branch( "p1x", &p1x, "p1x/D" ); + tree->Branch( "p1y", &p1y, "p1y/D" ); + tree->Branch( "p1z", &p1z, "p1z/D" ); + tree->Branch( "p2e", &p2e, "p2e/D" ); + tree->Branch( "p2x", &p2x, "p2x/D" ); + tree->Branch( "p2y", &p2y, "p2y/D" ); + tree->Branch( "p2z", &p2z, "p2z/D" ); + tree->Branch( "p3e", &p3e, "p3e/D" ); + tree->Branch( "p3x", &p3x, "p3x/D" ); + tree->Branch( "p3y", &p3y, "p3y/D" ); + tree->Branch( "p3z", &p3z, "p3z/D" ); + tree->Branch( "p4e", &p4e, "p4e/D" ); + tree->Branch( "p4x", &p4x, "p4x/D" ); + tree->Branch( "p4y", &p4y, "p4y/D" ); + tree->Branch( "p4z", &p4z, "p4z/D" ); + tree->Branch( "theta1", &theta1, "theta1/D" ); + tree->Branch( "theta3", &theta3, "theta3/D" ); + tree->Branch( "chi", &chi, "chi/D" ); int count = 1; char udecay_name[100]; strcpy( udecay_name, "exampleFiles/4BodyPhsp.DEC" ); myGenerator.readUDecay( udecay_name ); static EvtId B = EvtPDL::getId( std::string( "B+" ) ); do { EvtVector4R pinit( EvtPDL::getMass( B ), 0.0, 0.0, 0.0 ); EvtParticle* root_part = EvtParticleFactory::particleFactory( B, pinit ); myGenerator.generateDecay( root_part ); mB = root_part->mass(); m1 = root_part->getDaug( 0 )->mass(); m2 = root_part->getDaug( 1 )->mass(); m3 = root_part->getDaug( 2 )->mass(); m4 = root_part->getDaug( 3 )->mass(); EvtParticle* daug1 = root_part->getDaug( 0 ); EvtParticle* daug2 = root_part->getDaug( 1 ); EvtParticle* daug3 = root_part->getDaug( 2 ); EvtParticle* daug4 = root_part->getDaug( 3 ); m12 = ( daug1->getP4() + daug2->getP4() ).mass(); m13 = ( daug1->getP4() + daug3->getP4() ).mass(); m14 = ( daug1->getP4() + daug4->getP4() ).mass(); m23 = ( daug2->getP4() + daug3->getP4() ).mass(); m24 = ( daug2->getP4() + daug4->getP4() ).mass(); m34 = ( daug3->getP4() + daug4->getP4() ).mass(); m123 = ( daug1->getP4() + daug2->getP4() + daug3->getP4() ).mass(); m124 = ( daug1->getP4() + daug2->getP4() + daug4->getP4() ).mass(); m234 = ( daug2->getP4() + daug3->getP4() + daug4->getP4() ).mass(); pBe = root_part->getP4().get( 0 ); pBx = root_part->getP4().get( 1 ); pBy = root_part->getP4().get( 2 ); pBz = root_part->getP4().get( 3 ); p1e = daug1->getP4().get( 0 ); p1x = daug1->getP4().get( 1 ); p1y = daug1->getP4().get( 2 ); p1z = daug1->getP4().get( 3 ); p2e = daug2->getP4().get( 0 ); p2x = daug2->getP4().get( 1 ); p2y = daug2->getP4().get( 2 ); p2z = daug2->getP4().get( 3 ); p3e = daug3->getP4().get( 0 ); p3x = daug3->getP4().get( 1 ); p3y = daug3->getP4().get( 2 ); p3z = daug3->getP4().get( 3 ); p4e = daug4->getP4().get( 0 ); p4x = daug4->getP4().get( 1 ); p4y = daug4->getP4().get( 2 ); p4z = daug4->getP4().get( 3 ); theta1 = EvtDecayAngle( root_part->getP4(), - daug1->getP4() + daug2->getP4(), daug1->getP4() ); + daug1->getP4() + daug2->getP4(), daug1->getP4() ); theta3 = EvtDecayAngle( root_part->getP4(), - daug3->getP4() + daug4->getP4(), daug3->getP4() ); + daug3->getP4() + daug4->getP4(), daug3->getP4() ); chi = EvtDecayAngleChi( root_part->getP4(), daug1->getP4(), daug2->getP4(), daug3->getP4(), daug4->getP4() ); tree->Fill(); root_part->deleteTree(); } while ( count++ < nevent ); file->Write(); file->Close(); EvtGenReport( EVTGEN_INFO, "EvtGen" ) << "SUCCESS\n"; } diff --git a/test/jsonFiles/BC_BSSTAR_NPI__Bc_Bs0star3pi.json b/test/jsonFiles/BC_BSSTAR_NPI__Bc_Bs0star3pi.json new file mode 100644 index 0000000..407b61f --- /dev/null +++ b/test/jsonFiles/BC_BSSTAR_NPI__Bc_Bs0star3pi.json @@ -0,0 +1,17 @@ +{ + "parent" : "B_c+", + "daughters" : ["B_s*0", "pi+", "pi-", "pi+"], + "models" : ["BC_BSSTAR_NPI", "", "", "", ""], + "parameters" : [[], [], [], [], []], + "do_conjugate_decay" : [true, false, false, false, false], + "extras" : ["Define dm_incohMix_B_s0 0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(BC_BSSTAR_NPI)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B_{c}^{+})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 6.2, "xmax" : 6.3}, + {"variable" : "mass", "title" : "m(B_{s}^{*0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.4, "xmax" : 5.5}, + {"variable" : "mass3", "title" : "m(#pi^{+}#pi^{-}#pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0} + ], + "outfile" : "BC_BSSTAR_NPI__Bc_Bs0star3pi.root", + "reference" : "RefBC_BSSTAR_NPI__Bc_Bs0star3pi.root" +} diff --git a/test/jsonFiles/BC_BS_NPI__Bc_Bs03pi.json b/test/jsonFiles/BC_BS_NPI__Bc_Bs03pi.json new file mode 100644 index 0000000..4099e53 --- /dev/null +++ b/test/jsonFiles/BC_BS_NPI__Bc_Bs03pi.json @@ -0,0 +1,17 @@ +{ + "parent" : "B_c+", + "daughters" : ["B_s0", "pi+", "pi-", "pi+"], + "models" : ["BC_BS_NPI", "", "", "", ""], + "parameters" : [[], [], [], [], []], + "do_conjugate_decay" : [true, false, false, false, false], + "extras" : ["Define dm_incohMix_B_s0 0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(BC_BS_NPI)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B_{c}^{+})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 6.2, "xmax" : 6.3}, + {"variable" : "mass", "title" : "m(B_{s}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.3, "xmax" : 5.4}, + {"variable" : "mass3", "title" : "m(#pi^{+}#pi^{-}#pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0} + ], + "outfile" : "BC_BS_NPI__Bc_Bs03pi.root", + "reference" : "RefBC_BS_NPI__Bc_Bs03pi.root" +} diff --git a/test/jsonFiles/BC_PSI_NPI=VLL__Bc_Jpsi3pi,ee.json b/test/jsonFiles/BC_PSI_NPI=VLL__Bc_Jpsi3pi,ee.json new file mode 100644 index 0000000..5b58bab --- /dev/null +++ b/test/jsonFiles/BC_PSI_NPI=VLL__Bc_Jpsi3pi,ee.json @@ -0,0 +1,20 @@ +{ + "parent" : "B_c+", + "daughters" : ["J/psi", "pi+", "pi-", "pi+"], + "grand_daughters" : [["e+", "e-"], [], [], []], + "models" : ["BC_PSI_NPI", "VLL", "", "", ""], + "parameters" : [[], [], [], [], []], + "do_conjugate_decay" : [true, false, false, false, false], + "extras" : ["Define dm_incohMix_B_s0 0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(BC_PSI_NPI)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VLL)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B_{c}^{+})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 6.2, "xmax" : 6.3}, + {"variable" : "mass", "title" : "m(J/#psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.0, "xmax" : 3.2}, + {"variable" : "mass3", "title" : "m(#pi^{+}#pi^{-}#pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "cosHel", "title" : "cosHel(e^{+}, J/#psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BC_PSI_NPI=VLL__Bc_Jpsi3pi,ee.root", + "reference" : "RefBC_PSI_NPI=VLL__Bc_Jpsi3pi,ee.root" +} diff --git a/test/jsonFiles/BC_SMN=SVP__Bc_D0munu,Kst0gamma.json b/test/jsonFiles/BC_SMN=SVP__Bc_D0munu,Kst0gamma.json new file mode 100644 index 0000000..38cd418 --- /dev/null +++ b/test/jsonFiles/BC_SMN=SVP__Bc_D0munu,Kst0gamma.json @@ -0,0 +1,35 @@ +{ + "parent" : "B_c+", + "daughters" : ["D0", "mu+", "nu_mu"], + "grand_daughters" : [["gamma", "K*0"], [], []], + "models" : ["BC_SMN", "SVP", ""], + "parameters" : [["1"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(D0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "mass", "title" : "m(D0 mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : 3.0, "xmax" : 7.0}, + {"variable" : "mass", "title" : "m(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "p", "title" : "p(D0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "pSq", "title" : "pSq(D0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 10.0}, + {"variable" : "pz", "title" : "pz(D0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(D0,mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(gamma)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(K*0)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "E", "title" : "E(D0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 1.5, "xmax" : 4.0}, + {"variable" : "phi", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "E_daug1", "title" : "E(gamma)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K*0)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(gamma)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(gamma)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K*0)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K*0)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BC_SMN=SVP__Bc_D0munu,Kst0gamma.root", + "reference" : "RefBC_SMN=SVP__Bc_D0munu,Kst0gamma.root" +} diff --git a/test/jsonFiles/BC_TMN=TVP__Bc_chic2munu,Jpsigamma.json b/test/jsonFiles/BC_TMN=TVP__Bc_chic2munu,Jpsigamma.json new file mode 100644 index 0000000..b670989 --- /dev/null +++ b/test/jsonFiles/BC_TMN=TVP__Bc_chic2munu,Jpsigamma.json @@ -0,0 +1,36 @@ +{ + "parent" : "B_c+", + "daughters" : ["chi_c2", "mu+", "nu_mu"], + "grand_daughters" : [["gamma", "J/psi"], [], []], + "models" : ["BC_TMN", "TVP", ""], + "parameters" : [["3"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(chi_c2)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.52, "xmax" : 3.6}, + {"variable" : "mass", "title" : "m(chi_c2 mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : 3.0, "xmax" : 7.0}, + {"variable" : "mass", "title" : "m(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSumSq", "title" : "qSq(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 9.0}, + {"variable" : "p", "title" : "p(chi_c2)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pSq", "title" : "pSq(chi_c2)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pz", "title" : "pz(chi_c2)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(chi_c2,mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu,chi_c2)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(gamma)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(J/psi)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(chi_c2)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "E", "title" : "E(chi_c2)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.5, "xmax" : 4.3}, + {"variable" : "phi", "title" : "phi(chi_c2)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "E_daug1", "title" : "E(gamma)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(J/psi)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(gamma)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(gamma)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(J/psi)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(J/psi)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BC_TMN=TVP__Bc_chic2munu,Jpsigamma.root", + "reference" : "RefBC_TMN=TVP__Bc_chic2munu,Jpsigamma.root" +} diff --git a/test/jsonFiles/BC_VHAD=VLL__Bc_psi2SKKpi,mm.json b/test/jsonFiles/BC_VHAD=VLL__Bc_psi2SKKpi,mm.json new file mode 100644 index 0000000..399299c --- /dev/null +++ b/test/jsonFiles/BC_VHAD=VLL__Bc_psi2SKKpi,mm.json @@ -0,0 +1,41 @@ +{ + "parent" : "B_c+", + "daughters" : ["psi(2S)", "K+", "K-", "pi+"], + "grand_daughters" : [["mu+", "mu-"], [], [], []], + "models" : ["BC_VHAD", "VLL", "", "", ""], + "parameters" : [["1"], [], [], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.68, "xmax" : 3.695}, + {"variable" : "mass", "title" : "m(psi2S K+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 4.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(psi2S K-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 4.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(K+K-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(K-pi+)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.6}, + {"variable" : "mass", "title" : "m(psi2S pi+)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 3.5, "xmax" : 5.5}, + {"variable" : "pSumSq", "title" : "qSq(K+ K-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 7.0}, + {"variable" : "p", "title" : "p(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSq", "title" : "pSq(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "pz", "title" : "pz(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.0, "xmax" : 2.0}, + {"variable" : "cosHel", "title" : "cosHel(psi2S,K+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K-,pi+)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+,K-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(psi2S,K-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(mu+,psi2S)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(mu-,psi2S)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "E", "title" : "E(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.5, "xmax" : 4.2}, + {"variable" : "phi", "title" : "phi(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.5}, + {"variable" : "pLab_daug1", "title" : "pLab(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BC_VHAD=VLL__Bc_psi2SKKpi,mm.root", + "reference" : "RefBC_VHAD=VLL__Bc_psi2SKKpi,mm.root" +} diff --git a/test/jsonFiles/BC_VMN=VVPIPI_WEIGHTED__Bc_psi2Smunu,Jpsipipi.json b/test/jsonFiles/BC_VMN=VVPIPI_WEIGHTED__Bc_psi2Smunu,Jpsipipi.json new file mode 100644 index 0000000..1647f2d --- /dev/null +++ b/test/jsonFiles/BC_VMN=VVPIPI_WEIGHTED__Bc_psi2Smunu,Jpsipipi.json @@ -0,0 +1,40 @@ +{ + "parent" : "B_c+", + "daughters" : ["psi(2S)", "mu+", "nu_mu"], + "grand_daughters" : [["J/psi", "pi+", "pi-"], [], []], + "models" : ["BC_VMN", "VVPIPI_WEIGHTED", ""], + "parameters" : [["1"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.68, "xmax" : 3.695}, + {"variable" : "mass", "title" : "m(psi2S mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : 3.0, "xmax" : 7.0}, + {"variable" : "mass", "title" : "m(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSumSq", "title" : "qSq(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "p", "title" : "p(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pSq", "title" : "pSq(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pz", "title" : "pz(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(psi2S,mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu,psi2S)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(J/psi)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(pi+)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "E", "title" : "E(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.6, "xmax" : 4.4}, + {"variable" : "phi", "title" : "phi(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(J/psi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 0.7}, + {"variable" : "pLab_daug1", "title" : "pLab(pi-)", "d1" : 3, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 0.7}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(J/psi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(J/psi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi-)", "d1" : 3, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi-)", "d1" : 3, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BC_VMN=VVPIPI_WEIGHTED__Bc_psi2Smunu,Jpsipipi.root", + "reference" : "RefBC_VMN=VVPIPI_WEIGHTED__Bc_psi2Smunu,Jpsipipi.root" +} diff --git a/test/jsonFiles/BC_VMN=VVPIPI__Bc_psi2Smunu,Jpsipipi.json b/test/jsonFiles/BC_VMN=VVPIPI__Bc_psi2Smunu,Jpsipipi.json new file mode 100644 index 0000000..31cb697 --- /dev/null +++ b/test/jsonFiles/BC_VMN=VVPIPI__Bc_psi2Smunu,Jpsipipi.json @@ -0,0 +1,40 @@ +{ + "parent" : "B_c+", + "daughters" : ["psi(2S)", "mu+", "nu_mu"], + "grand_daughters" : [["J/psi", "pi+", "pi-"], [], []], + "models" : ["BC_VMN", "VVPIPI", ""], + "parameters" : [["1"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.68, "xmax" : 3.695}, + {"variable" : "mass", "title" : "m(psi2S mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : 3.0, "xmax" : 7.0}, + {"variable" : "mass", "title" : "m(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSumSq", "title" : "qSq(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "p", "title" : "p(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pSq", "title" : "pSq(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pz", "title" : "pz(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(psi2S,mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu,psi2S)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(J/psi)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(pi+)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "E", "title" : "E(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.6, "xmax" : 4.4}, + {"variable" : "phi", "title" : "phi(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(J/psi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 0.7}, + {"variable" : "pLab_daug1", "title" : "pLab(pi-)", "d1" : 3, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 0.7}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(J/psi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(J/psi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi-)", "d1" : 3, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi-)", "d1" : 3, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BC_VMN=VVPIPI__Bc_psi2Smunu,Jpsipipi.root", + "reference" : "RefBC_VMN=VVPIPI__Bc_psi2Smunu,Jpsipipi.root" +} diff --git a/test/jsonFiles/BC_VMN=VVP__Bc_psi2Smunu,chi_c1gamma.json b/test/jsonFiles/BC_VMN=VVP__Bc_psi2Smunu,chi_c1gamma.json new file mode 100644 index 0000000..89cac72 --- /dev/null +++ b/test/jsonFiles/BC_VMN=VVP__Bc_psi2Smunu,chi_c1gamma.json @@ -0,0 +1,36 @@ +{ + "parent" : "B_c+", + "daughters" : ["psi(2S)", "mu+", "nu_mu"], + "grand_daughters" : [["chi_c1", "gamma"], [], []], + "models" : ["BC_VMN", "VVP", ""], + "parameters" : [["1"], ["1.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0", "0.0"], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.68, "xmax" : 3.695}, + {"variable" : "mass", "title" : "m(psi2S mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : 3.0, "xmax" : 7.0}, + {"variable" : "mass", "title" : "m(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSumSq", "title" : "qSq(mu nu)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "p", "title" : "p(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pSq", "title" : "pSq(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pz", "title" : "pz(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(psi2S,mu)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu,psi2S)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(chi_c1)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(gamma)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "E", "title" : "E(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 3.6, "xmax" : 4.4}, + {"variable" : "phi", "title" : "phi(psi2S)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(chi_c1)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_daug1", "title" : "E(gamma)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 0.4}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(chi_c1)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(chi_c1)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(gamma)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(gamma)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BC_VMN=VVP__Bc_psi2Smunu,chi_c1gamma.root", + "reference" : "RefBC_VMN=VVP__Bc_psi2Smunu,chi_c1gamma.root" +} diff --git a/test/jsonFiles/BC_VNPI=VLL__Bc_psi2Spipipi,mm.json b/test/jsonFiles/BC_VNPI=VLL__Bc_psi2Spipipi,mm.json new file mode 100644 index 0000000..402e20d --- /dev/null +++ b/test/jsonFiles/BC_VNPI=VLL__Bc_psi2Spipipi,mm.json @@ -0,0 +1,41 @@ +{ + "parent" : "B_c+", + "daughters" : ["psi(2S)", "pi+", "pi-", "pi+"], + "grand_daughters" : [["mu+", "mu-"], [], [], []], + "models" : ["BC_VNPI", "VLL", "", "", ""], + "parameters" : [["1"], [], [], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.684, "xmax" : 3.69}, + {"variable" : "mass", "title" : "m(psi2S pi+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 3.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(psi2S pi-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 3.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(pi+pi-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(pi-pi+)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(psi2S pi+)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 3.5, "xmax" : 6.5}, + {"variable" : "pSumSq", "title" : "qSq(pi+ pi-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "p", "title" : "p(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSq", "title" : "pSq(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pz", "title" : "pz(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.0, "xmax" : 2.0}, + {"variable" : "cosHel", "title" : "cosHel(psi2S,K+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi-,pi+)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi+,K-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(psi2S,K-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(mu+,psi2S)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(mu-,psi2S)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "E", "title" : "E(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.5, "xmax" : 4.2}, + {"variable" : "phi", "title" : "phi(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.5}, + {"variable" : "pLab_daug1", "title" : "pLab(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BC_VNPI=VLL__Bc_psi2Spipipi,mm.root", + "reference" : "RefBC_VNPI=VLL__Bc_psi2Spipipi,mm.root" +} diff --git a/test/jsonFiles/BHADRONIC__Bd_D0pi0.json b/test/jsonFiles/BHADRONIC__Bd_D0pi0.json new file mode 100644 index 0000000..2224ce8 --- /dev/null +++ b/test/jsonFiles/BHADRONIC__Bd_D0pi0.json @@ -0,0 +1,22 @@ +{ + "parent" : "B0", + "daughters" : ["anti-D0", "pi0"], + "models" : ["BHADRONIC", "", ""], + "parameters" : [["1", "1"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "mass", "title" : "m(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.12, "xmax" : 0.15}, + {"variable" : "p", "title" : "p(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BHADRONIC__Bd_D0pi0.root", + "reference" : "RefBHADRONIC__Bd_D0pi0.root" +} diff --git a/test/jsonFiles/BHADRONIC__Bd_D0rho0.json b/test/jsonFiles/BHADRONIC__Bd_D0rho0.json new file mode 100644 index 0000000..55b5d9f --- /dev/null +++ b/test/jsonFiles/BHADRONIC__Bd_D0rho0.json @@ -0,0 +1,22 @@ +{ + "parent" : "B0", + "daughters" : ["anti-D0", "rho0"], + "models" : ["BHADRONIC", "", ""], + "parameters" : [["1", "2"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "mass", "title" : "m(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "p", "title" : "p(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BHADRONIC__Bd_D0rho0.root", + "reference" : "RefBHADRONIC__Bd_D0rho0.root" +} diff --git a/test/jsonFiles/BHADRONIC__Bd_D2star0pi0.json b/test/jsonFiles/BHADRONIC__Bd_D2star0pi0.json new file mode 100644 index 0000000..96e1e0f --- /dev/null +++ b/test/jsonFiles/BHADRONIC__Bd_D2star0pi0.json @@ -0,0 +1,22 @@ +{ + "parent" : "B0", + "daughters" : ["anti-D_2*0", "pi0"], + "models" : ["BHADRONIC", "", ""], + "parameters" : [["4", "1"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.12, "xmax" : 0.15}, + {"variable" : "p", "title" : "p(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.6, "xmax" : 2.2}, + {"variable" : "phi", "title" : "phi(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.6, "xmax" : 2.2}, + {"variable" : "phi", "title" : "phi(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BHADRONIC__Bd_D2star0pi0.root", + "reference" : "RefBHADRONIC__Bd_D2star0pi0.root" +} diff --git a/test/jsonFiles/BHADRONIC__Bd_D2star0rho0.json b/test/jsonFiles/BHADRONIC__Bd_D2star0rho0.json new file mode 100644 index 0000000..465cac8 --- /dev/null +++ b/test/jsonFiles/BHADRONIC__Bd_D2star0rho0.json @@ -0,0 +1,22 @@ +{ + "parent" : "B0", + "daughters" : ["anti-D_2*0", "rho0"], + "models" : ["BHADRONIC", "", ""], + "parameters" : [["4", "2"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "p", "title" : "p(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.2, "xmax" : 2.2}, + {"variable" : "phi", "title" : "phi(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D_2*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.2, "xmax" : 2.2}, + {"variable" : "phi", "title" : "phi(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BHADRONIC__Bd_D2star0rho0.root", + "reference" : "RefBHADRONIC__Bd_D2star0rho0.root" +} diff --git a/test/jsonFiles/BHADRONIC__Bd_Dstar0pi0.json b/test/jsonFiles/BHADRONIC__Bd_Dstar0pi0.json new file mode 100644 index 0000000..0d962fe --- /dev/null +++ b/test/jsonFiles/BHADRONIC__Bd_Dstar0pi0.json @@ -0,0 +1,22 @@ +{ + "parent" : "B0", + "daughters" : ["anti-D*0", "pi0"], + "models" : ["BHADRONIC", "", ""], + "parameters" : [["2", "1"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass", "title" : "m(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.12, "xmax" : 0.15}, + {"variable" : "p", "title" : "p(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BHADRONIC__Bd_Dstar0pi0.root", + "reference" : "RefBHADRONIC__Bd_Dstar0pi0.root" +} diff --git a/test/jsonFiles/BHADRONIC__Bd_Dstar0rho0.json b/test/jsonFiles/BHADRONIC__Bd_Dstar0rho0.json new file mode 100644 index 0000000..79291b4 --- /dev/null +++ b/test/jsonFiles/BHADRONIC__Bd_Dstar0rho0.json @@ -0,0 +1,22 @@ +{ + "parent" : "B0", + "daughters" : ["anti-D*0", "rho0"], + "models" : ["BHADRONIC", "", ""], + "parameters" : [["2", "2"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass", "title" : "m(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "p", "title" : "p(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D*0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(rho0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BHADRONIC__Bd_Dstar0rho0.root", + "reference" : "RefBHADRONIC__Bd_Dstar0rho0.root" +} diff --git a/test/jsonFiles/BLLNUL__Bu_eenumu.json b/test/jsonFiles/BLLNUL__Bu_eenumu.json new file mode 100644 index 0000000..e9b1106 --- /dev/null +++ b/test/jsonFiles/BLLNUL__Bu_eenumu.json @@ -0,0 +1,39 @@ +{ + "parent" : "B+", + "daughters" : ["e-", "e+", "nu_mu", "mu+"], + "models" : ["BLLNUL"], + "parameters" : [[]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(e-e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(e- nu_mu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(e+ nu_mu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(nu_mu mu+)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(e-e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSumSq", "title" : "qSq(nu_mu mu+)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(e-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(e-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(e+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(e+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(nu_mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(nu_mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(e-,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(nu_mu,mu+)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(e+,nu_mu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(e-,nu_mu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(nu_mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(e-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(e+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(nu_mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BLLNUL__Bu_eenumu.root", + "reference" : "RefBLLNUL__Bu_eenumu.root" +} diff --git a/test/jsonFiles/BQTOLLLLHYPERCP__Bd_4mu.json b/test/jsonFiles/BQTOLLLLHYPERCP__Bd_4mu.json new file mode 100644 index 0000000..757ccc0 --- /dev/null +++ b/test/jsonFiles/BQTOLLLLHYPERCP__Bd_4mu.json @@ -0,0 +1,39 @@ +{ + "parent" : "anti-B0", + "daughters" : ["mu+", "mu-", "mu+", "mu-"], + "models" : ["BQTOLLLLHYPERCP"], + "parameters" : [["2.5", "0.214", "0.01", "0.01", "1.0", "1.0", "450.0", "0.0", "450.0", "0.0", "380.0", "0.0", "380.0", "0.0"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 100.0}, + {"variable" : "mass", "title" : "m(mu1+mu1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(mu1+mu2+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(mu1- mu2+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(mu2+ mu2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu1+mu1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "pSumSq", "title" : "qSq(mu2+mu2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(mu1+,mu1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu2+,mu2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu1-,mu2+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu1+,mu2+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BQTOLLLLHYPERCP__Bd_4mu.root", + "reference" : "RefBQTOLLLLHYPERCP__Bd_4mu.root" +} diff --git a/test/jsonFiles/BQTOLLLL__Bs_4mu.json b/test/jsonFiles/BQTOLLLL__Bs_4mu.json new file mode 100644 index 0000000..ebbcc08 --- /dev/null +++ b/test/jsonFiles/BQTOLLLL__Bs_4mu.json @@ -0,0 +1,40 @@ +{ + "parent" : "anti-B_s0", + "daughters" : ["mu+", "mu-", "mu+", "mu-"], + "models" : ["BQTOLLLL"], + "parameters" : [["5.0", "5", "0", "1", "0.88", "0.227", "0.22", "0.34"]], + "do_conjugate_decay" : [true], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 10.0}, + {"variable" : "mass", "title" : "m(mu1+mu1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(mu1+mu2+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(mu1- mu2+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(mu2+ mu2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu1+mu1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "pSumSq", "title" : "qSq(mu2+mu2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(mu1+,mu1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu2+,mu2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu1-,mu2+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu1+,mu2+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(mu1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BQTOLLLL__Bs_4mu.root", + "reference" : "RefBQTOLLLL__Bs_4mu.root" +} diff --git a/test/jsonFiles/BSQUARK__Bu_Dstenue.json b/test/jsonFiles/BSQUARK__Bu_Dstenue.json new file mode 100644 index 0000000..33b443b --- /dev/null +++ b/test/jsonFiles/BSQUARK__Bu_Dstenue.json @@ -0,0 +1,26 @@ +{ + "parent" : "B-", + "daughters" : ["D*0", "e-", "anti-nu_e"], + "models" : ["BSQUARK", "", ""], + "parameters" : [["1.14", "2.0", "1000.0", "100.0", "100.0"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B-)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(D*0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "pSumSq", "title" : "qSq(e,nue)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(D*0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(D*0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D*0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(nue)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "phi", "title" : "phi(nue)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(nue)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "E", "title" : "Dalitz qSq(e,nue) vs E(e)", "d1" : 2, "d2" : 0, "nbins" : 50, "xmin" : 0.0, "xmax" : 2.5, "variableY" : "pSumSq", "d1Y" : 2, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 12.0} + ], + "outfile" : "BSQUARK__Bu_Dstenue.root", + "reference" : "RefBSQUARK__Bu_Dstenue.root" +} diff --git a/test/jsonFiles/BSTOGLLISRFSR__Bs_gammamumu.json b/test/jsonFiles/BSTOGLLISRFSR__Bs_gammamumu.json new file mode 100644 index 0000000..3649520 --- /dev/null +++ b/test/jsonFiles/BSTOGLLISRFSR__Bs_gammamumu.json @@ -0,0 +1,34 @@ +{ + "parent" : "B_s0", + "daughters" : ["gamma", "mu+", "mu-"], + "models" : ["BSTOGLLISRFSR"], + "parameters" : [["5.0", "5", "1", "1", "1", "0.02", "0.814", "0.2254", "0.117", "0.353"]], + "do_conjugate_decay" : [true], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.02}, + {"variable" : "mass", "title" : "m(gamma mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(gamma mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(gamma mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 40.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 40.0}, + {"variable" : "p", "title" : "p(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(gamma,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(gamma,mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BSTOGLLISRFSR__Bs_gammamumu.root", + "reference" : "RefBSTOGLLISRFSR__Bs_gammamumu.root" +} diff --git a/test/jsonFiles/BSTOGLLMNT__Bs_gammamumu.json b/test/jsonFiles/BSTOGLLMNT__Bs_gammamumu.json new file mode 100644 index 0000000..46ebc6d --- /dev/null +++ b/test/jsonFiles/BSTOGLLMNT__Bs_gammamumu.json @@ -0,0 +1,34 @@ +{ + "parent" : "B_s0", + "daughters" : ["gamma", "mu+", "mu-"], + "models" : ["BSTOGLLMNT"], + "parameters" : [["5.0", "5", "1", "1", "0.02", "0.88", "0.227", "0.22", "0.34"]], + "do_conjugate_decay" : [true], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 2000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(gamma mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(gamma mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(gamma mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 30.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "E", "title" : "E(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pz", "title" : "pz(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(gamma,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(gamma,mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BSTOGLLMNT__Bs_gammamumu.root", + "reference" : "RefBSTOGLLMNT__Bs_gammamumu.root" +} diff --git a/test/jsonFiles/BS_MUMUKK__Bs_mumuKK.json b/test/jsonFiles/BS_MUMUKK__Bs_mumuKK.json new file mode 100644 index 0000000..11b963c --- /dev/null +++ b/test/jsonFiles/BS_MUMUKK__Bs_mumuKK.json @@ -0,0 +1,40 @@ +{ + "parent" : "B_s0", + "daughters" : ["mu+", "mu-", "K+", "K-"], + "models" : ["BS_MUMUKK"], + "parameters" : [["0.0", "0.0", "-0.03", "1.0", "0.07", "3.315", "-0.03", "1.0", "0.93", "0.5242", "0.0", "-0.03", "1.0", "0.25", "3.08", "-0.03", "1.0", "3.26", "-0.03", "1.0", "0.0", "0.0", "-0.03", "1.0", "0.0", "0.0", "-0.03", "1.0", "0.0", "-0.03", "1.0", "0.6614", "0.08543", "17.8", "0.9499", "0.988", "1.2"]], + "do_conjugate_decay" : [true], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.3}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 3.0, "xmax" : 3.2}, + {"variable" : "mass", "title" : "m(mu+K+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "mass", "title" : "m(mu- K+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "mass", "title" : "m(K+ K-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.3}, + {"variable" : "pSumSq", "title" : "qSq(mu+mu-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 9.5, "xmax" : 9.7}, + {"variable" : "pSumSq", "title" : "qSq(K+K-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "pz", "title" : "pz(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.5, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(K-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "pz", "title" : "pz(K-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.5, "xmax" : 1.5}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+,K-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu-,K+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,K+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(K-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BS_MUMUKK__Bs_mumuKK.root", + "reference" : "RefBS_MUMUKK__Bs_mumuKK.root" +} diff --git a/test/jsonFiles/BTO3PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipi0_Deanti-nu_e.json b/test/jsonFiles/BTO3PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipi0_Deanti-nu_e.json new file mode 100644 index 0000000..4f6cb9e --- /dev/null +++ b/test/jsonFiles/BTO3PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipi0_Deanti-nu_e.json @@ -0,0 +1,22 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["pi+","pi-","pi0"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "BTO3PI_CP", "ISGW2"], + "parameters" : [[], ["0.51e12", "0.4"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob_daug1", "title" : "Prob(BTO3PI_CP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(#pi^{+} #pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass_daug1", "title" : "m(#pi^{-} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass_daug1", "title" : "m(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "massSq_daug1", "title" : "Dalitz m^{2}(#pi^{+} #pi^{-}) vs m^{2}(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq_daug1", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "massSq_daug1", "title" : "Dalitz m^{2}(#pi^{-} #pi^{0}) vs m^{2}(#pi^{+} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq_daug1", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "mPrime_daug1", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime_daug1", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "lifetime_daug1", "title" : "tau(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 200000.0}, + {"variable" : "lifetime_daug1", "title" : "tau(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 200000.0} + ], + "outfile" :"BTO3PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipi0_Deanti-nu_e.root", + "reference" : "RefBTO3PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipi0_Deanti-nu_e.root" +} diff --git a/test/jsonFiles/BTO4PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipipi_D+enu.json b/test/jsonFiles/BTO4PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipipi_D+enu.json new file mode 100644 index 0000000..6c3c0a1 --- /dev/null +++ b/test/jsonFiles/BTO4PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipipi_D+enu.json @@ -0,0 +1,22 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["pi+","pi-","pi+","pi-"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "BTO4PI_CP", "ISGW2"], + "parameters" : [[], ["0.4", "0.51e12", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob_daug1", "title" : "Prob(BTO4PI_CP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau1", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "lifetime", "title" : "tau2", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "id", "title" : "ID1", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1000.0, "xmax" : 1000.0}, + {"variable" : "id", "title" : "ID2", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1000.0, "xmax" : 1000.0}, + {"variable" : "mass_daug1", "title" : "mass(pi1pi2)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass3_daug1", "title" : "mass(pi1pi2pi3)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "decayangle3_daug1", "title" : "theta(rho+=pi1+pi2,pi3) B0 as parent", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 200.0}, + {"variable" : "decayangle_BTO4PI_daug1", "title" : "theta(pi1,pi2) a2=pi1+pi2+pi3 as parent", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 200.0} + ], + "outfile" :"BTO4PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipipi_D+enu.root", + "reference" : "RefBTO4PI_CP=VSS=ISGW2__Upsilon4S_Bd_pipipipi_D+enu.root" +} diff --git a/test/jsonFiles/BTODDALITZCPK=D0GAMMADALITZ__Bu_D0K,KsKK.json b/test/jsonFiles/BTODDALITZCPK=D0GAMMADALITZ__Bu_D0K,KsKK.json new file mode 100644 index 0000000..3b162a6 --- /dev/null +++ b/test/jsonFiles/BTODDALITZCPK=D0GAMMADALITZ__Bu_D0K,KsKK.json @@ -0,0 +1,26 @@ +{ + "parent" : "B-", + "daughters" : ["D0", "K-"], + "grand_daughters" : [["K_S0", "K+", "K-"], []], + "models" : ["BTODDALITZCPK", "D0GAMMADALITZ", ""], + "parameters" : [["1.15", "2.27", "0.10"], [], []], + "events" : 10000, + "histograms" : [ + {"variable" : "prob_daug1", "title" : "Prob(D0GAMMADALITZ)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B^{0})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "cosTheta", "title" : "cosTheta(D^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(K^{0}_{S} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass_daug1", "title" : "m(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass_daug1", "title" : "m(K^{+} K^{-})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "massSq_daug1", "title" : "Dalitz m^{2}(K^{0}_{S} K^{+}) vs m^{2}(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq_daug1", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "massSq_daug1", "title" : "Dalitz m^{2}(K^{+} K^{-}) vs m^{2}(K^{0}_{S} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq_daug1", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "mPrime_daug1", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime_daug1", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K^{0}_{S},D^{0})", "d1" : 1, "d2" : 0, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BTODDALITZCPK=D0GAMMADALITZ__Bu_D0K,KsKK.root", + "reference" : "RefBTODDALITZCPK=D0GAMMADALITZ__Bu_D0K,KsKK.root" +} diff --git a/test/jsonFiles/BTOKD3P=PTO3P__Bu_KD0D0b,K0spipi.json b/test/jsonFiles/BTOKD3P=PTO3P__Bu_KD0D0b,K0spipi.json new file mode 100644 index 0000000..f18323f --- /dev/null +++ b/test/jsonFiles/BTOKD3P=PTO3P__Bu_KD0D0b,K0spipi.json @@ -0,0 +1,45 @@ +{ + "parent" : "B-", + "daughters" : ["K-", "D0", "anti-D0"], + "grand_daughters" : [[], ["K_S0", "pi+", "pi-"], ["K_S0", "pi+", "pi-"]], + "models" : ["BTOKD3P", "", "PTO3P", "PTO3P"], + "do_conjugate_decay" : [false, false, false], + "parameters" : [["0.10", "3.04"], [], + ["MAXPDF 2.4", + "AMPLITUDE RESONANCE AC K*- ANGULAR BC TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 1.74 139.0", + "AMPLITUDE RESONANCE AC K_0*- ANGULAR BC TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.8 153.0", + "AMPLITUDE RESONANCE AC K_2*- ANGULAR BC TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 1.41 138.4", + "AMPLITUDE RESONANCE AB K*+ ANGULAR CA TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.16 -42.7", + "AMPLITUDE RESONANCE BC rho0 ANGULAR AB TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 1.0 0.0", + "AMPLITUDE RESONANCE BC omega ANGULAR AB TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.053 126.5", + "AMPLITUDE RESONANCE BC f_2 ANGULAR AB TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.61 157.4", + "AMPLITUDE PHASESPACE COEFFICIENT POLAR_DEG 0.3 0.0"], + ["MAXPDF 2.4", + "AMPLITUDE RESONANCE AC K*- ANGULAR BC TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 1.74 139.0", + "AMPLITUDE RESONANCE AC K_0*- ANGULAR BC TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.8 153.0", + "AMPLITUDE RESONANCE AC K_2*- ANGULAR BC TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 1.41 138.4", + "AMPLITUDE RESONANCE AB K*+ ANGULAR CA TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.16 -42.7", + "AMPLITUDE RESONANCE BC rho0 ANGULAR AB TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 1.0 0.0", + "AMPLITUDE RESONANCE BC omega ANGULAR AB TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.053 126.5", + "AMPLITUDE RESONANCE BC f_2 ANGULAR AB TYPE RBW_ZEMACH COEFFICIENT POLAR_DEG 0.61 157.4", + "AMPLITUDE PHASESPACE COEFFICIENT POLAR_DEG 0.3 0.0"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(BTOKD3P)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{-} D^{0})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass_daug2", "title" : "m(K^{0}_{S} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass_daug2", "title" : "m(K^{0}_{S} #pi^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass_daug2", "title" : "m(#pi^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.5}, + {"variable" : "massSq_daug2", "title" : "m^{2}(K^{0}_{S} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "massSq_daug2", "title" : "m^{2}(K^{0}_{S} #pi^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "massSq_daug2", "title" : "m^{2}(#pi^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "massSq_daug2", "title" : "Dalitz m^{2}(K^{0}_{S} #pi^{-}) vs m^{2}(K^{0}_{S} #pi^{+})", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.5, "variableY" : "massSq_daug2", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.5}, + {"variable" : "massSq_daug2", "title" : "Dalitz m^{2}(#pi^{+} #pi^{-}) vs m^{2}(K^{0}_{S} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 2.1, "variableY" : "massSq_daug2", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.5}, + {"variable" : "mPrime_daug2", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime_daug2", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BTOKD3P=PTO3P__Bu_KD0D0b,K0spipi.root", + "reference" : "RefBTOKD3P=PTO3P__Bu_KD0D0b,K0spipi.root" +} diff --git a/test/jsonFiles/BTOKPIPI_CP=VSS=ISGW2__Upsilon4S_Bd_Kpipi0_Deanti-nu_e.json b/test/jsonFiles/BTOKPIPI_CP=VSS=ISGW2__Upsilon4S_Bd_Kpipi0_Deanti-nu_e.json new file mode 100644 index 0000000..2be5927 --- /dev/null +++ b/test/jsonFiles/BTOKPIPI_CP=VSS=ISGW2__Upsilon4S_Bd_Kpipi0_Deanti-nu_e.json @@ -0,0 +1,22 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["K+","pi-","pi0"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "BTOKPIPI_CP", "ISGW2"], + "parameters" : [[], ["0.51e12", "1.5", "0.4"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob_daug1", "title" : "Prob(BTOKPIPI_CP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(K^{+} #pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass_daug1", "title" : "m(#pi^{-} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass_daug1", "title" : "m(K^{+} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "massSq_daug1", "title" : "Dalitz m^{2}(K^{+} #pi^{-}) vs m^{2}(K^{+} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq_daug1", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "massSq_daug1", "title" : "Dalitz m^{2}(#pi^{-} #pi^{0}) vs m^{2}(K^{+} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq_daug1", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "mPrime_daug1", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime_daug1", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "lifetime_daug1", "title" : "tau(K^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 200000.0}, + {"variable" : "lifetime_daug1", "title" : "tau(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 200000.0} + ], + "outfile" :"BTOKPIPI_CP=VSS=ISGW2__Upsilon4S_Bd_Kpipi0_Deanti-nu_e.root", + "reference" : "RefBTOKPIPI_CP=VSS=ISGW2__Upsilon4S_Bd_Kpipi0_Deanti-nu_e.root" +} diff --git a/test/jsonFiles/BTOPLNUBK__Bu_pienu.json b/test/jsonFiles/BTOPLNUBK__Bu_pienu.json new file mode 100644 index 0000000..5133c43 --- /dev/null +++ b/test/jsonFiles/BTOPLNUBK__Bu_pienu.json @@ -0,0 +1,26 @@ +{ + "parent" : "B+", + "daughters" : ["pi0", "e+", "nu_e"], + "models" : ["BTOPLNUBK"], + "parameters" : [["0.54", "1.4"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSumSq", "title" : "q^{2}(e #nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 28.0}, + {"variable" : "mass", "title" : "m(#pi^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.12, "xmax" : 0.15}, + {"variable" : "mass", "title" : "m(#pi^{0} e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.5}, + {"variable" : "mass", "title" : "m(e #nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.5}, + {"variable" : "mass", "title" : "m(#pi^{0} #nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.5}, + {"variable" : "p", "title" : "p(#pi^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#pi^{0},e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(e,#nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#pi^{0},#nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#pi^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BTOPLNUBK__Bu_pienu.root", + "reference" : "RefBTOPLNUBK__Bu_pienu.root" +} diff --git a/test/jsonFiles/BTOSLLALI=VSS__Bs_phimumu,KK.json b/test/jsonFiles/BTOSLLALI=VSS__Bs_phimumu,KK.json new file mode 100644 index 0000000..cd9e92b --- /dev/null +++ b/test/jsonFiles/BTOSLLALI=VSS__Bs_phimumu,KK.json @@ -0,0 +1,32 @@ +{ + "parent" : "B_s0", + "daughters" : ["phi", "mu+", "mu-"], + "grand_daughters" : [["K+", "K-"], [], []], + "models" : ["BTOSLLALI", "VSS", ""], + "parameters" : [[], [], []], + "do_conjugate_decay" : [true, false, false], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(BTOSLLALI)", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(phi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.95, "xmax" : 1.1}, + {"variable" : "mass", "title" : "m(phi mu+)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins": 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "p", "title" : "p(phi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(phi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(phi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,phi)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(phi)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K+)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K+)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K+)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K-)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K-)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K-)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOSLLALI=VSS__Bs_phimu+mu+,KK.root", + "reference" : "RefBTOSLLALI=VSS__Bs_phimu+mu+,KK.root" +} diff --git a/test/jsonFiles/BTOSLLBALL=PHSP__Bd_Ksmumu,pipi.json b/test/jsonFiles/BTOSLLBALL=PHSP__Bd_Ksmumu,pipi.json new file mode 100644 index 0000000..9da26fb --- /dev/null +++ b/test/jsonFiles/BTOSLLBALL=PHSP__Bd_Ksmumu,pipi.json @@ -0,0 +1,37 @@ +{ + "parent" : "B0", + "daughters" : ["K_S0", "mu+", "mu-"], + "grand_daughters" : [["pi+", "pi-"], [], []], + "models" : ["BTOSLLBALL", "PHSP", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(Ks)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 0.6}, + {"variable" : "mass", "title" : "m(Ks mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(Ks mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(Ks)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(Ks)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(Ks)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(Ks,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Ks)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Ks)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOSLLBALL=PHSP__Bd_Ksmumu,pipi.root", + "reference" : "RefBTOSLLBALL=PHSP__Bd_Ksmumu,pipi.root" +} diff --git a/test/jsonFiles/BTOSLLBALL=VSS__Bd_Kst0mumu,KK.json b/test/jsonFiles/BTOSLLBALL=VSS__Bd_Kst0mumu,KK.json new file mode 100644 index 0000000..c6c5785 --- /dev/null +++ b/test/jsonFiles/BTOSLLBALL=VSS__Bd_Kst0mumu,KK.json @@ -0,0 +1,37 @@ +{ + "parent" : "B0", + "daughters" : ["K*0", "mu+", "mu-"], + "grand_daughters" : [["K+", "pi-"], [], []], + "models" : ["BTOSLLBALL", "VSS", ""], + "parameters" : [["6"], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(Kst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(Kst mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(Kst mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(Kst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(Kst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(Kst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(Kst,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Kst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Kst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOSLLBALL=VSS__Bd_Kst0mumu,Kpi.root", + "reference" : "RefBTOSLLBALL=VSS__Bd_Kst0mumu,Kpi.root" +} diff --git a/test/jsonFiles/BTOSLLBALL=VSS__Bs_phimumu,KK.json b/test/jsonFiles/BTOSLLBALL=VSS__Bs_phimumu,KK.json new file mode 100644 index 0000000..123fa24 --- /dev/null +++ b/test/jsonFiles/BTOSLLBALL=VSS__Bs_phimumu,KK.json @@ -0,0 +1,38 @@ +{ + "parent" : "B_s0", + "daughters" : ["phi", "mu+", "mu-"], + "grand_daughters" : [["K+", "K-"], [], []], + "models" : ["BTOSLLBALL", "VSS", ""], + "parameters" : [["6"], [], []], + "do_conjugate_decay" : [true, false, false, false], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.1}, + {"variable" : "mass", "title" : "m(phi mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(phi mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "p", "title" : "p(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(phi,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOSLLBALL=VSS__Bs_phimumu,KK.root", + "reference" : "RefBTOSLLBALL=VSS__Bs_phimumu,KK.root" +} diff --git a/test/jsonFiles/BTOSLLBALL=VSS__Bu_rhomumu,pipi0.json b/test/jsonFiles/BTOSLLBALL=VSS__Bu_rhomumu,pipi0.json new file mode 100644 index 0000000..42d9be0 --- /dev/null +++ b/test/jsonFiles/BTOSLLBALL=VSS__Bu_rhomumu,pipi0.json @@ -0,0 +1,37 @@ +{ + "parent" : "B+", + "daughters" : ["rho+", "mu+", "mu-"], + "grand_daughters" : [["pi+", "pi0"], [], []], + "models" : ["BTOSLLBALL", "VSS", ""], + "parameters" : [["6"], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(rho mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(rho mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(rho,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOSLLBALL=VSS__Bu_rhomumu,pipi0.root", + "reference" : "RefBTOSLLBALL=VSS__Bu_rhomumu,pipi0.root" +} diff --git a/test/jsonFiles/BTOSLLBALL__Bu_Kmumu.json b/test/jsonFiles/BTOSLLBALL__Bu_Kmumu.json new file mode 100644 index 0000000..9b4b3d0 --- /dev/null +++ b/test/jsonFiles/BTOSLLBALL__Bu_Kmumu.json @@ -0,0 +1,33 @@ +{ + "parent" : "B+", + "daughters" : ["K+", "mu+", "mu-"], + "models" : ["BTOSLLBALL"], + "parameters" : [["6"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K+ mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(K+ mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(K+ mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 30.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 30.0}, + {"variable" : "p", "title" : "p(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(K+,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+,mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BTOSLLBALL__Bu_Kmumu.root", + "reference" : "RefBTOSLLBALL__Bu_Kmumu.root" +} diff --git a/test/jsonFiles/BTOSLLBALL__Bu_pimumu.json b/test/jsonFiles/BTOSLLBALL__Bu_pimumu.json new file mode 100644 index 0000000..e32780b --- /dev/null +++ b/test/jsonFiles/BTOSLLBALL__Bu_pimumu.json @@ -0,0 +1,33 @@ +{ + "parent" : "B+", + "daughters" : ["pi+", "mu+", "mu-"], + "models" : ["BTOSLLBALL"], + "parameters" : [["6"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(pi+ mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(pi+ mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(pi+ mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 30.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 30.0}, + {"variable" : "p", "title" : "p(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(pi+,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi+,mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "BTOSLLBALL__Bu_pimumu.root", + "reference" : "RefBTOSLLBALL__Bu_pimumu.root" +} diff --git a/test/jsonFiles/BTOSLLMS=VSS__Bu_rhomumu,pipi0.json b/test/jsonFiles/BTOSLLMS=VSS__Bu_rhomumu,pipi0.json new file mode 100644 index 0000000..9b71f13 --- /dev/null +++ b/test/jsonFiles/BTOSLLMS=VSS__Bu_rhomumu,pipi0.json @@ -0,0 +1,37 @@ +{ + "parent" : "B+", + "daughters" : ["rho+", "mu+", "mu-"], + "grand_daughters" : [["pi+", "pi0"], [], []], + "models" : ["BTOSLLMS", "VSS", ""], + "parameters" : [["5.0", "5", "0", "1", "0.88", "0.227", "0.22", "0.34"], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(rho mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(rho mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(rho,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOSLLMS=VSS__Bu_rhomumu,pipi0.root", + "reference" : "RefBTOSLLMS=VSS__Bu_rhomumu,pipi0.root" +} diff --git a/test/jsonFiles/BTOSLLMSEXT=VVS_PWAVE__Bu_K1mumu,rho0K.json b/test/jsonFiles/BTOSLLMSEXT=VVS_PWAVE__Bu_K1mumu,rho0K.json new file mode 100644 index 0000000..b6a04fb --- /dev/null +++ b/test/jsonFiles/BTOSLLMSEXT=VVS_PWAVE__Bu_K1mumu,rho0K.json @@ -0,0 +1,38 @@ +{ + "parent" : "B+", + "daughters" : ["K_1+", "mu+", "mu-"], + "grand_daughters" : [["rho0", "K+"], [], []], + "models" : ["BTOSLLMSEXT", "VVS_PWAVE", ""], + "parameters" : [["5.0", "5", "0", "1", "0.88", "0.227", "0.22", "0.34", "1.0", "0.0", "-1.0", "0.0"], + ["1.0", "0.0", "0.0", "0.0", "0.0", "0.0"], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(K_1 mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(K_1 mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "p", "title" : "p(K_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(K_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(K_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(K_1,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(rho0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(K_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(rho0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(rho0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(rho0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOSLLMSEXT=VSS__Bu_K1mumu,rho0K.root", + "reference" : "RefBTOSLLMSEXT=VSS__Bu_K1mumu,rho0K.root" +} diff --git a/test/jsonFiles/BTOVLNUBALL__Bd_Kstarenu.json b/test/jsonFiles/BTOVLNUBALL__Bd_Kstarenu.json new file mode 100644 index 0000000..3c2d3ac --- /dev/null +++ b/test/jsonFiles/BTOVLNUBALL__Bd_Kstarenu.json @@ -0,0 +1,26 @@ +{ + "parent" : "B0", + "daughters" : ["K*+", "e-", "anti-nu_e"], + "models" : ["BTOVLNUBALL"], + "parameters" : [["0.290", "40.38", "-0.084", "0.342", "52.0", "0.923", "-0.511", "49.40"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{*+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(K^{*+} e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 5.5}, + {"variable" : "mass", "title" : "m(e #nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(K^{*+} #nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 5.5}, + {"variable" : "pSumSq", "title" : "q^{2}(e #nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 21.0}, + {"variable" : "p", "title" : "p(K^{*+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(K^{*+},e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(e,#nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K^{*+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BTOVLNUBALL__Bd_Kstarenu.root", + "reference" : "RefBTOVLNUBALL__Bd_Kstarenu.root" +} diff --git a/test/jsonFiles/BTOXELNU=VSS__Bu_rho0munu,pipi.json b/test/jsonFiles/BTOXELNU=VSS__Bu_rho0munu,pipi.json new file mode 100644 index 0000000..c232402 --- /dev/null +++ b/test/jsonFiles/BTOXELNU=VSS__Bu_rho0munu,pipi.json @@ -0,0 +1,38 @@ +{ + "parent" : "B+", + "daughters" : ["rho0", "mu+", "nu_mu"], + "grand_daughters" : [["pi+", "pi-"], [], []], + "models" : ["BTOXELNU", "VSS", ""], + "parameters" : [["BCL", "-0.861", "1.444", "0.266", "0.378", "0.165", "0.291", + "0.718", "0.384", "0.331", "-0.876", "1.907"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(BTOXELNU)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#rho^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.2, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(#rho^{0} #mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#rho^{0} #nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#mu #nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#mu #nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(#rho^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(#rho^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#pi^{+},#rho^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#rho^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#rho^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "p_daug1", "title" : "p(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug1", "title" : "phi(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "BTOXELNU=VSS__Bu_rho0munu,pipi.root", + "reference" : "RefBTOXELNU=VSS__Bu_rho0munu,pipi.root" +} diff --git a/test/jsonFiles/BTOXSETAP=SVP_HELAMP__Bu_Xsuetap,rho0gamma.json b/test/jsonFiles/BTOXSETAP=SVP_HELAMP__Bu_Xsuetap,rho0gamma.json new file mode 100644 index 0000000..8cf4d66 --- /dev/null +++ b/test/jsonFiles/BTOXSETAP=SVP_HELAMP__Bu_Xsuetap,rho0gamma.json @@ -0,0 +1,31 @@ +{ + "parent" : "B+", + "daughters" : ["Xsu", "eta'"], + "grand_daughters" : [[], ["rho0", "gamma"], []], + "models" : ["BTOXSETAP", "", "SVP_HELAMP"], + "parameters" : [[], [], ["1.0", "0.0", "1.0", "0.0"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(Xsu)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(eta')", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.8, "xmax" : 1.1}, + {"variable" : "p", "title" : "p(Xsu)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(Xsu)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(Xsu)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(rho0)", "d1" : 1, "d2" : 2, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(gamma)", "d1" : 2, "d2" : 1, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Xsu)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(Xsu)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug2", "title" : "pLab(rho0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(rho0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(rho0)", "d1" : 1, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "E_daug2", "title" : "E(gamma)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(gamma)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(gamma)", "d1" : 2, "d2" : 0, "nbins": 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" :"BTOXSETAP=SVP_HELAMP__Bu_Xsuetap,rho0gamma.root", + "reference" : "RefBTOXSETAP=SVP_HELAMP__Bu_Xsuetap,rho0gamma.root" +} diff --git a/test/jsonFiles/BTOXSGAMMA__Bd_Xsdgamma.json b/test/jsonFiles/BTOXSGAMMA__Bd_Xsdgamma.json new file mode 100644 index 0000000..da410fc --- /dev/null +++ b/test/jsonFiles/BTOXSGAMMA__Bd_Xsdgamma.json @@ -0,0 +1,21 @@ +{ + "parent" : "B0", + "daughters" : ["Xsd", "gamma"], + "models" : ["BTOXSGAMMA", "", ""], + "parameters" : [["1"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.25, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(Xsd)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "p", "title" : "p(Xsd)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "phi", "title" : "phi(Xsd)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Xsd)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "phi", "title" : "phi(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BTOXSGAMMA__Bd_Xsdgamma.root", + "reference" : "RefBTOXSGAMMA__Bd_Xsdgamma.root" +} diff --git a/test/jsonFiles/BTOXSLL__Bu_Xsumumu.json b/test/jsonFiles/BTOXSLL__Bu_Xsumumu.json new file mode 100644 index 0000000..4398df3 --- /dev/null +++ b/test/jsonFiles/BTOXSLL__Bu_Xsumumu.json @@ -0,0 +1,35 @@ +{ + "parent" : "B+", + "daughters" : ["Xsu", "mu+", "mu-"], + "grand_daughters" : [[], [], []], + "models" : ["BTOXSLL", "", ""], + "parameters" : [["4.8", "0.2", "0.0", "0.41"], + [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(Xsu mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(Xsu mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(Xsu mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 30.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "p", "title" : "p(Xsu)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(Xsu)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(Xsu,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(Xsu,mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Xsu)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Xsu)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" :"BTOXSLL__Bu_Xsumumu.root", + "reference" : "RefBTOXSLL__Bu_Xsumumu.root" +} diff --git a/test/jsonFiles/BToDiBaryonlnupQCD__Bu_Deltapmunu.json b/test/jsonFiles/BToDiBaryonlnupQCD__Bu_Deltapmunu.json new file mode 100644 index 0000000..11f7d10 --- /dev/null +++ b/test/jsonFiles/BToDiBaryonlnupQCD__Bu_Deltapmunu.json @@ -0,0 +1,17 @@ +{ + "parent" : "B-", + "daughters" : ["Delta+", "anti-p-", "mu-", "anti-nu_mu"], + "models" : ["BToDiBaryonlnupQCD"], + "parameters" : [["67.7", "-280.0", "-187.3", "-840.1", "-10.1", "-157.0", "7.0e6"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mPP", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.5}, + {"variable" : "mass", "title" : "mMuNu", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "pSumSq", "title" : "qSqMuNu", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel", "title" : "cosThetaB", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosThetaL", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BToDiBaryonlnupQCD__Bu_Deltapmunu.root", + "reference" : "RefBToDiBaryonlnupQCD__Bu_Deltapmunu.root" +} diff --git a/test/jsonFiles/BToDiBaryonlnupQCD__Bu_ppmunu.json b/test/jsonFiles/BToDiBaryonlnupQCD__Bu_ppmunu.json new file mode 100644 index 0000000..60608bf --- /dev/null +++ b/test/jsonFiles/BToDiBaryonlnupQCD__Bu_ppmunu.json @@ -0,0 +1,17 @@ +{ + "parent" : "B-", + "daughters" : ["p+", "anti-p-", "mu-", "anti-nu_mu"], + "models" : ["BToDiBaryonlnupQCD"], + "parameters" : [["67.7", "-280.0", "-187.3", "-840.1", "-10.1", "-157.0", "3.0e6"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mPP", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.5}, + {"variable" : "mass", "title" : "mMuNu", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "pSumSq", "title" : "qSqMuNu", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel", "title" : "cosThetaB", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosThetaL", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BToDiBaryonlnupQCD__Bu_ppmunu.root", + "reference" : "RefBToDiBaryonlnupQCD__Bu_ppmunu.root" +} diff --git a/test/jsonFiles/B_TO_2BARYON_SCALAR__Bu_Lambda0pbarpi0.json b/test/jsonFiles/B_TO_2BARYON_SCALAR__Bu_Lambda0pbarpi0.json new file mode 100644 index 0000000..4e88412 --- /dev/null +++ b/test/jsonFiles/B_TO_2BARYON_SCALAR__Bu_Lambda0pbarpi0.json @@ -0,0 +1,19 @@ +{ + "parent" : "B-", + "daughters" : ["Lambda0", "anti-p-", "pi0"], + "models" : ["B_TO_2BARYON_SCALAR"], + "parameters" : [[]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{#Lambda}#bar{#it{p}})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 5.5}, + {"variable" : "mass", "title" : "M(#bar{#it{p}}#it{#pi}^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 1.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "M(#it{#Lambda}#it{#pi}^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.0, "xmax" : 5.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{#Lambda},#bar{#it{p}})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#bar{#it{p}},#it{#pi}^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{#Lambda},#it{#pi}^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "B_TO_2BARYON_SCALAR__Bu_Lambda0pbarpi0.root", + "reference" : "RefB_TO_2BARYON_SCALAR__Bu_Lambda0pbarpi0.root" +} diff --git a/test/jsonFiles/B_TO_LAMBDA_PBAR_GAMMA__Bu_Lambda0pbargamma.json b/test/jsonFiles/B_TO_LAMBDA_PBAR_GAMMA__Bu_Lambda0pbargamma.json new file mode 100644 index 0000000..d843e20 --- /dev/null +++ b/test/jsonFiles/B_TO_LAMBDA_PBAR_GAMMA__Bu_Lambda0pbargamma.json @@ -0,0 +1,20 @@ +{ + "parent" : "B-", + "daughters" : ["Lambda0", "anti-p-", "gamma"], + "models" : ["B_TO_LAMBDA_PBAR_GAMMA"], + "parameters" : [[]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSumSq", "title" : "qSq(pbar,gamma)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "mass", "title" : "m(Lambda,pbar)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 5.5}, + {"variable" : "mass", "title" : "m(pbar,gamma)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 1.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(Lambda,gamma)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.0, "xmax" : 5.0}, + {"variable" : "cosHel", "title" : "cosHel(Lambda0,pbar)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pbar,gamma)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(Lambda0,gamma)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "B_TO_LAMBDA_PBAR_GAMMA__BuLambdapbargamma.root", + "reference" : "RefB_TO_LAMBDA_PBAR_GAMMA__BuLambdapbargamma.root" +} diff --git a/test/jsonFiles/BaryonPCR=PHSP__Lambdab0_Lambdacmunu,Lambda0pi.json b/test/jsonFiles/BaryonPCR=PHSP__Lambdab0_Lambdacmunu,Lambda0pi.json new file mode 100644 index 0000000..e769082 --- /dev/null +++ b/test/jsonFiles/BaryonPCR=PHSP__Lambdab0_Lambdacmunu,Lambda0pi.json @@ -0,0 +1,20 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["Lambda_c+", "mu-", "anti-nu_mu"], + "grand_daughters" : [["Lambda0", "pi+"], [], []], + "models" : ["BaryonPCR", "PHSP", ""], + "parameters" : [["1", "1", "1", "1"], [], []], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(BaryonPCR)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(#Lambda^{0}_{b})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.5, "xmax" : 5.7}, + {"variable" : "mass", "title" : "m(#Lambda^{+}_{c})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 2.5}, + {"variable" : "mass", "title" : "m(#Lambda^{+}_{c},#mu^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 2.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#mu^{-},anti-#nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "mass", "title" : "m(#Lambda^{+}_{c},anti-#nu_{#mu})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 2.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(#mu^{-},anti-#nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel", "title" : "cosHel(#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "BaryonPCR=PHSP__Lambdab0_Lambdacmunu,Lambda0pi.root", + "reference" : "RefBaryonPCR=PHSP__Lambdab0_Lambdacmunu,Lambda0pi.root" +} diff --git a/test/jsonFiles/CB3PI-MPP__Bu_3pi.json b/test/jsonFiles/CB3PI-MPP__Bu_3pi.json new file mode 100644 index 0000000..1cfd937 --- /dev/null +++ b/test/jsonFiles/CB3PI-MPP__Bu_3pi.json @@ -0,0 +1,17 @@ +{ + "parent" : "B+", + "daughters" : ["pi+","pi+","pi-"], + "models" : ["CB3PI-MPP"], + "parameters" : [["1.5"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{-})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{-}) vs m^{2}(#pi^{+} #pi^{-})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + ], + "outfile" :"CB3PI-MPP__Bu_3pi.root", + "reference" : "RefCB3PI-MPP__Bu_3pi.root" +} diff --git a/test/jsonFiles/CB3PI-P00__Bu_pi2pi0.json b/test/jsonFiles/CB3PI-P00__Bu_pi2pi0.json new file mode 100644 index 0000000..d52e242 --- /dev/null +++ b/test/jsonFiles/CB3PI-P00__Bu_pi2pi0.json @@ -0,0 +1,17 @@ +{ + "parent" : "B+", + "daughters" : ["pi+","pi0","pi0"], + "models" : ["CB3PI-P00"], + "parameters" : [["1.5"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#pi^{0} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{0}) vs m^{2}(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + ], + "outfile" :"CB3PI-P00__Bu_pi2pi0.root", + "reference" : "RefCB3PI-P00__Bu_pi2pi0.root" +} diff --git a/test/jsonFiles/D0MIXDALITZ__D0_KsKK.json b/test/jsonFiles/D0MIXDALITZ__D0_KsKK.json new file mode 100644 index 0000000..62a0baf --- /dev/null +++ b/test/jsonFiles/D0MIXDALITZ__D0_KsKK.json @@ -0,0 +1,21 @@ +{ + "parent" : "D0", + "daughters" : ["K_S0", "K+", "K-"], + "models" : ["D0MIXDALITZ"], + "parameters" : [["0.01", "0.01", "1.0", "0.0"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass", "title" : "m(K^{+} K^{-})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{0}_{S} K^{+}) vs m^{2}(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} K^{-}) vs m^{2}(K^{0}_{S} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D0MIXDALITZ__D0_KsKK.root", + "reference" : "RefD_DALITZ__D0_KsKK.root" +} diff --git a/test/jsonFiles/DMIX=VSS__psi3770_D0antiD0,Kpi.json b/test/jsonFiles/DMIX=VSS__psi3770_D0antiD0,Kpi.json new file mode 100644 index 0000000..028c52b --- /dev/null +++ b/test/jsonFiles/DMIX=VSS__psi3770_D0antiD0,Kpi.json @@ -0,0 +1,30 @@ +{ + "parent" : "psi(3770)", + "daughters" : ["D0", "anti-D0"], + "grand_daughters" : [["K+", "pi-"], ["K-", "pi+"]], + "models" : ["VSS", "DMIX", "DMIX"], + "parameters" : [[], ["3.4e-3", "0.1e-3", "1.0e-3"], ["3.4e-3", "0.1e-3", "1.0e-3"]], + "extras" : ["noPhotos"], + "events" : 20000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(DMIX)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.1}, + {"variable" : "prob_daug2", "title" : "Prob(DMIX)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.1}, + {"variable" : "parMass", "title" : "m(#psi(3770))", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 3.7, "xmax" : 4.0}, + {"variable" : "mass", "title" : "m(D^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "mass", "title" : "m(anti-D^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "cosHel", "title" : "cosHel(K^{+},D^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K^{-},anti-D^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "DecayAngle(K^{+},#pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "decayangle_daug2", "title" : "DecayAngle(K^{-},#pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "lifetime", "title" : "#tau(D^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "lifetime", "title" : "#tau(anti-D^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "deltaT", "title" : "#Delta #tau", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -4.0, "xmax" : 4.0}, + {"variable" : "pLab_daug1", "title" : "p(K^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "pLab_daug1", "title" : "p(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "pLab_daug2", "title" : "p(K^{-})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "pLab_daug2", "title" : "p(#pi^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5} + ], + "outfile" : "DMIX=VSS__psi3770_D0antiD0,Kpi.root", + "reference" : "RefDMIX=VSS__psi3770_D0antiD0,Kpi.root" +} diff --git a/test/jsonFiles/DToKpienu__D+_Kpimunu.json b/test/jsonFiles/DToKpienu__D+_Kpimunu.json new file mode 100644 index 0000000..82b1d0c --- /dev/null +++ b/test/jsonFiles/DToKpienu__D+_Kpimunu.json @@ -0,0 +1,39 @@ +{ + "parent" : "D+", + "daughters" : ["K-", "pi+", "mu+", "nu_mu"], + "models" : ["DToKpienu"], + "parameters" : [[]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K pi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K mu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(pi mu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(mu mu)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "pSumSq", "title" : "qSq(K pi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSumSq", "title" : "qSq(mu mu)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "p", "title" : "p(K)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pz", "title" : "pz(K)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pz", "title" : "pz(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pz", "title" : "pz(mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(nu)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pz", "title" : "pz(nu)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K,pi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu,nu)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi,mu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K,mu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(nu)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(K)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(mu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(nu)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "DToKpiemu__D+_Kpimunu.root", + "reference" : "RefDToKpiemu__D+_Kpimunu.root" +} diff --git a/test/jsonFiles/D_DALITZ__D+_K+pipi.json b/test/jsonFiles/D_DALITZ__D+_K+pipi.json new file mode 100644 index 0000000..656e846 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D+_K+pipi.json @@ -0,0 +1,22 @@ +{ + "parent" : "D+", + "daughters" : ["K+", "pi-", "pi+"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{+} #pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(K^{+} #pi^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} #pi^{-}) vs m^{2}(K^{+} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.05, "xmax" : 3.5, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{+}) vs m^{2}(K^{+} #pi^{-})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.05, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.05, "ymax" : 3.5}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D+_K+pipi.root", + "reference" : "RefD_DALITZ__D+_K+pipi.root" +} diff --git a/test/jsonFiles/D_DALITZ__D+_K0pipi0.json b/test/jsonFiles/D_DALITZ__D+_K0pipi0.json new file mode 100644 index 0000000..78157a8 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D+_K0pipi0.json @@ -0,0 +1,22 @@ +{ + "parent" : "D+", + "daughters" : ["K0", "pi+", "pi0"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{0} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(K^{0} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{0} #pi^{+}) vs m^{2}(K^{0} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.3, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.3, "ymax" : 3.2}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{0}) vs m^{2}(K^{0} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.3, "ymax" : 3.2}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D+_K0pipi0.root", + "reference" : "RefD_DALITZ__D+_K0pipi0.root" +} diff --git a/test/jsonFiles/D_DALITZ__D+_KKpi+.json b/test/jsonFiles/D_DALITZ__D+_KKpi+.json new file mode 100644 index 0000000..ce272ec --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D+_KKpi+.json @@ -0,0 +1,22 @@ +{ + "parent" : "D+", + "daughters" : ["K-", "K+", "pi+"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{-} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(K^{-} #pi^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K^{+} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{-} K^{+}) vs m^{2}(K^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.3, "ymax" : 2.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} #pi^{+}) vs m^{2}(K^{-} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.3, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.7, "ymax" : 3.2}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D+_KKpi+.root", + "reference" : "RefD_DALITZ__D+_KKpi+.root" +} diff --git a/test/jsonFiles/D_DALITZ__D+_Kpipi+.json b/test/jsonFiles/D_DALITZ__D+_Kpipi+.json new file mode 100644 index 0000000..e56c302 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D+_Kpipi+.json @@ -0,0 +1,22 @@ +{ + "parent" : "D+", + "daughters" : ["K-", "pi+", "pi+"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(K^{-} #pi^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{-} #pi^{+}) vs m^{2}(K^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.3, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.3, "ymax" : 3.2}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{+}) vs m^{2}(K^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.3, "ymax" : 3.2}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D+_Kpipi+.root", + "reference" : "RefD_DALITZ__D+_Kpipi+.root" +} diff --git a/test/jsonFiles/D_DALITZ__D+_pipipi+.json b/test/jsonFiles/D_DALITZ__D+_pipipi+.json new file mode 100644 index 0000000..04a355e --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D+_pipipi+.json @@ -0,0 +1,22 @@ +{ + "parent" : "D+", + "daughters" : ["pi-", "pi+", "pi+"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{+}) vs m^{2}(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.2}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{+}) vs m^{2}(#pi^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.2}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D+_pipipi+.root", + "reference" : "RefD_DALITZ__D+_pipipi+.root" +} diff --git a/test/jsonFiles/D_DALITZ__D0_KKK_S0.json b/test/jsonFiles/D_DALITZ__D0_KKK_S0.json new file mode 100644 index 0000000..70512f0 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D0_KKK_S0.json @@ -0,0 +1,22 @@ +{ + "parent" : "D0", + "daughters" : ["K-", "K+", "K_S0"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{-} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass", "title" : "m(K^{-} K^{0}_{S})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass", "title" : "m(K^{+} K^{0}_{S})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{-} K^{+}) vs m^{2}(K^{-} K^{0}_{S})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} K^{0}_{S}) vs m^{2}(K^{-} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D0_KKK_S0.root", + "reference" : "RefD_DALITZ__D0_KKK_S0.root" +} diff --git a/test/jsonFiles/D_DALITZ__D0_KKanti-K0.json b/test/jsonFiles/D_DALITZ__D0_KKanti-K0.json new file mode 100644 index 0000000..a2f44f4 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D0_KKanti-K0.json @@ -0,0 +1,22 @@ +{ + "parent" : "D0", + "daughters" : ["K-", "K+", "anti-K0"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{-} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass", "title" : "m(K^{-} anti-K^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "mass", "title" : "m(K^{+} anti-K^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.4}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{-} K^{+}) vs m^{2}(K^{-} anti-K^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} anti-K^{0}) vs m^{2}(K^{-} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D0_KKanti-K0.root", + "reference" : "RefD_DALITZ__D0_KKanti-K0.root" +} diff --git a/test/jsonFiles/D_DALITZ__D0_Kpipi0.json b/test/jsonFiles/D_DALITZ__D0_Kpipi0.json new file mode 100644 index 0000000..1713726 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D0_Kpipi0.json @@ -0,0 +1,22 @@ +{ + "parent" : "D0", + "daughters" : ["K-", "pi+", "pi0"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(K^{-} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{-} #pi^{+}) vs m^{2}(K^{-} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.3, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.3, "ymax" : 3.2}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{0}) vs m^{2}(K^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.2}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D0_Kpipi0.root", + "reference" : "RefD_DALITZ__D0_Kpipi0.root" +} diff --git a/test/jsonFiles/D_DALITZ__D0_anti-K0pipi.json b/test/jsonFiles/D_DALITZ__D0_anti-K0pipi.json new file mode 100644 index 0000000..d9172c4 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D0_anti-K0pipi.json @@ -0,0 +1,22 @@ +{ + "parent" : "D0", + "daughters" : ["anti-K0", "pi+", "pi-"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(anti-K^{0} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(anti-K^{0} #pi^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{-})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(anti-K^{0} #pi^{+}) vs m^{2}(anti-K^{0} #pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.05, "xmax" : 3.5, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{-}) vs m^{2}(anti-K^{0} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.05, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.05, "ymax" : 3.5}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D0_anti-K0pipi.root", + "reference" : "RefD_DALITZ__D0_anti-K0pipi.root" +} diff --git a/test/jsonFiles/D_DALITZ__D0_pipiK_S0.json b/test/jsonFiles/D_DALITZ__D0_pipiK_S0.json new file mode 100644 index 0000000..56aff45 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D0_pipiK_S0.json @@ -0,0 +1,22 @@ +{ + "parent" : "D0", + "daughters" : ["pi-", "pi+", "K_S0"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(#pi^{-} K^{0}_{S})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{+} K^{0}_{S})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.8}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{+}) vs m^{2}(#pi^{-} K^{0}_{S})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.2}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} K^{0}_{S}) vs m^{2}(#pi^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.3, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 2.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D0_pipiK_S0.root", + "reference" : "RefD_DALITZ__D0_pipiK_S0.root" +} diff --git a/test/jsonFiles/D_DALITZ__D0_pipipi0.json b/test/jsonFiles/D_DALITZ__D0_pipipi0.json new file mode 100644 index 0000000..4ec1c90 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__D0_pipipi0.json @@ -0,0 +1,22 @@ +{ + "parent" : "D0", + "daughters" : ["pi-", "pi+", "pi0"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{+}) vs m^{2}(#pi^{-} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.2}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{0}) vs m^{2}(#pi^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.2, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.2}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__D0_pipipi0.root", + "reference" : "RefD_DALITZ__D0_pipipi0.root" +} diff --git a/test/jsonFiles/D_DALITZ__Ds+_KKpi.json b/test/jsonFiles/D_DALITZ__Ds+_KKpi.json new file mode 100644 index 0000000..ca93b4c --- /dev/null +++ b/test/jsonFiles/D_DALITZ__Ds+_KKpi.json @@ -0,0 +1,22 @@ +{ + "parent" : "D_s+", + "daughters" : ["K-", "K+", "pi+"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{-} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.9}, + {"variable" : "mass", "title" : "m(K^{-} #pi^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.6}, + {"variable" : "mass", "title" : "m(K^{+} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.6}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{-} K^{+}) vs m^{2}(K^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 3.5, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.2, "ymax" : 2.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} #pi^{+}) vs m^{2}(K^{-} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.2, "xmax" : 2.5, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.7, "ymax" : 3.5}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__Ds+_KKpi.root", + "reference" : "RefD_DALITZ__Ds+_KKpi.root" +} diff --git a/test/jsonFiles/D_DALITZ__Ds+_pipipi.json b/test/jsonFiles/D_DALITZ__Ds+_pipipi.json new file mode 100644 index 0000000..f0cf311 --- /dev/null +++ b/test/jsonFiles/D_DALITZ__Ds+_pipipi.json @@ -0,0 +1,22 @@ +{ + "parent" : "D_s+", + "daughters" : ["pi-", "pi+", "pi+"], + "models" : ["D_DALITZ"], + "parameters" : [[]], + "do_conjugate_decay" : [true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.9}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.9}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.9}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{+}) vs m^{2}(#pi^{-} #pi^{+})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.5, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{+}) vs m^{2}(#pi^{-} #pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.5, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 3.5}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_DALITZ__Ds+_pipipi.root", + "reference" : "RefD_DALITZ__Ds+_pipipi.root" +} diff --git a/test/jsonFiles/D_MULTIBODY__D0_K0sKK.json b/test/jsonFiles/D_MULTIBODY__D0_K0sKK.json new file mode 100644 index 0000000..aefc26f --- /dev/null +++ b/test/jsonFiles/D_MULTIBODY__D0_K0sKK.json @@ -0,0 +1,24 @@ +{ + "parent" : "D0", + "daughters" : ["K_S0", "K-", "K+"], + "models" : ["D_MULTIBODY"], + "parameters" : [["RESONANCE", "a_00(BREITWIGNER,HELAMP,[1.0,0.0],[K+,K-])", + "RESONANCE", "a_0+(BREITWIGNER,HELAMP,[0.460,3.59],[K_S0,K+])", + "RESONANCE", "f'_0(BREITWIGNER,HELAMP,[0.435,-2.65],[K+,K-])"]], + "do_conjugate_decay" : [false], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K^{-} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{0}_{S} K^{+}) vs m^{2}(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} K^{-}) vs m^{2}(K^{0}_{S} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "D_MULTIBODY__D0_K0sKK.root", + "reference" : "RefD_MULTIBODY__D0_K0sKK.root" +} diff --git a/test/jsonFiles/ETA_DALITZ__eta_pipipi0.json b/test/jsonFiles/ETA_DALITZ__eta_pipipi0.json new file mode 100644 index 0000000..37de921 --- /dev/null +++ b/test/jsonFiles/ETA_DALITZ__eta_pipipi0.json @@ -0,0 +1,21 @@ +{ + "parent" : "eta", + "daughters" : ["pi+", "pi-", "pi0"], + "models" : ["ETA_DALITZ"], + "parameters" : [[]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.45}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.45}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.45}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{-}) vs m^{2}(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.06, "xmax" : 0.18, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.06, "ymax" : 0.18}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{0}) vs m^{2}(#pi^{+} #pi^{-})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.06, "xmax" : 0.18, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.06, "ymax" : 0.18}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "ETA_DALITZ__eta_pipipi0.root", + "reference" : "RefETA_DALITZ__eta_pipipi0.root" +} diff --git a/test/jsonFiles/ETA_LLPIPI__etap_eepipi.json b/test/jsonFiles/ETA_LLPIPI__etap_eepipi.json new file mode 100644 index 0000000..8c0fe5f --- /dev/null +++ b/test/jsonFiles/ETA_LLPIPI__etap_eepipi.json @@ -0,0 +1,18 @@ +{ + "parent" : "eta'", + "daughters" : ["e+", "e-", "pi+", "pi-"], + "models" : ["ETA_LLPIPI"], + "parameters" : [[]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mPiPi", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mLL" , "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.5}, + {"variable" : "mass", "title" : "mPiL1", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.85}, + {"variable" : "mass", "title" : "mPiL2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.85}, + {"variable" : "cosHel", "title" : "cosL", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosPi", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "ETA_LLPIPI__etap_eepipi.root", + "reference" : "RefETA_LLPIPI__etap_eepipi.root" +} diff --git a/test/jsonFiles/ETA_LLPIPI__etap_mumupipi.json b/test/jsonFiles/ETA_LLPIPI__etap_mumupipi.json new file mode 100644 index 0000000..07b6272 --- /dev/null +++ b/test/jsonFiles/ETA_LLPIPI__etap_mumupipi.json @@ -0,0 +1,18 @@ +{ + "parent" : "eta'", + "daughters" : ["mu+", "mu-", "pi+", "pi-"], + "models" : ["ETA_LLPIPI"], + "parameters" : [[]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mPiPi", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mLL" , "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 0.75}, + {"variable" : "mass", "title" : "mPiL1", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 0.1, "xmax" : 0.8}, + {"variable" : "mass", "title" : "mPiL2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.1, "xmax" : 0.8}, + {"variable" : "cosHel", "title" : "cosL", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosPi", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "ETA_LLPIPI__etap_mumupipi.root", + "reference" : "RefETA_LLPIPI__etap_mumupipi.root" +} diff --git a/test/jsonFiles/EvtBcToNPi=VLL__Bc_Jpsi3pi,ee.json b/test/jsonFiles/EvtBcToNPi=VLL__Bc_Jpsi3pi,ee.json new file mode 100644 index 0000000..94e3be4 --- /dev/null +++ b/test/jsonFiles/EvtBcToNPi=VLL__Bc_Jpsi3pi,ee.json @@ -0,0 +1,20 @@ +{ + "parent" : "B_c+", + "daughters" : ["J/psi", "pi+", "pi-", "pi+"], + "grand_daughters" : [["e+", "e-"], [], [], []], + "models" : ["EvtBcToNPi", "VLL", "", "", ""], + "parameters" : [["0.9e5", "5.9", "0.049", "0.0015", "0.0", "0.0", "0.0", "-0.074", "0.049", "0.0015"], [], [], [], []], + "do_conjugate_decay" : [true, false, false, false, false], + "extras" : ["Define dm_incohMix_B_s0 0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(EvtBcToNPi)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VLL)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B_{c}^{+})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 6.2, "xmax" : 6.3}, + {"variable" : "mass", "title" : "m(J/#psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.0, "xmax" : 3.2}, + {"variable" : "mass3", "title" : "m(#pi^{+}#pi^{-}#pi^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.5}, + {"variable" : "cosHel", "title" : "cosHel(e^{+}, J/#psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "EvtBcToNPi=VLL__Bc_Jpsi3pi,ee.root", + "reference" : "RefEvtBcToNPi=VLL__Bc_Jpsi3pi,ee.root" +} diff --git a/test/jsonFiles/FLATQ2=VSS__Bs_phimumu,KK.json b/test/jsonFiles/FLATQ2=VSS__Bs_phimumu,KK.json new file mode 100644 index 0000000..311117b --- /dev/null +++ b/test/jsonFiles/FLATQ2=VSS__Bs_phimumu,KK.json @@ -0,0 +1,38 @@ +{ + "parent" : "B_s0", + "daughters" : ["phi", "mu+", "mu-"], + "grand_daughters" : [["K+", "K-"], [], []], + "models" : ["FLATQ2", "VSS", ""], + "parameters" : [["1"], [], []], + "do_conjugate_decay" : [true, false, false, false], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.1}, + {"variable" : "mass", "title" : "m(phi mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(phi mu-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu+mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(mu+ mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "p", "title" : "p(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 8.0}, + {"variable" : "pz", "title" : "pz(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(phi,mu+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu+,mu-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "FLATQ2=VSS__Bs_phimumu,KK.root", + "reference" : "RefFLATQ2=VSS__Bs_phimumu,KK.root" +} diff --git a/test/jsonFiles/FLATSQDALITZ__Lb_LzKK.json b/test/jsonFiles/FLATSQDALITZ__Lb_LzKK.json new file mode 100644 index 0000000..1a9771c --- /dev/null +++ b/test/jsonFiles/FLATSQDALITZ__Lb_LzKK.json @@ -0,0 +1,20 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["K+", "K-", "Lambda0"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["FLATSQDALITZ"], + "parameters" : [[]], + "extras" : ["noPhotos"], + "events" : 1000000, + "histograms" : [ + {"variable" : "mass", "title" : "mKPi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.6, "xmax" : 2.25}, + {"variable" : "mass", "title" : "mJpsiPi", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 3.2, "xmax" : 4.8}, + {"variable" : "mass", "title" : "mJpsiK", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 3.5, "xmax" : 5.2}, + {"variable" : "cosHel", "title" : "cosTheta1", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta2", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta3", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + ], + "outfile" : "FLATSQDALITZ__Lb_LzKK.root", + "reference" : "RefFLATSQDALITZ__Lb_LzKK.root" +} diff --git a/test/jsonFiles/FLATSQDALITZ__Lb_LzKK_cuts.json b/test/jsonFiles/FLATSQDALITZ__Lb_LzKK_cuts.json new file mode 100644 index 0000000..ce8fd6e --- /dev/null +++ b/test/jsonFiles/FLATSQDALITZ__Lb_LzKK_cuts.json @@ -0,0 +1,20 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["K+", "K-", "Lambda0"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["FLATSQDALITZ"], + "parameters" : [["0.2", "0.7", "0.3", "0.8"]], + "extras" : ["noPhotos"], + "events" : 1000000, + "histograms" : [ + {"variable" : "mass", "title" : "mKPi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.6, "xmax" : 2.25}, + {"variable" : "mass", "title" : "mJpsiPi", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 3.2, "xmax" : 4.8}, + {"variable" : "mass", "title" : "mJpsiK", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 3.5, "xmax" : 5.2}, + {"variable" : "cosHel", "title" : "cosTheta1", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta2", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta3", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 20, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 20, "ymin" : 0.0, "ymax" : 1.0} + ], + "outfile" : "FLATSQDALITZ__Lb_LzKK_cuts.root", + "reference" : "RefFLATSQDALITZ__Lb_LzKK_cuts.root" +} diff --git a/test/jsonFiles/FOURBODYPHSP__Bu_mumuKrho0.json b/test/jsonFiles/FOURBODYPHSP__Bu_mumuKrho0.json new file mode 100644 index 0000000..c5fb107 --- /dev/null +++ b/test/jsonFiles/FOURBODYPHSP__Bu_mumuKrho0.json @@ -0,0 +1,49 @@ +{ + "parent" : "B+", + "daughters" : ["mu+", "mu-", "K+", "rho0"], + "do_conjugate_decay" : [true,false,false,true,false], + "models" : ["FOURBODYPHSP"], + "parameters" : [["1.0", "2.0", "1.0", "2.0"]], + "events" : 10000, + "histograms" : [ + {"variable" : "parMass", "title" : "M(B+)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.0, "xmax" : 5.5}, + {"variable" : "px", "title" : "px(B+)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "py", "title" : "py(B+)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(B+)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "E", "title" : "E(B+)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "M(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.2}, + {"variable" : "px", "title" : "px(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "py", "title" : "py(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu+", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "E", "title" : "E(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "M(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.2}, + {"variable" : "px", "title" : "px(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "py", "title" : "py(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "E", "title" : "E(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "M(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "px", "title" : "px(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "py", "title" : "py(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "E", "title" : "E(K+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "M(rho0)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.5}, + {"variable" : "px", "title" : "px(rho0)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "py", "title" : "py(rho0)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(rho0)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "E", "title" : "E(rho0)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m1m2(mu+ + mu-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m1m3(mu+ + K+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m1m4(mu+ + rho0)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m2m3(mu- + K+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m2m4(mu- + rho0)", "d1" : 2, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m3m4(K+ + rho0)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "mass3_specified", "title" : "m1m2m3(mu+, mu-, K+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass3_specified", "title" : "m1m2m3(mu+, mu-, rho0)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass3_specified", "title" : "m2m3m4(mu-, K+, rho0)", "d1" : 2, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "decayangle", "title" : "theta1(mu+,mu-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 200.0}, + {"variable" : "decayangle", "title" : "theta3(K+,rho0)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 200.0}, + {"variable" : "chi", "title" : "chi(mu+,mu-,K+,rho0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 360.0} + ], + "outfile" : "FOURBODYPHSP__Bu_mumuKrho0.root", + "reference" : "RefFOURBODYPHSP__Bu_mumuKrho0.root" +} diff --git a/test/jsonFiles/GENERIC_DALITZ__D0_KsKK.json b/test/jsonFiles/GENERIC_DALITZ__D0_KsKK.json new file mode 100644 index 0000000..31f8f82 --- /dev/null +++ b/test/jsonFiles/GENERIC_DALITZ__D0_KsKK.json @@ -0,0 +1,21 @@ +{ + "parent" : "D0", + "daughters" : ["K_S0", "K+", "K-"], + "models" : ["GENERIC_DALITZ"], + "parameters" : [["../validation/DalitzFiles/DalitzDecays.xml"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K^{-} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{0}_{S} K^{+}) vs m^{2}(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} K^{-}) vs m^{2}(K^{0}_{S} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "GENERIC_DALITZ__D0_K0sKK.root", + "reference" : "RefGENERIC_DALIZT__D0_K0sKK.root" +} diff --git a/test/jsonFiles/GOITY_ROBERTS=VSS__Bd_Dst0pienu,D0pi0.json b/test/jsonFiles/GOITY_ROBERTS=VSS__Bd_Dst0pienu,D0pi0.json new file mode 100644 index 0000000..f8103ba --- /dev/null +++ b/test/jsonFiles/GOITY_ROBERTS=VSS__Bd_Dst0pienu,D0pi0.json @@ -0,0 +1,42 @@ +{ + "parent" : "B0", + "daughters" : ["anti-D*0", "pi-", "e+", "nu_e"], + "grand_daughters" : [["anti-D0", "pi0"], [], []], + "models" : ["GOITY_ROBERTS", "VSS", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{D}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass", "title" : "M(#it{D}*^{0}#it{#pi})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "M(#it{D}*^{0}#it{e})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "M(#it{D}*^{0}#it{#nu})", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "M(#it{e}#it{#nu})", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "mass3", "title" : "M(#it{D}*^{0}#it{#pi}#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#it{e}#it{#nu})", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(#it{D}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{D}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pz", "title" : "pz(#it{D}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "decayangle", "title" : "#theta(#it{D}*^{0},#it{e})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0, "xmax" : 200.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{D}*^{0},#it{#pi})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{D}*^{0},#it{e})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{e}#it{#nu})", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{D}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{e})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#nu})", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{D}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.25}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "GOITY_ROBERTS=VSS__Bd_Dst0enu,D0pi0.root", + "reference" : "RefGOITY_ROBERTS=VSS__Bd_Dst0enu,D0pi0.root" +} diff --git a/test/jsonFiles/HELAMP=VSS__Bu_psi2SKstar_Jpsigamma,K0pi.json b/test/jsonFiles/HELAMP=VSS__Bu_psi2SKstar_Jpsigamma,K0pi.json new file mode 100644 index 0000000..ec4885e --- /dev/null +++ b/test/jsonFiles/HELAMP=VSS__Bu_psi2SKstar_Jpsigamma,K0pi.json @@ -0,0 +1,45 @@ +{ + "parent" : "B+", + "daughters" : ["psi(2S)", "K*+"], + "grand_daughters" : [["J/psi", "gamma"], ["K0", "pi+"]], + "models" : ["HELAMP", "HELAMP", "VSS"], + "parameters" : [["0.0", "0.0", "0.0", "0.0", "1.0", "0.0"], ["1.0", "0.0", "1.0", "0.0", "0.0", "0.0", "0.0", "0.0"], []], + "do_conjugate_decay" : [true, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(HELAMP,B)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(HELAMP,psi2S)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B+)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass", "title" : "m(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.6, "xmax" : 3.8}, + {"variable" : "mass", "title" : "m(K*+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.6}, + {"variable" : "mass_daug1", "title" : "m(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.0, "xmax" : 3.2}, + {"variable" : "mass_daug2", "title" : "m(K0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 0.6}, + {"variable" : "mass_daug2", "title" : "m(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "cosHel", "title" : "cosHel(J/psi,psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K0,K*+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "decayangle", "title" : "decayAngle(psi2S,K*+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(J/psi,gamma)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "decayangle_daug2", "title" : "decayAngle(K0,pi+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(K*+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(K0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug1", "title" : "phi(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug2", "title" : "phi(K0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug2", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "p", "title" : "p(psi2S)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.3}, + {"variable" : "p", "title" : "p(K*+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.3}, + {"variable" : "p_daug1", "title" : "p(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 0.6}, + {"variable" : "p_daug1", "title" : "p(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 0.6}, + {"variable" : "p_daug2", "title" : "p(K0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.8}, + {"variable" : "p_daug2", "title" : "p(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.8} + ], + "outfile" : "HELAMP=VSS__Bu_psi2SKstar_Jpsigamma,K0pi.root", + "reference" : "RefHELAMP=VSS__Bu_psi2SKstar_Jpsigamma,K0pi.root" +} diff --git a/test/jsonFiles/HQET2=VSS__Bd_Dstenu,D0pi.json b/test/jsonFiles/HQET2=VSS__Bd_Dstenu,D0pi.json new file mode 100644 index 0000000..658452c --- /dev/null +++ b/test/jsonFiles/HQET2=VSS__Bd_Dstenu,D0pi.json @@ -0,0 +1,37 @@ +{ + "parent" : "B0", + "daughters" : ["D*-", "e+", "nu_e"], + "grand_daughters" : [["anti-D0", "pi-"], [], []], + "models" : ["HQET2", "VSS", ""], + "parameters" : [["1.122", "0.921", "1.270", "0.852"], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{D}*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass", "title" : "M(#it{D}*#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "M(#it{D}*#it{#nu})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "M(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(#it{D}*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{D}*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pz", "title" : "pz(#it{D}*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(#it{D}*,#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{D}*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{e})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#nu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{D}*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.25}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{D}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "HQET2=VSS__Bd_Dstenu,D0pi.root", + "reference" : "RefHQET2=VSS__Bd_Dstenu,D0pi.root" +} diff --git a/test/jsonFiles/HQET=VSS__Bd_Dstenu,D0pi.json b/test/jsonFiles/HQET=VSS__Bd_Dstenu,D0pi.json new file mode 100644 index 0000000..5c62a6f --- /dev/null +++ b/test/jsonFiles/HQET=VSS__Bd_Dstenu,D0pi.json @@ -0,0 +1,37 @@ +{ + "parent" : "B0", + "daughters" : ["D*-", "e+", "nu_e"], + "grand_daughters" : [["anti-D0", "pi-"], [], []], + "models" : ["HQET", "VSS", ""], + "parameters" : [["0.92", "1.18", "0.72"], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass", "title" : "m(Dst e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(Dst nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(e nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pSumSq", "title" : "qSq(e nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pz", "title" : "pz(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(Dst,e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(e,nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.25}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "HQET=VSS__Bd_Dstenu,D0pi.root", + "reference" : "RefHQET=VSS__Bd_Dstenu,D0pi.root" +} diff --git a/test/jsonFiles/HypNonLepton__Lambda0_ppi.json b/test/jsonFiles/HypNonLepton__Lambda0_ppi.json new file mode 100644 index 0000000..1c6cb20 --- /dev/null +++ b/test/jsonFiles/HypNonLepton__Lambda0_ppi.json @@ -0,0 +1,19 @@ +{ + "parent" : "Lambda0", + "daughters" : ["p+", "pi-"], + "models" : ["HypNonLepton"], + "parameters" : [["0.642", "-6.5"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(#Lambda^{0})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(p #pi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.0, "xmax" : 1.2}, + {"variable" : "cosTheta", "title" : "cosTheta(p)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(p)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "HypNonLepton__Lambda0_ppi.root", + "reference" : "RefHypNonLepton__Lambda0_ppi.root" +} diff --git a/test/jsonFiles/ISGW2=PHSP=TAUSCALARNU__Bu_D0taunu,Kpi,pinu.json b/test/jsonFiles/ISGW2=PHSP=TAUSCALARNU__Bu_D0taunu,Kpi,pinu.json new file mode 100644 index 0000000..e7f4a61 --- /dev/null +++ b/test/jsonFiles/ISGW2=PHSP=TAUSCALARNU__Bu_D0taunu,Kpi,pinu.json @@ -0,0 +1,36 @@ +{ + "parent" : "B+", + "daughters" : ["anti-D0", "tau+", "nu_tau"], + "grand_daughters" : [["K+", "pi-"], ["pi+", "anti-nu_tau"], []], + "models" : ["ISGW2", "PHSP", "TAUSCALARNU"], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(D0 tau)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 3.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(tau nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 3.0, "xmax" : 15.0}, + {"variable" : "p", "title" : "p(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSq", "title" : "pSq(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pz", "title" : "pz(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.0, "xmax" : 2.0}, + {"variable" : "cosHel", "title" : "cosHel(tau,D0)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi2)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug1", "title" : "pLab(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug1", "title" : "pLab(pi1)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi1)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi1)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug2", "title" : "pLab(pi2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(pi2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(pi2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug2", "title" : "pLab(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "ISGW2=PHSP=TAUSCALARNU__Bu_D0taunu,Kpi,pinu.root", + "reference" : "RefISGW2=PHSP=TAUSCALARNU__Bu_D0taunu,Kpi,pinu.root" +} diff --git a/test/jsonFiles/ISGW2=VSS=TAUSCALARNU__Bd_Dsttaunu,D0pi,pinu.json b/test/jsonFiles/ISGW2=VSS=TAUSCALARNU__Bd_Dsttaunu,D0pi,pinu.json new file mode 100644 index 0000000..7beeffd --- /dev/null +++ b/test/jsonFiles/ISGW2=VSS=TAUSCALARNU__Bd_Dsttaunu,D0pi,pinu.json @@ -0,0 +1,36 @@ +{ + "parent" : "B0", + "daughters" : ["D*-", "tau+", "nu_tau"], + "grand_daughters" : [["anti-D0", "pi-"], ["pi+", "anti-nu_tau"], []], + "models" : ["ISGW2", "VSS", "TAUSCALARNU"], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(Dst tau)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 3.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "qSq(tau nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 3.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSq", "title" : "pSq(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pz", "title" : "pz(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.0, "xmax" : 2.0}, + {"variable" : "cosHel", "title" : "cosHel(tau,Dst)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi2)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug1", "title" : "pLab(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug1", "title" : "pLab(pi1)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.2}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi1)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi1)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug2", "title" : "pLab(pi2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(pi2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(pi2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "pLab_daug2", "title" : "pLab(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "ISGW2=VSS=TAUSCALARNU__Bd_Dsttaunu,D0pi,pinu.root", + "reference" : "RefISGW2=VSS=TAUSCALARNU__Bd_Dsttaunu,D0pi,pinu.root" +} diff --git a/test/jsonFiles/ISGW2=VSS__Bd_Dstmunu,D0pi.json b/test/jsonFiles/ISGW2=VSS__Bd_Dstmunu,D0pi.json new file mode 100644 index 0000000..24a4e18 --- /dev/null +++ b/test/jsonFiles/ISGW2=VSS__Bd_Dstmunu,D0pi.json @@ -0,0 +1,37 @@ +{ + "parent" : "B0", + "daughters" : ["D*-", "mu+", "nu_mu"], + "grand_daughters" : [["anti-D0", "pi-"], [], []], + "models" : ["ISGW2", "VSS", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass", "title" : "m(Dst mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(Dst nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pSumSq", "title" : "qSq(mu nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pz", "title" : "pz(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(Dst,mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu,nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.3}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "ISGW2=VSS__Bd_Dstmunu,D0pi.root", + "reference" : "RefISGW2=VSS__Bd_Dstmunu,D0pi.root" +} diff --git a/test/jsonFiles/ISGW=VSS__Bd_Dstmunu,D0pi.json b/test/jsonFiles/ISGW=VSS__Bd_Dstmunu,D0pi.json new file mode 100644 index 0000000..b406483 --- /dev/null +++ b/test/jsonFiles/ISGW=VSS__Bd_Dstmunu,D0pi.json @@ -0,0 +1,37 @@ +{ + "parent" : "B0", + "daughters" : ["D*-", "mu+", "nu_mu"], + "grand_daughters" : [["anti-D0", "pi-"], [], []], + "models" : ["ISGW", "VSS", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass", "title" : "m(Dst mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(Dst nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.5, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(mu nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 4.0}, + {"variable" : "pSumSq", "title" : "qSq(mu nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "pSq(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pz", "title" : "pz(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(Dst,mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu,nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.3}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "ISGW=VSS__Bd_Dstmunu,D0pi.root", + "reference" : "RefISGW=VSS__Bd_Dstmunu,D0pi.root" +} diff --git a/test/jsonFiles/KK_LAMBDAC_SL=HELAMP__Lambdac_Lambda0munu.json b/test/jsonFiles/KK_LAMBDAC_SL=HELAMP__Lambdac_Lambda0munu.json new file mode 100644 index 0000000..c1470c4 --- /dev/null +++ b/test/jsonFiles/KK_LAMBDAC_SL=HELAMP__Lambdac_Lambda0munu.json @@ -0,0 +1,22 @@ +{ + "parent" : "Lambda_c+", + "daughters" : ["Lambda0", "mu+", "nu_mu"], + "grand_daughters" : [["p+","pi-"], [], []], + "models" : ["KK_LAMBDAC_SL", "HELAMP", ""], + "parameters" : [["1.0", "2.0"], ["0.936", "0.0", "0.351", "0.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(KK_LAMBDAC_SL)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(HELAMP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(#Lambda^{+}_{c})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.4}, + {"variable" : "mass", "title" : "m(#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(#Lambda^{0} #mu^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.0, "xmax" : 2.5}, + {"variable" : "mass", "title" : "m(#Lambda^{0} #nu_{#mu})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.0, "xmax" : 2.5}, + {"variable" : "pSumSq", "title" : "q^{2}(#mu^{+} #nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "cosHel", "title" : "cosHel(p,#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(#Lambda^{0},p,#pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0} + ], + "outfile" : "KK_LAMBDAC_SL=HELAMP__Lambdac_Lambda0munu.root", + "reference" : "RefKK_LAMBDAC_SL=HELAMP__Lambdac_Lambda0munu.root" +} diff --git a/test/jsonFiles/KSTARNUNU__Bd_Kstr0nunu.json b/test/jsonFiles/KSTARNUNU__Bd_Kstr0nunu.json new file mode 100644 index 0000000..fe83720 --- /dev/null +++ b/test/jsonFiles/KSTARNUNU__Bd_Kstr0nunu.json @@ -0,0 +1,16 @@ +{ + "parent" : "B0", + "daughters" : ["K*0","nu_e","anti-nu_e"], + "models" : ["KSTARNUNU"], + "parameters" : [[]], + "extras" : ["Define dm_incohMix_B0 0.0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "massSq", "title" : "q2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "E", "title" : "E(nu_e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "totE_over_Mparent", "title" : "E(nu_e + anti-nu_e)/M(B)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.4, "xmax" : 0.9} + ], + "outfile" : "KSTARNUNU__Bd_Kstr0nunu.root", + "reference" : "RefKSTARNUNU__Bd_Kstr0nunu.root" +} diff --git a/test/jsonFiles/KSTARSTARGAMMA__Bd_Kpigamma.json b/test/jsonFiles/KSTARSTARGAMMA__Bd_Kpigamma.json new file mode 100644 index 0000000..d98febc --- /dev/null +++ b/test/jsonFiles/KSTARSTARGAMMA__Bd_Kpigamma.json @@ -0,0 +1,14 @@ +{ + "parent" : "B0", + "daughters" : ["K+", "pi-", "gamma"], + "models" : ["KSTARSTARGAMMA"], + "parameters" : [[]], + "extras" : ["Define dm_incohMix_B0 0.0"], + "events" : 10000, + "histograms" : [ + {"variable" : "mass", "title" : "m(K,pi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(K,pi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "KSTARSTARGAMMA__Bd_Kpigamma.root", + "reference" : "RefKSTARSTARGAMMA__Bd_Kpigamma.root" +} diff --git a/test/jsonFiles/KS_PI0MUMU__Ks_pi0mumu.json b/test/jsonFiles/KS_PI0MUMU__Ks_pi0mumu.json new file mode 100644 index 0000000..31f7e07 --- /dev/null +++ b/test/jsonFiles/KS_PI0MUMU__Ks_pi0mumu.json @@ -0,0 +1,21 @@ +{ + "parent" : "K_S0", + "daughters" : ["pi0", "mu+", "mu-"], + "models" : ["KS_PI0MUMU"], + "parameters" : [["1.2", "0.49", "-3.9", "0.2", "2.5"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.02}, + {"variable" : "mass", "title" : "m(#pi^{0} #mu^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.2, "xmax" : 0.4}, + {"variable" : "mass", "title" : "m(#mu^{+} #mu^{-})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 0.4}, + {"variable" : "mass", "title" : "m(#pi^{0} #mu^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 0.4}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{0} #mu^{+}) vs m^{2}(#pi^{0} #mu^{-})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.05, "xmax" : 0.16, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.05, "ymax" : 0.16}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#mu^{+} #mu^{-}) vs m^{2}(#pi^{0} #mu^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.03, "xmax" : 0.14, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.05, "ymax" : 0.16}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "KS_PI0MUMU__Ks_pi0mumu.root", + "reference" : "RefKS_PI0MUMU__Ks_pi0mumu.root" +} diff --git a/test/jsonFiles/LAMBDAB2LAMBDAV=LAMBDA2PPIFORLAMBDAB2LAMBDAV=V2VPVMFORLAMBDAB2LAMBDAV__Lambdab0_Lambda0Jpsi,ppi,mumu.json b/test/jsonFiles/LAMBDAB2LAMBDAV=LAMBDA2PPIFORLAMBDAB2LAMBDAV=V2VPVMFORLAMBDAB2LAMBDAV__Lambdab0_Lambda0Jpsi,ppi,mumu.json new file mode 100644 index 0000000..c30ed8d --- /dev/null +++ b/test/jsonFiles/LAMBDAB2LAMBDAV=LAMBDA2PPIFORLAMBDAB2LAMBDAV=V2VPVMFORLAMBDAB2LAMBDAV__Lambdab0_Lambda0Jpsi,ppi,mumu.json @@ -0,0 +1,23 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["Lambda0", "J/psi"], + "grand_daughters" : [["p+", "pi-"], ["mu+", "mu-"]], + "models" : ["LAMBDAB2LAMBDAV", "LAMBDA2PPIFORLAMBDAB2LAMBDAV", "V2VPVMFORLAMBDAB2LAMBDAV"], + "parameters" : [["0.5", "1"], ["0.5", "1"], ["0.5", "1"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(LAMBDAB2LAMBDAV)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(LAMBDA2PPIFORLAMBDAB2LAMBDAV)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(V2VPVMFORLAMBDAB2LAMBDAV)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(#Lambda^{0}_{b})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 2.5}, + {"variable" : "mass", "title" : "m(J/#psi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 3.0, "xmax" : 4.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "cosHel", "title" : "cosHel(p,#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "cosHel", "title" : "cosHel(#mu^{_},J/#psi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0} + ], + "outfile" : "LAMBDAB2LAMBDADAV__Lambdab0_Lambda0Jpsi,ppi,mumu.root", + "reference" : "RefLAMBDAB2LAMBDADAV__Lambdab0_Lambda0Jpsi,ppi,mumu.root" +} diff --git a/test/jsonFiles/LAMBDAC_PHH__Lc_pKpi.json b/test/jsonFiles/LAMBDAC_PHH__Lc_pKpi.json new file mode 100644 index 0000000..ba9a8a1 --- /dev/null +++ b/test/jsonFiles/LAMBDAC_PHH__Lc_pKpi.json @@ -0,0 +1,20 @@ +{ + "parent" : "Lambda_c+", + "daughters" : ["p+", "K-", "pi+"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["LAMBDAC_PHH"], + "parameters" : [[]], + "extras" : ["noPhotos"], + "events" : 100000, + "histograms" : [ + {"variable" : "mass", "title" : "mPK", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.4, "xmax" : 2.2}, + {"variable" : "mass", "title" : "mPPi", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.05, "xmax" : 1.85}, + {"variable" : "mass", "title" : "mKpi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.4}, + {"variable" : "cosHel", "title" : "cosTheta1", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta2", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta3", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "massSq", "title" : "Dalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 1.9, "xmax" : 4.8, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 25, "ymin" : 1.0, "ymax" : 3.4} + ], + "outfile" : "LAMBDAC_PHH__Lc_pKpi.root", + "reference" : "RefLAMBDAC_PHH__Lc_pKpi.root" +} diff --git a/test/jsonFiles/LNUGAMMA__Bu_enugamma.json b/test/jsonFiles/LNUGAMMA__Bu_enugamma.json new file mode 100644 index 0000000..ce7352d --- /dev/null +++ b/test/jsonFiles/LNUGAMMA__Bu_enugamma.json @@ -0,0 +1,25 @@ +{ + "parent" : "B+", + "daughters" : ["e+", "nu_e", "gamma"], + "models" : ["LNUGAMMA"], + "parameters" : [["0.35", "3.0", "5.0", "0.0"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B^{+})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass", "title" : "m(e^{+},#nu_{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.3}, + {"variable" : "pSumSq", "title" : "q^{2}(e^{+},nue)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(e^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "phi", "title" : "phi(e^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(#nu_{e})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "phi", "title" : "phi(#nu_{e})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu_{e})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(#gamma)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "phi", "title" : "phi(#gamma)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#gamma)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "E", "title" : "Dalitz q^{2}(e^{+},#nu_{e}) vs E(#gamma)", "d1" : 3, "d2" : 0, "nbins" : 50, "xmin" : 0.0, "xmax" : 3.0, "variableY" : "pSumSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 27.0} + ], + "outfile" : "LNUGAMMA__Bd_enugamma.root", + "reference" : "RefLNUGAMMA__Bd_enugamma.root" +} diff --git a/test/jsonFiles/Lb2Baryonlnu__Lb_Lc2593munu.json b/test/jsonFiles/Lb2Baryonlnu__Lb_Lc2593munu.json new file mode 100644 index 0000000..38f9e7d --- /dev/null +++ b/test/jsonFiles/Lb2Baryonlnu__Lb_Lc2593munu.json @@ -0,0 +1,15 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["Lambda_c(2593)+", "mu-", "anti-nu_mu"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["Lb2Baryonlnu"], + "parameters" : [["1.0", "1.0", "1.0", "1.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "massSq", "title" : "q2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 9.5}, + {"variable" : "cosHel", "title" : "cosTheta", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "Lb2Baryonlnu__Lb_Lc2593munu.root", + "reference" : "RefLb2Baryonlnu__Lb_Lc2593munu.root" +} diff --git a/test/jsonFiles/Lb2Baryonlnu__Lb_Lc2625munu.json b/test/jsonFiles/Lb2Baryonlnu__Lb_Lc2625munu.json new file mode 100644 index 0000000..02b0abe --- /dev/null +++ b/test/jsonFiles/Lb2Baryonlnu__Lb_Lc2625munu.json @@ -0,0 +1,15 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["Lambda_c(2625)+", "mu-", "anti-nu_mu"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["Lb2Baryonlnu"], + "parameters" : [["1.0", "1.0", "1.0", "1.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "massSq", "title" : "q2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 9.5}, + {"variable" : "cosHel", "title" : "cosTheta", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "Lb2Baryonlnu__Lb_Lc2625munu.root", + "reference" : "RefLb2Baryonlnu__Lb_Lc2625munu.root" +} diff --git a/test/jsonFiles/Lb2Baryonlnu__Lb_Lcmunu.json b/test/jsonFiles/Lb2Baryonlnu__Lb_Lcmunu.json new file mode 100644 index 0000000..98585a2 --- /dev/null +++ b/test/jsonFiles/Lb2Baryonlnu__Lb_Lcmunu.json @@ -0,0 +1,15 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["Lambda_c+", "mu-", "anti-nu_mu"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["Lb2Baryonlnu"], + "parameters" : [["1.0", "1.0", "1.0", "1.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "massSq", "title" : "q2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 11.5}, + {"variable" : "cosHel", "title" : "cosTheta", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "Lb2Baryonlnu__Lb_Lcmunu.root", + "reference" : "RefLb2Baryonlnu__Lb_Lcmunu.root" +} diff --git a/test/jsonFiles/Lb2Baryonlnu__Lb_pmunu.json b/test/jsonFiles/Lb2Baryonlnu__Lb_pmunu.json new file mode 100644 index 0000000..fa61ba3 --- /dev/null +++ b/test/jsonFiles/Lb2Baryonlnu__Lb_pmunu.json @@ -0,0 +1,15 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["p+", "mu-", "anti-nu_mu"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["Lb2Baryonlnu"], + "parameters" : [["1.0", "1.0", "1.0", "1.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "massSq", "title" : "q2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 22.0}, + {"variable" : "cosHel", "title" : "cosTheta", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "Lb2Baryonlnu__Lb_pmunu.root", + "reference" : "RefLb2Baryonlnu__Lb_pmunu.root" +} diff --git a/test/jsonFiles/Lb2Lll=HELAMP__Lambdab0_Lambda0mumu,pipi.json b/test/jsonFiles/Lb2Lll=HELAMP__Lambdab0_Lambda0mumu,pipi.json new file mode 100644 index 0000000..48f9e13 --- /dev/null +++ b/test/jsonFiles/Lb2Lll=HELAMP__Lambdab0_Lambda0mumu,pipi.json @@ -0,0 +1,22 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["Lambda0", "mu-", "mu+"], + "grand_daughters" : [["p+","pi-"], [], []], + "models" : ["Lb2Lll", "HELAMP", ""], + "parameters" : [[], ["0.936", "0.0", "0.351", "0.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(Lb2Lll)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(HELAMP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(#Lambda^{0}_{b})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(#Lambda^{0} #mu^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#Lambda^{0} #mu^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#mu^{-} #mu^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 21.0}, + {"variable" : "cosHel", "title" : "cosHel(p,#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(#Lambda^{0},p,#pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0} + ], + "outfile" : "Lb2Lll=HELAMP__Lambdab0_Lambda0mumu,ppi.root", + "reference" : "RefLb2Lll=HELAMP__Lambdab0_Lambda0mumu,ppi.root" +} diff --git a/test/jsonFiles/Lb2plnuLCSR__Lb_pmunu.json b/test/jsonFiles/Lb2plnuLCSR__Lb_pmunu.json new file mode 100644 index 0000000..1257d1d --- /dev/null +++ b/test/jsonFiles/Lb2plnuLCSR__Lb_pmunu.json @@ -0,0 +1,15 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["p+", "mu-", "anti-nu_mu"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["Lb2plnuLCSR"], + "parameters" : [["1.0", "1.0", "1.0", "1.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "massSq", "title" : "q2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 22.0}, + {"variable" : "cosHel", "title" : "cosTheta", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "Lb2plnuLCSR__Lb_pmunu.root", + "reference" : "RefLb2plnuLCSR__Lb_pmunu.root" +} diff --git a/test/jsonFiles/Lb2plnuLQCD__Lb_pmunu.json b/test/jsonFiles/Lb2plnuLQCD__Lb_pmunu.json new file mode 100644 index 0000000..6584538 --- /dev/null +++ b/test/jsonFiles/Lb2plnuLQCD__Lb_pmunu.json @@ -0,0 +1,15 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["p+", "mu-", "anti-nu_mu"], + "do_conjugate_decay" : [ true, true, true, true ], + "models" : ["Lb2plnuLQCD"], + "parameters" : [["1.0", "1.0", "1.0", "1.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "massSq", "title" : "q2", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 22.0}, + {"variable" : "cosHel", "title" : "cosTheta", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "Lb2plnuLQCD__Lb_pmunu.root", + "reference" : "RefLb2plnuLQCD__Lb_pmunu.root" +} diff --git a/test/jsonFiles/MELIKHOV=VSS__Bd_rhomunu,pipi0.json b/test/jsonFiles/MELIKHOV=VSS__Bd_rhomunu,pipi0.json new file mode 100644 index 0000000..50ed734 --- /dev/null +++ b/test/jsonFiles/MELIKHOV=VSS__Bd_rhomunu,pipi0.json @@ -0,0 +1,37 @@ +{ + "parent" : "B0", + "daughters" : ["rho-", "mu+", "nu_mu"], + "grand_daughters" : [["pi-", "pi0"], [], []], + "models" : ["MELIKHOV", "VSS", ""], + "parameters" : [["1"], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(MELIKHOV)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "mass", "title" : "M(#rho#mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "M(#rho#nu)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "M(#mu#nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#mu#nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "p", "title" : "p(#rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(#rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(#rho,#mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#mu#nu)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#pi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#pi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#pi^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#pi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#pi^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#pi^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "MELIKHOV=VSS__Bd_rhomunu,pipi0.root", + "reference" : "RefMELIKHOV=VSS__Bd_rhomunu,pipi0.root" +} diff --git a/test/jsonFiles/OMEGA_DALITZ__omega_pipipi0.json b/test/jsonFiles/OMEGA_DALITZ__omega_pipipi0.json new file mode 100644 index 0000000..7b1f1f4 --- /dev/null +++ b/test/jsonFiles/OMEGA_DALITZ__omega_pipipi0.json @@ -0,0 +1,21 @@ +{ + "parent" : "omega", + "daughters" : ["pi+", "pi-", "pi0"], + "models" : ["OMEGA_DALITZ"], + "parameters" : [[]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.75}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.75}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.75}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{-}) vs m^{2}(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.05, "xmax" : 0.55, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.05, "ymax" : 0.55}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{0}) vs m^{2}(#pi^{+} #pi^{-})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.05, "xmax" : 0.55, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.05, "ymax" : 0.55}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "OMEGA_DALITZ__omega_pipipi0.root", + "reference" : "RefOMEGA_DALITZ__omega_pipipi0.root" +} diff --git a/test/jsonFiles/PARTWAVE=VSS__Bd_DstarDstar,D0piD0pi.json b/test/jsonFiles/PARTWAVE=VSS__Bd_DstarDstar,D0piD0pi.json new file mode 100644 index 0000000..47efaae --- /dev/null +++ b/test/jsonFiles/PARTWAVE=VSS__Bd_DstarDstar,D0piD0pi.json @@ -0,0 +1,46 @@ +{ + "parent" : "B0", + "daughters" : ["D*+", "D*-"], + "grand_daughters" : [["D0", "pi+"], ["anti-D0", "pi-"]], + "models" : ["PARTWAVE", "VSS", "VSS"], + "parameters" : [["1.0", "0.0", "0.0", "0.0", "0.0", "0.0"], [], []], + "extras" : ["Define dm_incohMix_B0 0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(PARTWAVE,B)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VSS,D*+)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(VSS,D*-)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.1}, + {"variable" : "parMass", "title" : "m(B0)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.95, "xmax" : 2.05}, + {"variable" : "mass", "title" : "m(D*-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.95, "xmax" : 2.05}, + {"variable" : "mass_daug1", "title" : "m(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.9}, + {"variable" : "mass_daug1", "title" : "m(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "mass_daug2", "title" : "m(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.9}, + {"variable" : "mass_daug2", "title" : "m(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "cosHel", "title" : "cosHel(D0,D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(D0bar,D*-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "decayangle", "title" : "decayAngle(D*+,D*-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(D0,pi+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "decayangle_daug2", "title" : "decayAngle(D0bar,pi-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D*-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug2", "title" : "phi(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug2", "title" : "phi(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "p", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.65, "xmax" : 1.75}, + {"variable" : "p", "title" : "p(D*-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.65, "xmax" : 1.75}, + {"variable" : "p_daug1", "title" : "p(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.1}, + {"variable" : "p_daug1", "title" : "p(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.1}, + {"variable" : "p_daug2", "title" : "p(D0bar)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.1}, + {"variable" : "p_daug2", "title" : "p(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.1} + ], + "outfile" : "PARTWAVE=VSS__Bd_DstarDstar,D0piD0pi.root", + "reference" : "RefPARTWAVE=VSS__Bd_DstarDstar,D0piD0pi.root" +} diff --git a/test/jsonFiles/PHI_DALITZ__phi_pipipi0.json b/test/jsonFiles/PHI_DALITZ__phi_pipipi0.json new file mode 100644 index 0000000..086c085 --- /dev/null +++ b/test/jsonFiles/PHI_DALITZ__phi_pipipi0.json @@ -0,0 +1,21 @@ +{ + "parent" : "phi", + "daughters" : ["pi+", "pi-", "pi0"], + "models" : ["PHI_DALITZ"], + "parameters" : [[]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#pi^{-} #pi^{0})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{+} #pi^{-}) vs m^{2}(#pi^{+} #pi^{0})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 0.8, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 0.8}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(#pi^{-} #pi^{0}) vs m^{2}(#pi^{+} #pi^{-})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 0.8, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 0.8}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "PHI_DALITZ__eta_pipipi0.root", + "reference" : "RefPHI_DALITZ__eta_pipipi0.root" +} diff --git a/test/jsonFiles/PHSP=TAUSCALARNU__Bd_tautau,pinu,pinu.json b/test/jsonFiles/PHSP=TAUSCALARNU__Bd_tautau,pinu,pinu.json new file mode 100644 index 0000000..79ec758 --- /dev/null +++ b/test/jsonFiles/PHSP=TAUSCALARNU__Bd_tautau,pinu,pinu.json @@ -0,0 +1,53 @@ +{ + "parent" : "B0", + "daughters" : ["tau+", "tau-"], + "grand_daughters" : [["pi+", "anti-nu_tau"], ["pi-", "nu_tau"]], + "models" : ["PHSP", "TAUSCALARNU", "TAUSCALARNU"], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(tau+tau-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 5.1, "xmax" : 5.4}, + {"variable" : "pSumSq", "title" : "qSq(tau+tau-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 25.0, "xmax" : 30.0}, + {"variable" : "p", "title" : "p(tau+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.5}, + {"variable" : "pSq", "title" : "pSq(tau+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.5, "xmax" : 4.5}, + {"variable" : "pz", "title" : "pz(tau+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(tau-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHelTau1(pi+)", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHelTau2(pi-)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_over05", "title" : "cosHelTau1(pi+)", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_over05", "title" : "cosHelTau2(pi-)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_under05", "title" : "cosHelTau1(pi+)", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_under05", "title" : "cosHelTau2(pi-)", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "E_daug1", "title" : "E(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi+)/E(tau+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug1", "title" : "pzLab(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E_daug1", "title" : "E(nubar)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nubar)/E(tau+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(nubar)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug1", "title" : "pzLab(nubar)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nubar)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(nubar)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E_daug2", "title" : "E(pi-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug2", "title" : "E(pi-)/E(tau+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug2", "title" : "pLab(pi-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug2", "title" : "pzLab(pi-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(pi-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(pi-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E_daug2", "title" : "E(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug2", "title" : "E(nu)/E(tau+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug2", "title" : "pLab(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug2", "title" : "pzLab(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "PHSP=TAUSCALARNU__Bd_tautau,pinu,pinu.root", + "reference" : "RefPHSP=TAUSCALARNU__Bd_tautau,pinu,pinu.root" +} diff --git a/test/jsonFiles/PHSPDECAYTIMECUT__Bu_JpsiK+.json b/test/jsonFiles/PHSPDECAYTIMECUT__Bu_JpsiK+.json new file mode 100644 index 0000000..9edd9b9 --- /dev/null +++ b/test/jsonFiles/PHSPDECAYTIMECUT__Bu_JpsiK+.json @@ -0,0 +1,13 @@ +{ + "parent" : "B+", + "daughters" : ["J/psi", "K+"], + "do_conjugate_decay" : [ true, false, true ], + "models" : ["PHSPDECAYTIMECUT"], + "parameters" : [["0.4"]], + "events" : 10000, + "histograms" : [ + {"variable" : "lifetime", "title" : "tau", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 10.0} + ], + "outfile" : "PhspDecaytimeCut__Bu_JpsiK+.root", + "reference" : "RefPhspDecaytimeCut__Bu_JpsiK+.root" +} diff --git a/test/jsonFiles/PHSPFLATLIFETIME__Bu_JpsiKpi.json b/test/jsonFiles/PHSPFLATLIFETIME__Bu_JpsiKpi.json new file mode 100644 index 0000000..8b80dd6 --- /dev/null +++ b/test/jsonFiles/PHSPFLATLIFETIME__Bu_JpsiKpi.json @@ -0,0 +1,20 @@ +{ + "parent" : "B+", + "daughters" : ["J/psi", "K+", "pi0"], + "do_conjugate_decay" : [ true, false, true, false ], + "models" : ["PHSPFLATLIFETIME"], + "parameters" : [["5.0"]], + "events" : 20000, + "histograms" : [ + {"variable" : "lifetime", "title" : "tau", "d1" : 0, "d2" : 0, "nbins" : 110, "xmin" : 0.0, "xmax" : 5.5}, + {"variable" : "mass", "title" : "mKPi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.6, "xmax" : 2.25}, + {"variable" : "mass", "title" : "mJpsiPi", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 3.2, "xmax" : 4.8}, + {"variable" : "mass", "title" : "mJpsiK", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 3.5, "xmax" : 5.2}, + {"variable" : "cosHel", "title" : "cosTheta1", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta2", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta3", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "massSq", "title" : "dalitz", "d1" : 2, "d2" : 3, "nbins" : 25, "xmin" : 0.30, "xmax" : 5.30, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 25, "ymin" : 10.2, "ymax" : 23.2} + ], + "outfile" : "PHSPFLATLIFETIME__Bu_JpsiKpi.root", + "reference" : "RefPHSPFLATLIFETIME__Bu_JpsiKpi.root" +} diff --git a/test/jsonFiles/PHSP__Bd_4pi.json b/test/jsonFiles/PHSP__Bd_4pi.json new file mode 100644 index 0000000..a7fae53 --- /dev/null +++ b/test/jsonFiles/PHSP__Bd_4pi.json @@ -0,0 +1,39 @@ +{ + "parent" : "B0", + "daughters" : ["pi+", "pi-", "pi+", "pi-"], + "models" : ["PHSP"], + "parameters" : [[]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(pi1+pi1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.1, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(pi1+pi2+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(pi1- pi2+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(pi2+ pi2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(pi1+pi1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "pSumSq", "title" : "qSq(pi2+pi2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(pi1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(pi1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(pi1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(pi1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(pi2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(pi2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(pi2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(pi2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(pi1+,pi1-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi2+,pi2-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi1-,pi2+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi1+,pi2+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(pi1+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(pi1-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(pi2+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "phi", "title" : "phi(pi2-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "PHSP__Bd_4pi.root", + "reference" : "RefPHSP__Bd_4pi.root" +} diff --git a/test/jsonFiles/PI0_DALITZ__pi0_eegamma.json b/test/jsonFiles/PI0_DALITZ__pi0_eegamma.json new file mode 100644 index 0000000..da439de --- /dev/null +++ b/test/jsonFiles/PI0_DALITZ__pi0_eegamma.json @@ -0,0 +1,21 @@ +{ + "parent" : "pi0", + "daughters" : ["e+", "e-", "gamma"], + "models" : ["PI0_DALITZ"], + "parameters" : [[], [], []], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(e+ e-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.15}, + {"variable" : "mass", "title" : "m(e+ #gamma)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.15}, + {"variable" : "mass", "title" : "m(e- #gamma)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.15}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(e+ e-) vs m^{2}(e+ #gamma)", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 0.02, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 0.02}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(e- #gamma) vs m^{2}(e+ e-)", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.0, "xmax" : 0.02, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 0.02}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "PI0DALITZ__pi0_eegamma.root", + "reference" : "RefPI0DALITZ__pi0_eegamma.root" +} diff --git a/test/jsonFiles/PROPSLPOLE=VSS__D+_Kst0enu,Kpi.json b/test/jsonFiles/PROPSLPOLE=VSS__D+_Kst0enu,Kpi.json new file mode 100644 index 0000000..40aa32e --- /dev/null +++ b/test/jsonFiles/PROPSLPOLE=VSS__D+_Kst0enu,Kpi.json @@ -0,0 +1,38 @@ +{ + "parent" : "D+", + "daughters" : ["anti-K*0", "e+", "nu_e"], + "grand_daughters" : [["K-", "pi+"], [], []], + "models" : ["PROPSLPOLE", "VSS", ""], + "parameters" : [["1.00", "-0.558", "0.0", "1.0", "0.85", "-0.558", "0.0", "1.0", "1.50", "-0.790", "0.0", "1.0", "0.00", "-0.558", "0.0", "1.0"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.4}, + {"variable" : "mass", "title" : "M(#it{K}*^{0}#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "mass", "title" : "M(#it{K}*^{0}#it{#nu})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "mass", "title" : "M(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pz", "title" : "pz(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}*^{0},#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "decayangle", "title" : "#theta(#it{K}*^{0},#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 200.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{e})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#nu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "PROPSLPOLE=VSS__D+_Kst0enu,Kpi.root", + "reference" : "RefPROPSLPOLE=VSS__D+_Kst0enu,Kpi.root" +} diff --git a/test/jsonFiles/PSI2JPSIPIPI__psi2S_Jpsipipi_nlo.json b/test/jsonFiles/PSI2JPSIPIPI__psi2S_Jpsipipi_nlo.json new file mode 100644 index 0000000..cfee186 --- /dev/null +++ b/test/jsonFiles/PSI2JPSIPIPI__psi2S_Jpsipipi_nlo.json @@ -0,0 +1,15 @@ +{ + "parent" : "X_2(3872)", + "daughters" : ["J/psi", "pi+", "pi-"], + "models" : ["PSI2JPSIPIPI"], + "parameters" : [["0.78539816"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mPiPi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.85}, + {"variable" : "cosHel", "title" : "cosTheta1", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta2", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "PSI2JPSIPIPI__psi2S_Jpsipipi_nlo.root", + "reference" : "RefPSI2JPSIPIPI__psi2S_Jpsipipi_nlo.root" +} diff --git a/test/jsonFiles/PSI2JPSIPIPI__psi2S_Jpsipipi_tree.json b/test/jsonFiles/PSI2JPSIPIPI__psi2S_Jpsipipi_tree.json new file mode 100644 index 0000000..f03ace4 --- /dev/null +++ b/test/jsonFiles/PSI2JPSIPIPI__psi2S_Jpsipipi_tree.json @@ -0,0 +1,15 @@ +{ + "parent" : "X_2(3872)", + "daughters" : ["J/psi", "pi+", "pi-"], + "models" : ["PSI2JPSIPIPI"], + "parameters" : [[]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "mPiPi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 0.85}, + {"variable" : "cosHel", "title" : "cosTheta1", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosTheta2", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "PSI2JPSIPIPI__psi2S_Jpsipipi_tree.root", + "reference" : "RefPSI2JPSIPIPI__psi2S_Jpsipipi_tree.root" +} diff --git a/test/jsonFiles/PTO3P__D0_K0sKK.json b/test/jsonFiles/PTO3P__D0_K0sKK.json new file mode 100644 index 0000000..da5328d --- /dev/null +++ b/test/jsonFiles/PTO3P__D0_K0sKK.json @@ -0,0 +1,25 @@ +{ + "parent" : "D0", + "daughters" : ["K_S0", "K+", "K-"], + "models" : ["PTO3P"], + "parameters" : [["MAXPDF 6.0", + "AMPLITUDE RESONANCE BC a_00 ANGULAR AC TYPE NBW COEFFICIENT POLAR_RAD 1.0 0.0", + "AMPLITUDE RESONANCE BC phi ANGULAR AC TYPE RBW_ZEMACH COEFFICIENT POLAR_RAD 0.437 1.91", + "AMPLITUDE RESONANCE AB a_0+ ANGULAR CA TYPE NBW COEFFICIENT POLAR_RAD 0.460 3.59", + "AMPLITUDE RESONANCE BC f'_0 ANGULAR AC TYPE RBW_ZEMACH COEFFICIENT POLAR_RAD 0.435 -2.65"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{+})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(K^{-} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.9, "xmax" : 1.5}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{0}_{S} K^{+}) vs m^{2}(K^{0}_{S} K^{-})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(K^{+} K^{-}) vs m^{2}(K^{0}_{S} K^{+})", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : 0.8, "xmax" : 2.0, "variableY" : "massSq", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 50, "ymin" : 0.8, "ymax" : 2.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel12", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel23", "d1" : 2, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel13", "d1" : 1, "d2" : 3, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "PTO3P__D0_K0sKK.root", + "reference" : "RefPTO3P__D0_K0sKK.root" +} diff --git a/test/jsonFiles/PVV_CPLH=VLL=VSS__B0s_Jpsiphi,ee,KK.json b/test/jsonFiles/PVV_CPLH=VLL=VSS__B0s_Jpsiphi,ee,KK.json new file mode 100644 index 0000000..7ec49fd --- /dev/null +++ b/test/jsonFiles/PVV_CPLH=VLL=VSS__B0s_Jpsiphi,ee,KK.json @@ -0,0 +1,26 @@ +{ + "parent" : "B_s0", + "daughters" : ["J/psi", "phi"], + "grand_daughters" : [["e+", "e-"], ["K+", "K-"]], + "models" : ["PVV_CPLH", "VLL", "VSS"], + "parameters" : [["-0.035", "1", "0.480", "3.30", "0.722", "0.0", "0.499", "3.07"], [], []], + "do_conjugate_decay" : [true, false, false], + "extras" : ["Define dm_incohMix_B_s0 0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(PVV_CPLH)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VLL)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0s)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.5}, + {"variable" : "mass", "title" : "m(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "mass", "title" : "m(phi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "cosHel", "title" : "cosHel(e)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "DecayAngle(e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "decayangle_daug2", "title" : "DecayAngle(K)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(e)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 1.8}, + {"variable" : "p_daug2", "title" : "p(K)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.3} + ], + "outfile" : "PVV_CPLH=VLL=VSS__Bs0_Jpsiphi,ee,KK.root", + "reference" : "RefPVV_CPLH=VLL=VSS__Bs0_Jpsiphi,ee,KK.root" +} diff --git a/test/jsonFiles/RareLbToLll=HELAMP__Lambdab0_Lambda0mumu,pipi.json b/test/jsonFiles/RareLbToLll=HELAMP__Lambdab0_Lambda0mumu,pipi.json new file mode 100644 index 0000000..bf86f62 --- /dev/null +++ b/test/jsonFiles/RareLbToLll=HELAMP__Lambdab0_Lambda0mumu,pipi.json @@ -0,0 +1,22 @@ +{ + "parent" : "Lambda_b0", + "daughters" : ["Lambda0", "mu-", "mu+"], + "grand_daughters" : [["p+","pi-"], [], []], + "models" : ["RareLbToLll", "HELAMP", ""], + "parameters" : [[], ["0.936", "0.0", "0.351", "0.0"]], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(RareLbToLll)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(HELAMP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(#Lambda^{0}_{b})", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(#Lambda^{0} #mu^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "mass", "title" : "m(#Lambda^{0} #mu^{+})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 6.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#mu^{-} #mu^{+})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 21.0}, + {"variable" : "cosHel", "title" : "cosHel(p,#Lambda^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(#Lambda^{0},p,#pi^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0} + ], + "outfile" : "RareLbToLll=HELAMP__Lambdab0_Lambda0mumu,ppi.root", + "reference" : "RefRareLbToLll=HELAMP__Lambdab0_Lambda0mumu,ppi.root" +} diff --git a/test/jsonFiles/SINGLE__Upsilon4S_mu.json b/test/jsonFiles/SINGLE__Upsilon4S_mu.json new file mode 100644 index 0000000..ca0ed5f --- /dev/null +++ b/test/jsonFiles/SINGLE__Upsilon4S_mu.json @@ -0,0 +1,17 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["mu+"], + "models" : ["SINGLE"], + "parameters" : [["0.5", "1.0", "-0.8", "0.5", "0.0", "6.2832"]], + "extras" : ["noPhotos"], + "events" : 100000, + "histograms" : [ + {"variable" : "parMass", "title" : "m(Upsilon4S)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 10.0, "xmax" : 11.0}, + {"variable" : "mass", "title" : "m(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.05, "xmax" : 0.15}, + {"variable" : "p", "title" : "p(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.1}, + {"variable" : "cosTheta", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SINGLE__Upsilon4S_mu.root", + "reference" : "RefSINGLE__Upsilon4S_mu.root" +} diff --git a/test/jsonFiles/SLBKPOLE=PHSP__D+_Ksenu,pipi.json b/test/jsonFiles/SLBKPOLE=PHSP__D+_Ksenu,pipi.json new file mode 100644 index 0000000..e049468 --- /dev/null +++ b/test/jsonFiles/SLBKPOLE=PHSP__D+_Ksenu,pipi.json @@ -0,0 +1,38 @@ +{ + "parent" : "D+", + "daughters" : ["anti-K0", "e+", "nu_e"], + "grand_daughters" : [["pi+", "pi-"], [], []], + "models" : ["SLBKPOLE", "PHSP", ""], + "parameters" : [["1.0", "0.303", "1.0", "2.112"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{K}_{S}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.4}, + {"variable" : "mass", "title" : "M(#it{K}_{S}^{0}#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "mass", "title" : "M(#it{K}_{S}^{0}#it{#nu})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "mass", "title" : "M(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(#it{K}_{S}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{K}_{S}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pz", "title" : "pz(#it{K}_{S}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}_{S}^{0},#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}_{S}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "decayangle", "title" : "#theta(#it{K}_{S}^{0},#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 200.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{K}_{S}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{e})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#nu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{K}_{S}^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SLBKPOLE=PHSP__D+_Ksenu,pipi.root", + "reference" : "RefSLBKPOLE=PHSP__D+_Ksenu,pipi.root" +} diff --git a/test/jsonFiles/SLL=TAUSCALARNU__Bd_tautau,pinu,pinu.json b/test/jsonFiles/SLL=TAUSCALARNU__Bd_tautau,pinu,pinu.json new file mode 100644 index 0000000..611faba --- /dev/null +++ b/test/jsonFiles/SLL=TAUSCALARNU__Bd_tautau,pinu,pinu.json @@ -0,0 +1,53 @@ +{ + "parent" : "B0", + "daughters" : ["tau+", "tau-"], + "grand_daughters" : [["pi+", "anti-nu_tau"], ["pi-", "nu_tau"]], + "models" : ["SLL", "TAUSCALARNU", "TAUSCALARNU"], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(SLL)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob_{1}(TAUSCALARNU)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob_{2}(TAUSCALARNU)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(#tau^{+}#tau^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 5.1, "xmax" : 5.4}, + {"variable" : "p", "title" : "p(#tau^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.5}, + {"variable" : "pz", "title" : "pz(#tau^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(#tau^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#tau^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHelTau1(#pi^{+})", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHelTau2(#pi^{-})", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_over05", "title" : "cosHelTau1(#pi^{+})", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_over05", "title" : "cosHelTau2(#pi^{-})", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_under05", "title" : "cosHelTau1(#pi^{+})", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau_under05", "title" : "cosHelTau2(#pi^{-})", "d1" : 2, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "E_daug1", "title" : "E(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(#pi^{+})/E(#tau^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug1", "title" : "pzLab(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E_daug1", "title" : "E(#bar{#nu})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(#bar{#nu})/E(#tau^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#bar{#nu})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug1", "title" : "pzLab(#bar{#nu})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#bar{#nu})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#bar{#nu})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E_daug2", "title" : "E(#pi^{-})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug2", "title" : "E(#pi^{-})/E(#tau^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug2", "title" : "pLab(#pi^{-})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug2", "title" : "pzLab(#pi^{-})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(#pi^{-})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(#pi^{-})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E_daug2", "title" : "E(#nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "E_over_Eparent_daug2", "title" : "E(#nu)/E(#tau^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug2", "title" : "pLab(#nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pzLab_daug2", "title" : "pzLab(#nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(#nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(#nu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "SLL=TAUSCALARNU__Bd_tautau,pinu,pinu.root", + "reference" : "RefSLL=TAUSCALARNU__Bd_tautau,pinu,pinu.root" +} diff --git a/test/jsonFiles/SLN=TAUHADNU__Bu_taunu,pi0pi0pinu.json b/test/jsonFiles/SLN=TAUHADNU__Bu_taunu,pi0pi0pinu.json new file mode 100644 index 0000000..b1536d2 --- /dev/null +++ b/test/jsonFiles/SLN=TAUHADNU__Bu_taunu,pi0pi0pinu.json @@ -0,0 +1,42 @@ +{ + "parent" : "B+", + "daughters" : ["tau+", "nu_tau"], + "grand_daughters" : [["pi0", "pi0", "pi+", "anti-nu_tau"], []], + "models" : ["SLN", "TAUHADNU", ""], + "parameters" : [[], ["-0.108", "0.775", "0.149", "1.364", "0.400", "1.23", "0.4"], []], + "extras" : ["Define TauolaBR1 1.0", + "Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "p", "title" : "p(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.6}, + {"variable" : "pz", "title" : "pz(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E", "title" : "E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "E_over_Eparent", "title" : "E(tau)/E(B)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi0_{1})/E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi0_{2})/E(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi+)/E(tau)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nu)/E(tau)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi0_{1})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi0_{2})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nu)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi0_{1})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi0_{1})", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi0_{2})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nu)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(pi0_{1} pi0_{2})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi0_{1} pi+)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi0_{1} nu)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi0_{2} pi+)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi0_{2} nu)", "d1" : 2, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi+ nu)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass3_daug1", "title" : "m(pi0_{1} pi0_{2} pi+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "cosTheta3_daug1", "title" : "cosTheta3", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "SLN=TAUHADNU__Bu_taunu,pi0pi0pinu.root", + "reference" : "RefSLN=TAUHADNU__Bu_taunu,pi0pi0pinu.root" +} diff --git a/test/jsonFiles/SLN=TAULNUNU__Bu_taunu,enu.json b/test/jsonFiles/SLN=TAULNUNU__Bu_taunu,enu.json new file mode 100644 index 0000000..85b4942 --- /dev/null +++ b/test/jsonFiles/SLN=TAULNUNU__Bu_taunu,enu.json @@ -0,0 +1,33 @@ +{ + "parent" : "B+", + "daughters" : ["tau+", "nu_tau"], + "grand_daughters" : [["e+", "nu_e", "anti-nu_tau"], []], + "models" : ["SLN", "TAULNUNU", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "p", "title" : "p(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.6}, + {"variable" : "pz", "title" : "pz(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E", "title" : "E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "E_over_Eparent", "title" : "E(tau)/E(B)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(e)/E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nue)/E(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nutau_{2})/E(tau)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(e)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nue)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nutau_{2})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(e)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(e)", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nue)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nutau_{2})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(e nue)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(e nutau_{2})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(nue nutau_{2})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0} + ], + "outfile" : "SLN=TAULNUNU__Bu_taunu,enu.root", + "reference" : "RefSLN=TAULNUNU__Bu_taunu,enu.root" +} diff --git a/test/jsonFiles/SLN=TAULNUNU__Bu_taunu,munu.json b/test/jsonFiles/SLN=TAULNUNU__Bu_taunu,munu.json new file mode 100644 index 0000000..7b781d6 --- /dev/null +++ b/test/jsonFiles/SLN=TAULNUNU__Bu_taunu,munu.json @@ -0,0 +1,33 @@ +{ + "parent" : "B+", + "daughters" : ["tau+", "nu_tau"], + "grand_daughters" : [["mu+", "nu_mu", "anti-nu_tau"], []], + "models" : ["SLN", "TAULNUNU", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "p", "title" : "p(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.6}, + {"variable" : "pz", "title" : "pz(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E", "title" : "E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "E_over_Eparent", "title" : "E(tau)/E(B)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(mu)/E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(numu)/E(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nutau)/E(tau)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(numu)", "d1" : 2, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nutau)", "d1" : 3, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(mu)", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(numu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nutau)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(mu numu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(mu nutau)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(numu nutau)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0} + ], + "outfile" : "SLN=TAULNUNU__Bu_taunu,munu.root", + "reference" : "RefSLN=TAULNUNU__Bu_taunu,munu.root" +} diff --git a/test/jsonFiles/SLN=TAUOLA__Bu_taunu,pipipinu,BaBar.json b/test/jsonFiles/SLN=TAUOLA__Bu_taunu,pipipinu,BaBar.json new file mode 100644 index 0000000..11d1f66 --- /dev/null +++ b/test/jsonFiles/SLN=TAUOLA__Bu_taunu,pipipinu,BaBar.json @@ -0,0 +1,43 @@ +{ + "parent" : "B+", + "daughters" : ["tau+", "nu_tau"], + "grand_daughters" : [[" "], []], + "models" : ["SLN", "TAUOLA", ""], + "parameters" : [[], ["5"], []], + "extras" : ["Define TauolaCurrentOption 1", + "Define TauolaBR1 1.0", + "Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "p", "title" : "p(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.6}, + {"variable" : "pz", "title" : "pz(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E", "title" : "E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "E_over_Eparent", "title" : "E(tau)/E(B)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nutau_{2})/E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi+_{1})/E(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi+_{2})/E(tau)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi-)/E(tau)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nutau_{2})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+_{1})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+_{2})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(nutau_{2})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nutau_{2})", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi+_{1})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi+_{2})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi-)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(nutau_{2} pi+_{1})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(nutau_{2} pi+_{2})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(nutau_{2} pi-)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi+_{1} pi+_{2})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi+_{1} pi-)", "d1" : 2, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi+_{2} pi-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass3_daug1", "title" : "m(pi+_{1} pi+_{2} pi-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "cosTheta3_daug1", "title" : "cosTheta3pi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "SLN=TAUOLA__Bu_taunu,pipipinu,BaBar.root", + "reference" : "RefSLN=TAUOLA__Bu_taunu,pipipinu,BaBar.root" +} diff --git a/test/jsonFiles/SLN=TAUOLA__Bu_taunu,pipipinu,CLEO.json b/test/jsonFiles/SLN=TAUOLA__Bu_taunu,pipipinu,CLEO.json new file mode 100644 index 0000000..9129857 --- /dev/null +++ b/test/jsonFiles/SLN=TAUOLA__Bu_taunu,pipipinu,CLEO.json @@ -0,0 +1,43 @@ +{ + "parent" : "B+", + "daughters" : ["tau+", "nu_tau"], + "grand_daughters" : [[" "], []], + "models" : ["SLN", "TAUOLA", ""], + "parameters" : [[], ["5"], []], + "extras" : ["Define TauolaCurrentOption 0", + "Define TauolaBR1 1.0", + "Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "p", "title" : "p(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.6}, + {"variable" : "pz", "title" : "pz(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E", "title" : "E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "E_over_Eparent", "title" : "E(tau)/E(B)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nutau_{2})/E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi+_{1})/E(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi+_{2})/E(tau)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi-)/E(tau)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nutau_{2})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+_{1})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+_{2})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi-)", "d1" : 4, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(nutau_{2})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nutau_{2})", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi+_{1})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi+_{2})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi-)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(nutau_{2} pi+_{1})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(nutau_{2} pi+_{2})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(nutau_{2} pi-)", "d1" : 1, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi+_{1} pi+_{2})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi+_{1} pi-)", "d1" : 2, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass_daug1", "title" : "m(pi+_{2} pi-)", "d1" : 3, "d2" : 4, "nbins" : 100, "xmin" : 0.25, "xmax" : 2.0}, + {"variable" : "mass3_daug1", "title" : "m(pi+_{1} pi+_{2} pi-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.2, "xmax" : 1.8}, + {"variable" : "cosTheta3_daug1", "title" : "cosTheta3pi", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "SLN=TAUOLA__Bu_taunu,pipipinu,CLEO.root", + "reference" : "RefSLN=TAUOLA__Bu_taunu,pipipinu,CLEO.root" +} diff --git a/test/jsonFiles/SLN=TAUSCALARNU__Bu_taunu,pinu.json b/test/jsonFiles/SLN=TAUSCALARNU__Bu_taunu,pinu.json new file mode 100644 index 0000000..33c6460 --- /dev/null +++ b/test/jsonFiles/SLN=TAUSCALARNU__Bu_taunu,pinu.json @@ -0,0 +1,28 @@ +{ + "parent" : "B+", + "daughters" : ["tau+", "nu_tau"], + "grand_daughters" : [["pi+", "anti-nu_tau"], []], + "models" : ["SLN", "TAUSCALARNU", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "p", "title" : "p(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.6}, + {"variable" : "pz", "title" : "pz(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E", "title" : "E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "E_over_Eparent", "title" : "E(tau)/E(B)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(pi)/E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nutau_{2})/E(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nutau_{2})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(pi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(pi)", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nutau_{2})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(pi nutau_{2})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.7, "xmax" : 1.9} + ], + "outfile" : "SLN=TAUSCALARNU__Bu_taunu,pinu.root", + "reference" : "RefSLN=TAUSCALARNU__Bu_taunu,pinu.root" +} diff --git a/test/jsonFiles/SLN=TAUVECTORNU__Bu_taunu,rhonu.json b/test/jsonFiles/SLN=TAUVECTORNU__Bu_taunu,rhonu.json new file mode 100644 index 0000000..8ddf3f8 --- /dev/null +++ b/test/jsonFiles/SLN=TAUVECTORNU__Bu_taunu,rhonu.json @@ -0,0 +1,29 @@ +{ + "parent" : "B+", + "daughters" : ["tau+", "nu_tau"], + "grand_daughters" : [["rho+", "anti-nu_tau"], []], + "models" : ["SLN", "TAUVECTORNU", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "p", "title" : "p(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.2, "xmax" : 2.6}, + {"variable" : "pz", "title" : "pz(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosTheta", "title" : "cosTheta(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "E", "title" : "E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "E_over_Eparent", "title" : "E(tau)/E(B)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(rho)/E(tau)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "E_over_Eparent_daug1", "title" : "E(nutau_{2})/E(tau)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(nutau_{2})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(rho)", "d1" : 1, "d2" : 1, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelTau", "title" : "cosHelTau(nutau_{2})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(rho nutau_{2})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.7, "xmax" : 1.9}, + {"variable" : "mass_daug1", "title" : "m(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0} + ], + "outfile" : "SLN=TAUVECTORNU__Bu_taunu,rhonu.root", + "reference" : "RefSLN=TAUVECTORNU__Bu_taunu,rhonu.root" +} diff --git a/test/jsonFiles/SLPOLE=VSS__D+_Kst0enu,Kpi.json b/test/jsonFiles/SLPOLE=VSS__D+_Kst0enu,Kpi.json new file mode 100644 index 0000000..f9bff06 --- /dev/null +++ b/test/jsonFiles/SLPOLE=VSS__D+_Kst0enu,Kpi.json @@ -0,0 +1,38 @@ +{ + "parent" : "D+", + "daughters" : ["anti-K*0", "e+", "nu_e"], + "grand_daughters" : [["K-", "pi+"], [], []], + "models" : ["SLPOLE", "VSS", ""], + "parameters" : [["1.00", "-0.558", "0.0", "1.0", "0.85", "-0.558", "0.0", "1.0", "1.50", "-0.790", "0.0", "1.0", "0.00", "-0.558", "0.0", "1.0"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.4}, + {"variable" : "mass", "title" : "M(#it{K}*^{0}#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "mass", "title" : "M(#it{K}*^{0}#it{#nu})", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 0.5, "xmax" : 2.0}, + {"variable" : "mass", "title" : "M(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pSumSq", "title" : "q^{2}(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pz", "title" : "pz(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}*^{0},#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{e}#it{#nu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "decayangle", "title" : "#theta(#it{K}*^{0},#it{e})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 200.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{e})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#nu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{K})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SLPOLE=VSS__D+_Kst0enu,Kpi.root", + "reference" : "RefSLPOLE=VSS__D+_Kst0enu,Kpi.root" +} diff --git a/test/jsonFiles/SSD_DirectCP=TSS__Bu_f2pi+,pi+pi-.json b/test/jsonFiles/SSD_DirectCP=TSS__Bu_f2pi+,pi+pi-.json new file mode 100644 index 0000000..debae4f --- /dev/null +++ b/test/jsonFiles/SSD_DirectCP=TSS__Bu_f2pi+,pi+pi-.json @@ -0,0 +1,19 @@ +{ + "parent" : "B+", + "daughters" : ["f_2", "pi+"], + "grand_daughters" : [["pi+", "pi-"], []], + "models" : ["SSD_DirectCP", "TSS", ""], + "parameters" : [["0.40"], [], []], + "do_conjugate_decay" : [ true, false, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "id", "title" : "StdHep ID", "d1" : 0, "d2" : 0, "nbins" : 2, "xmin" : -600.0, "xmax" : 600.0}, + {"variable" : "p", "title" : "f_2 Mtm", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "pi Mtm", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "f_2 Mass", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "f_2 Helicity Angle", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "SSD_DirectCP=TSS__Bu_f2pi+,pi+pi-.root", + "reference" : "RefSSD_DirectCP=TSS__Bu_f2pi+,pi+pi-.root" +} diff --git a/test/jsonFiles/SSD_DirectCP=VSS__Bu_Kst0pi+,K+pi-.json b/test/jsonFiles/SSD_DirectCP=VSS__Bu_Kst0pi+,K+pi-.json new file mode 100644 index 0000000..b303551 --- /dev/null +++ b/test/jsonFiles/SSD_DirectCP=VSS__Bu_Kst0pi+,K+pi-.json @@ -0,0 +1,19 @@ +{ + "parent" : "B+", + "daughters" : ["K*0", "pi+"], + "grand_daughters" : [["K+", "pi-"], []], + "models" : ["SSD_DirectCP", "VSS", ""], + "parameters" : [["0.032"], [], []], + "do_conjugate_decay" : [ true, true, false ], + "events" : 10000, + "histograms" : [ + {"variable" : "id", "title" : "StdHep ID", "d1" : 0, "d2" : 0, "nbins" : 2, "xmin" : -600.0, "xmax" : 600.0}, + {"variable" : "p", "title" : "Kst Mtm", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "pi Mtm", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "mass", "title" : "Kst Mass", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "cosHel", "title" : "Kst Helicity Angle", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0} + ], + "outfile" : "SSD_DirectCP=VSS__Bu_Kst0pi+,K+pi-.root", + "reference" : "RefSSD_DirectCP=VSS__Bu_Kst0pi+,K+pi-.root" +} diff --git a/test/jsonFiles/SSD_DirectCP__Bd_K+pi-.json b/test/jsonFiles/SSD_DirectCP__Bd_K+pi-.json new file mode 100644 index 0000000..a4ce5fe --- /dev/null +++ b/test/jsonFiles/SSD_DirectCP__Bd_K+pi-.json @@ -0,0 +1,16 @@ +{ + "parent" : "B0", + "daughters" : ["K+", "pi-"], + "models" : ["SSD_DirectCP"], + "parameters" : [["-0.083"]], + "do_conjugate_decay" : [ true ], + "events" : 10000, + "histograms" : [ + {"variable" : "id", "title" : "StdHep ID", "d1" : 0, "d2" : 0, "nbins" : 2, "xmin" : -600.0, "xmax" : 600.0}, + {"variable" : "p", "title" : "K Mtm", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "pi Mtm", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0} + ], + "outfile" : "SSD_DirectCP__Bd_K+pi-.root", + "reference" : "RefSSD_DirectCP__Bd_K+pi-.root" +} diff --git a/test/jsonFiles/STS=TSS__Bu_D2st0pi,Dpi.json b/test/jsonFiles/STS=TSS__Bu_D2st0pi,Dpi.json new file mode 100644 index 0000000..17e66a3 --- /dev/null +++ b/test/jsonFiles/STS=TSS__Bu_D2st0pi,Dpi.json @@ -0,0 +1,29 @@ +{ + "parent" : "B+", + "daughters" : ["D_2*0", "pi+"], + "grand_daughters" : [["D+", "pi-"], [], []], + "models" : ["STS", "TSS", ""], + "parameters" : [[], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(D2st)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.5}, + {"variable" : "mass", "title" : "m(D2st pi+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 5.0, "xmax" : 5.5}, + {"variable" : "p", "title" : "p(D2st)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.6, "xmax" : 2.3}, + {"variable" : "pSq", "title" : "pSq(D2st)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 5.0}, + {"variable" : "pz", "title" : "pz(D2st)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -2.5, "xmax" : 2.5}, + {"variable" : "cosHel", "title" : "cosHel(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Dst)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(D2st)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "pLab_daug1", "title" : "pLab(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.8}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "STS=TSS__Bu_D2st0pi,Dpi.root", + "reference" : "RefSTS=TSS__Bu_D2st0pi,Dpi.root" +} diff --git a/test/jsonFiles/STS_CP=TVS_PWAVE__Bd_a2pi,rhopi.json b/test/jsonFiles/STS_CP=TVS_PWAVE__Bd_a2pi,rhopi.json new file mode 100644 index 0000000..8c185b5 --- /dev/null +++ b/test/jsonFiles/STS_CP=TVS_PWAVE__Bd_a2pi,rhopi.json @@ -0,0 +1,30 @@ +{ + "parent" : "B0", + "daughters" : ["a_2+", "pi-"], + "grand_daughters" : [["rho0", "pi+"], []], + "models" : ["STS_CP", "TVS_PWAVE"], + "parameters" : [["0.4", "0.51e12", "1.0", "1.0", "0.0", "1.0", "0.0"], ["0.0", "0.0", "1.0", "0.0", "0.0", "0.0"]], + "do_conjugate_decay" : [true, true], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(a2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "mass", "title" : "m(a2pi1)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.4}, + {"variable" : "lifetime", "title" : "B0 lifetime", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "p", "title" : "p(a2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.8}, + {"variable" : "pSq", "title" : "pSq(a2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.5, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(a2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(rho0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(a2)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi1)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi2)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi2)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug1", "title" : "phi(pi2)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "STS_CP=TVS_PWAVE__Bd_a2pi,rhopi.root", + "reference" : "RefSTS_CP=TVS_PWAVE__Bd_a2pi,rhopi.root" +} diff --git a/test/jsonFiles/SVPHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_phigamma,Dsenue.json b/test/jsonFiles/SVPHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_phigamma,Dsenue.json new file mode 100644 index 0000000..6082e2d --- /dev/null +++ b/test/jsonFiles/SVPHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_phigamma,Dsenue.json @@ -0,0 +1,33 @@ +{ + "parent" : "Upsilon(5S)", + "daughters" : ["B_s0", "anti-B_s0"], + "grand_daughters" : [["phi", "gamma"], ["D_s+","e-","anti-nu_e"]], + "models" : ["VSS", "SVPHELCPMIX", "ISGW2"], + "parameters" : [[], ["1.0", "0.0", "1.0", "0.0", "0.025"], []], + "do_conjugate_decay" : [false, true, true], + "extras" : ["Define dm_incohMix_B_s0 17.8e12", "Define qoverp_incohMix_B_s0 1.0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVPHELCPMIX)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B_{s})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(anti-B_{s})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B_{s})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.3, "xmax" : 5.4}, + {"variable" : "mass", "title" : "m(anti-B_{s})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.3, "xmax" : 5.4}, + {"variable" : "mass_daug1", "title" : "m(#phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.15}, + {"variable" : "E_daug1", "title" : "E_{Lab}(#gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 4.0}, + {"variable" : "mass_daug2", "title" : "m(D_{s}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e^{-} anti-#nu_{e})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D_{s}^{+},e^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(#phi,#gamma)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(#phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 2.7}, + {"variable" : "p_daug1", "title" : "p(#gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 2.7}, + {"variable" : "p_daug2", "title" : "p(D_s^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(e^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(anti-#nu_{e})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5} + ], + "outfile" : "SVPHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_phigamma,Dsenue.root", + "reference" : "RefSVPHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_phigamma,Dsenue.root" +} diff --git a/test/jsonFiles/SVP_CP=VSS__Bd_Kst0gamma,Kpi.json b/test/jsonFiles/SVP_CP=VSS__Bd_Kst0gamma,Kpi.json new file mode 100644 index 0000000..1694b4e --- /dev/null +++ b/test/jsonFiles/SVP_CP=VSS__Bd_Kst0gamma,Kpi.json @@ -0,0 +1,35 @@ +{ + "parent" : "B0", + "daughters" : ["K*0", "gamma"], + "grand_daughters" : [["K+", "pi-"], []], + "models" : ["SVP_CP", "VSS"], + "parameters" : [["0.0", "0.472e12", "1.0", "1.0", "0.0", "1.0", "0.0"], [], []], + "do_conjugate_decay" : [true, true], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.5}, + {"variable" : "mass", "title" : "M(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 0.01}, + {"variable" : "p", "title" : "p(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.3, "xmax" : 2.7}, + {"variable" : "pSq", "title" : "p^{2}(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.5, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.3, "xmax" : 2.7}, + {"variable" : "pSq", "title" : "p^{2}(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.5, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{K}*^{0})", "d1" : 1, "d2" : 1, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{K}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{K}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{K}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi}^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi}^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi}^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SVP_CP__Bd_Kst0gamma,Kpi.root", + "reference" : "RefSVP_CP__Bd_Kst0gamma,Kpi.root" +} diff --git a/test/jsonFiles/SVP_HELAMP=VSS__Bu_Kstgamma,Kspi.json b/test/jsonFiles/SVP_HELAMP=VSS__Bu_Kstgamma,Kspi.json new file mode 100644 index 0000000..3e31980 --- /dev/null +++ b/test/jsonFiles/SVP_HELAMP=VSS__Bu_Kstgamma,Kspi.json @@ -0,0 +1,34 @@ +{ + "parent" : "B+", + "daughters" : ["K*+", "gamma"], + "grand_daughters" : [["K_S0", "pi+"], []], + "models" : ["SVP_HELAMP", "VSS", ""], + "parameters" : [["1.0", "0.0", "1.0", "0.0"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{K}*^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.5}, + {"variable" : "mass", "title" : "M(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 0.01}, + {"variable" : "p", "title" : "p(#it{K}*^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{K}*^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{K}*^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}*^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{K}*^{+})", "d1" : 1, "d2" : 1, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{K}*^{+})", "d1" : 1, "d2" : 0, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{K}*^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{K}^{0}_{S})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{K}^{0}_{S})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{K}^{0}_{S})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SVP_HELAMP=VSS__Bu_Kstgamma,Kspi.root", + "reference" : "RefSVP_HELAMP=VSS__Bu_Kstgamma,Kspi.root" +} diff --git a/test/jsonFiles/SVP_HELAMP=VVS_PWAVE__Bu_Kprime1gamma,Kstpi.json b/test/jsonFiles/SVP_HELAMP=VVS_PWAVE__Bu_Kprime1gamma,Kstpi.json new file mode 100644 index 0000000..5e4b5b8 --- /dev/null +++ b/test/jsonFiles/SVP_HELAMP=VVS_PWAVE__Bu_Kprime1gamma,Kstpi.json @@ -0,0 +1,34 @@ +{ + "parent" : "B+", + "daughters" : ["K'_1+", "gamma"], + "grand_daughters" : [["K*0", "pi+"], []], + "models" : ["SVP_HELAMP", "VVS_PWAVE", ""], + "parameters" : [["1.0", "0.0", "0.0", "0.0"], ["1.0", "0.0", "0.0", "0.0", "0.0", "0.0"], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 2.5}, + {"variable" : "mass", "title" : "M(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 0.01}, + {"variable" : "p", "title" : "p(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 1, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 0, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{K}_{1}^{+}')", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#it{#gamma})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{K}*^{0})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi}^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi}^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi}^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SVP_HELAMP=VVS_PWAVE__Bu_Kprime1gamma,Kstpi.root", + "reference" : "RefSVP_HELAMP=VVS_PWAVE__Bu_Kprime1gamma,Kstpi.root" +} diff --git a/test/jsonFiles/SVS=PHSP=VSS__Bu_D0rho,Kpi,pipi.json b/test/jsonFiles/SVS=PHSP=VSS__Bu_D0rho,Kpi,pipi.json new file mode 100644 index 0000000..4be863a --- /dev/null +++ b/test/jsonFiles/SVS=PHSP=VSS__Bu_D0rho,Kpi,pipi.json @@ -0,0 +1,37 @@ +{ + "parent" : "B+", + "daughters" : ["rho+", "anti-D0"], + "grand_daughters" : [["pi+", "pi0"], ["K+", "pi-"]], + "models" : ["SVS", "VSS", "PHSP"], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(SVS)", "d1" : 0, "d2" : 0, "nbins" : 110, "xmin" : 0.0, "xmax" : 1.1}, + {"variable" : "prob_daug1", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 110, "xmin" : 0.0, "xmax" : 1.1}, + {"variable" : "mass", "title" : "m(#rho^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.2, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(#bar{D}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.88}, + {"variable" : "cosTheta", "title" : "cosTheta(#rho^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#bar{D}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#rho^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#bar{D}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosHel", "title" : "cosHel(#pi^{+},#rho^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K^{+},#bar{D}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#pi^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "p_daug1", "title" : "p(#pi^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.5}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#pi^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#pi^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "p_daug2", "title" : "p(K^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(K^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(K^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180}, + {"variable" : "p_daug2", "title" : "p(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(#pi^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180} + ], + "outfile" : "SVS=PHSP=VSS__Bu_D0rho,Kpi,pipi.root", + "reference" : "RefSVS=PHSP=VSS__Bu_D0rho,Kpi,pipi.root" +} diff --git a/test/jsonFiles/SVS=SLL=VSS__Bs_chi_c0phi,mumu,KK.json b/test/jsonFiles/SVS=SLL=VSS__Bs_chi_c0phi,mumu,KK.json new file mode 100644 index 0000000..d126c2b --- /dev/null +++ b/test/jsonFiles/SVS=SLL=VSS__Bs_chi_c0phi,mumu,KK.json @@ -0,0 +1,36 @@ +{ + "parent" : "B_s0", + "daughters" : ["phi", "chi_c0"], + "grand_daughters" : [["K+", "K-"], ["mu+", "mu-"]], + "models" : ["SVS", "VSS", "SLL"], + "parameters" : [[], [], []], + "do_conjugate_decay" : [true, false, false], + "extras" : ["Define dm_incohMix_B_s0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "mass", "title" : "m(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "mass", "title" : "m(chi_c0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 3.0, "xmax" : 4.0}, + {"variable" : "p", "title" : "p(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.1, "xmax" : 1.5}, + {"variable" : "pSq", "title" : "pSq(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 2.5}, + {"variable" : "pz", "title" : "pz(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.5, "xmax" : 1.5}, + {"variable" : "cosHel", "title" : "cosHel(K)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(phi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(chi_c0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.2}, + {"variable" : "pLab_daug1", "title" : "pLab(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.2}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug1", "title" : "phi(K-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug2", "title" : "pLab(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "pLab_daug2", "title" : "pLab(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi_daug2", "title" : "phi(mu-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SVS=SLL=VSS__Bs_chi_c0phi,mumu,KK.root", + "reference" : "RefSVS=SLL=VSS__Bs_chi_c0phi,mumu,KK.root" +} diff --git a/test/jsonFiles/SVVHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_Jpsiphi,Dsenue.json b/test/jsonFiles/SVVHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_Jpsiphi,Dsenue.json new file mode 100644 index 0000000..d0cc42d --- /dev/null +++ b/test/jsonFiles/SVVHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_Jpsiphi,Dsenue.json @@ -0,0 +1,33 @@ +{ + "parent" : "Upsilon(5S)", + "daughters" : ["B_s0", "anti-B_s0"], + "grand_daughters" : [["J/psi", "phi"], ["D_s+","e-","anti-nu_e"]], + "models" : ["VSS", "SVVHELCPMIX", "ISGW2"], + "parameters" : [[], ["1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "8.15e24", "17.8e12", "65.78e10", "8.42e10", "0.0", "0.025"], []], + "do_conjugate_decay" : [false, true, true], + "extras" : ["Define dm_incohMix_B_s0 17.8e12", "Define qoverp_incohMix_B_s0 1.0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVVHELCPMIX)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.1}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B_{s})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(anti-B_{s})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B_{s})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.3, "xmax" : 5.4}, + {"variable" : "mass", "title" : "m(anti-B_{s})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.3, "xmax" : 5.4}, + {"variable" : "mass_daug1", "title" : "m(J/#psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "mass_daug1", "title" : "m(#phi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.95, "xmax" : 1.10}, + {"variable" : "mass_daug2", "title" : "m(D_{s}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e^{-} anti-#nu_{e})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D_{s}^{+},e^{-})", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(J/#psi,#phi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(J/#psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 1.65}, + {"variable" : "p_daug1", "title" : "p(#phi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 1.65}, + {"variable" : "p_daug2", "title" : "p(D_s^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(e^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(anti-#nu_{e})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5} + ], + "outfile" : "SVVHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_Jpsiphi,Dsenue.root", + "reference" : "RefSVVHELCPMIX=VSS=ISGW2__Upsilon5S_Bs_Jpsiphi,Dsenue.root" +} diff --git a/test/jsonFiles/SVV_CPLH=VLL=VSS__Bs0_Jpsiphi,ee,KK.json b/test/jsonFiles/SVV_CPLH=VLL=VSS__Bs0_Jpsiphi,ee,KK.json new file mode 100644 index 0000000..f0a2c99 --- /dev/null +++ b/test/jsonFiles/SVV_CPLH=VLL=VSS__Bs0_Jpsiphi,ee,KK.json @@ -0,0 +1,26 @@ +{ + "parent" : "B_s0", + "daughters" : ["J/psi", "phi"], + "grand_daughters" : [["e+", "e-"], ["K+", "K-"]], + "models" : ["SVV_CPLH", "VLL", "VSS"], + "parameters" : [["0.2", "2.0e12", "1.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0"], [], []], + "do_conjugate_decay" : [true, false, false], + "extras" : ["Define dm_incohMix_B_s0 0"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(SVV_CPLH)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(VLL)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(B0s)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.5}, + {"variable" : "mass", "title" : "m(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "mass", "title" : "m(phi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.8, "xmax" : 1.2}, + {"variable" : "cosHel", "title" : "cosHel(e)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "DecayAngle(e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "decayangle_daug2", "title" : "DecayAngle(K)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(e)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 1.8}, + {"variable" : "p_daug2", "title" : "p(K)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.3} + ], + "outfile" : "SVV_CPLH=VLL=VSS__Bs0_Jpsiphi,ee,KK.root", + "reference" : "RefSVV_CPLH=VLL=VSS__Bs0_Jpsiphi,ee,KK.root" +} diff --git a/test/jsonFiles/SVV_HELAMP=VLL=VSS__Bu_JpsiKst,mmKspi.json b/test/jsonFiles/SVV_HELAMP=VLL=VSS__Bu_JpsiKst,mmKspi.json new file mode 100644 index 0000000..160e02b --- /dev/null +++ b/test/jsonFiles/SVV_HELAMP=VLL=VSS__Bu_JpsiKst,mmKspi.json @@ -0,0 +1,35 @@ +{ + "parent" : "B+", + "daughters" : ["J/psi", "K*+"], + "grand_daughters" : [["mu+", "mu-"], ["K_S0", "pi+"]], + "models" : ["SVV_HELAMP", "VLL", "VSS"], + "parameters" : [["0.159", "1.563", "0.775", "0.0", "0.612", "2.712"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{J/#psi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.0966, "xmax" : 3.098}, + {"variable" : "mass", "title" : "M(#it{K}*^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(#it{J/#psi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{J/#psi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{J/#psi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{J/#psi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{K}*^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{J/#psi})", "d1" : 1, "d2" : 1, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{K}*^{+})", "d1" : 2, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{J/#psi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{K}*^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{J/#psi})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#it{K}*^{+})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#mu}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#mu}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#mu}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#mu}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#mu}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#mu}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SVV_HELAMP=VLL=VSS__Bu_JpsiKst,mmKspi.root", + "reference" : "RefSVV_HELAMP=VLL=VSS__Bu_JpsiKst,mmKspi.root" +} diff --git a/test/jsonFiles/SVV_HELAMP=VSS__Bu_rhorho0,pipi0pipi,Longitudinal.json b/test/jsonFiles/SVV_HELAMP=VSS__Bu_rhorho0,pipi0pipi,Longitudinal.json new file mode 100644 index 0000000..1147ee4 --- /dev/null +++ b/test/jsonFiles/SVV_HELAMP=VSS__Bu_rhorho0,pipi0pipi,Longitudinal.json @@ -0,0 +1,35 @@ +{ + "parent" : "B+", + "daughters" : ["rho+", "rho0"], + "grand_daughters" : [["pi+", "pi0"], ["pi+", "pi-"]], + "models" : ["SVV_HELAMP", "VSS", "VSS"], + "parameters" : [["0.0", "0.0", "1.0", "0.0", "0.0", "0.0"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "mass", "title" : "M(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{#rho}^{+})", "d1" : 1, "d2" : 1, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{#rho}^{0})", "d1" : 2, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SVV_HELAMP=VSS__Bd_rho0rho0,4pi,Longitudinal.root", + "reference" : "RefSVV_HELAMP=VSS__Bd_rho0rho0,4pi,Longitudinal.root" +} diff --git a/test/jsonFiles/SVV_HELAMP=VSS__Bu_rhorho0,pipi0pipi,Transverse.json b/test/jsonFiles/SVV_HELAMP=VSS__Bu_rhorho0,pipi0pipi,Transverse.json new file mode 100644 index 0000000..3e2d327 --- /dev/null +++ b/test/jsonFiles/SVV_HELAMP=VSS__Bu_rhorho0,pipi0pipi,Transverse.json @@ -0,0 +1,35 @@ +{ + "parent" : "B+", + "daughters" : ["rho+", "rho0"], + "grand_daughters" : [["pi+", "pi0"], ["pi+", "pi-"]], + "models" : ["SVV_HELAMP", "VSS", "VSS"], + "parameters" : [["1.0", "0.0", "0.0", "0.0", "1.0", "0.0"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "M(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "mass", "title" : "M(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.4, "xmax" : 1.5}, + {"variable" : "p", "title" : "p(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 3.0}, + {"variable" : "pSq", "title" : "p^{2}(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 7.0}, + {"variable" : "pz", "title" : "pz(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{#rho}^{+})", "d1" : 1, "d2" : 1, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHelDiTau", "title" : "cosHel(#it{#rho}^{0})", "d1" : 2, "d2" : 2, "nbins" : 50, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosAcoplanarityAngle", "title" : "cosAcopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "acoplanarityAngle", "title" : "acopl", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(#it{#rho}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#it{#rho}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi}^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(#it{#pi}^{0})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "SVV_HELAMP=VSS__Bd_rho0rho0,4pi,Transverse.root", + "reference" : "RefSVV_HELAMP=VSS__Bd_rho0rho0,4pi,Transverse.root" +} diff --git a/test/jsonFiles/THREEBODYPHSP=VLL=PHSP__Bu_JpsiKpi0,mumu,gammagamma.json b/test/jsonFiles/THREEBODYPHSP=VLL=PHSP__Bu_JpsiKpi0,mumu,gammagamma.json new file mode 100644 index 0000000..5f29a08 --- /dev/null +++ b/test/jsonFiles/THREEBODYPHSP=VLL=PHSP__Bu_JpsiKpi0,mumu,gammagamma.json @@ -0,0 +1,20 @@ +{ + "parent" : "B+", + "daughters" : ["J/psi", "K+", "pi0"], + "grand_daughters" : [["mu+", "mu-"], [], ["gamma", "gamma"]], + "models" : ["THREEBODYPHSP", "VLL", "", "PHSP"], + "parameters" : [["15.0", "22.0", "1.5", "4.5"], [], [], []], + "do_conjugate_decay" : [true, false, false, false], + "events" : 10000, + "histograms" : [ + {"variable" : "px", "title" : "px(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "py", "title" : "py(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "pz", "title" : "pz(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -3.0, "xmax" : 3.0}, + {"variable" : "px", "title" : "pxpy(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 50, "xmin" : -1.8, "xmax" : 1.8, "variableY" : "py", "d1Y" : 1, "d2Y" : 0, "nbinsY" : 50, "ymin" :-1.8, "ymax" : 1.8}, + {"variable" : "px", "title" : "pxpz(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 50, "xmin" : -1.8, "xmax" : 1.8, "variableY" : "pz", "d1Y" : 1, "d2Y" : 0, "nbinsY" : 50, "ymin" :-1.8, "ymax" : 1.8}, + {"variable" : "py", "title" : "pypz(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 50, "xmin" : -1.8, "xmax" : 1.8, "variableY" : "pz", "d1Y" : 1, "d2Y" : 0, "nbinsY" : 50, "ymin" :-1.8, "ymax" : 1.8}, + {"variable" : "massSq", "title" : "dalitz", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 12.5, "xmax" : 27.0, "variableY" : "massSq", "d1Y" : 2, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.35, "ymax" : 4.8} + ], + "outfile" : "THREEBODYPHSP__Bu_JpsiKpi0,mumu,gammagamma.root", + "reference" : "RefTHREEBODYPHSP__Bu_JpsiKpi0,mumu,gammagamma.root" +} diff --git a/test/jsonFiles/VECTORISR=VSS__Upsilon4S_psi4160gamma,DD.json b/test/jsonFiles/VECTORISR=VSS__Upsilon4S_psi4160gamma,DD.json new file mode 100644 index 0000000..f0803b2 --- /dev/null +++ b/test/jsonFiles/VECTORISR=VSS__Upsilon4S_psi4160gamma,DD.json @@ -0,0 +1,27 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["psi(4160)", "gamma"], + "grand_daughters" : [["D+", "D-"], []], + "models" : ["VECTORISR", "VSS", ""], + "parameters" : [["0.9", "0.9"], [], []], + "events" : 10000, + "histograms" : [ + {"variable" : "prob_daug1", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(Upsilon4S)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 10.5, "xmax" : 11.0}, + {"variable" : "mass", "title" : "m(psi4160)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.5, "xmax" : 5.5}, + {"variable" : "mass_daug1", "title" : "m(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.9}, + {"variable" : "mass_daug1", "title" : "m(D-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.9}, + {"variable" : "cosHel", "title" : "cosHel(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(D+,D-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p", "title" : "p(psi4160)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 5.0}, + {"variable" : "phi", "title" : "phi(psi4160)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(psi4160)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 5.0}, + {"variable" : "phi", "title" : "phi(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p_daug1", "title" : "p(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 2.0}, + {"variable" : "p_daug1", "title" : "p(D-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.6, "xmax" : 2.0} + ], + "outfile" : "VECTORISR=VSS__Upsilon4S_psi4160gamma,DD.root", + "reference" : "RefVECTORISR=VSS__Upsilon4S_psi4160gamma,DD.root" +} diff --git a/test/jsonFiles/VPHOTOVISRHI=VSS__psi4415_psi4160gamma,DD.json b/test/jsonFiles/VPHOTOVISRHI=VSS__psi4415_psi4160gamma,DD.json new file mode 100644 index 0000000..9397e38 --- /dev/null +++ b/test/jsonFiles/VPHOTOVISRHI=VSS__psi4415_psi4160gamma,DD.json @@ -0,0 +1,27 @@ +{ + "parent" : "psi(4415)", + "daughters" : ["psi(4160)", "gamma"], + "grand_daughters" : [["D+", "D-"], []], + "models" : ["VPHOTOVISRHI", "VSS", ""], + "parameters" : [["1.0"], [], []], + "extras" : ["noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(#psi(4415))", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 4.2, "xmax" : 5.4}, + {"variable" : "mass", "title" : "m(#psi(4160))", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 3.8, "xmax" : 5.4}, + {"variable" : "E", "title" : "E(#gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.55}, + {"variable" : "p", "title" : "p(#psi(4160))", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.55}, + {"variable" : "cosTheta", "title" : "cosTheta(#psi(4160))", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#gamma))", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "mass_daug1", "title" : "m(D^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "mass_daug1", "title" : "m(D^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "pLab_daug1", "title" : "pLab(D^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.2, "xmax" : 2.0}, + {"variable" : "pLab_daug1", "title" : "pLab(D^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.2, "xmax" : 2.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D^{+})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(D^{-})", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "VPHOTOVISRHI=VSS__psi4415_psi4160gamma,DD.root", + "reference" : "RefVPHOTOVISRHI=VSS__psi4415_psi4160gamma,DD.root" +} diff --git a/test/jsonFiles/VSP_PWAVE=PHSP__Dst_D0gamma,Kpi.json b/test/jsonFiles/VSP_PWAVE=PHSP__Dst_D0gamma,Kpi.json new file mode 100644 index 0000000..f0a5be3 --- /dev/null +++ b/test/jsonFiles/VSP_PWAVE=PHSP__Dst_D0gamma,Kpi.json @@ -0,0 +1,28 @@ +{ + "parent" : "D*0", + "daughters" : ["D0", "gamma"], + "grand_daughters" : [["K-", "pi+"],[]], + "models" : ["VSP_PWAVE", "PHSP", ""], + "parameters" : [[], [], []], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass", "title" : "m(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.95}, + {"variable" : "mass", "title" : "m(D0 gamma)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.1}, + {"variable" : "p", "title" : "p(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.2}, + {"variable" : "pz", "title" : "pz(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -0.15, "xmax" : 0.15}, + {"variable" : "cosHel", "title" : "cosHel(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(gamma)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.7, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.7, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "VSP_PWAVE__Dst_D0gamma,Kpi.root", + "reference" : "RefVSP_PWAVE__Dst_D0gamma,Kpi.root" +} diff --git a/test/jsonFiles/VSS=BTO2PI_CP_ISO=ISGW2__Upsilon4S_Bd_2pi,Denue.json b/test/jsonFiles/VSS=BTO2PI_CP_ISO=ISGW2__Upsilon4S_Bd_2pi,Denue.json new file mode 100644 index 0000000..ea7f073 --- /dev/null +++ b/test/jsonFiles/VSS=BTO2PI_CP_ISO=ISGW2__Upsilon4S_Bd_2pi,Denue.json @@ -0,0 +1,34 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["pi+", "pi-"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "BTO2PI_CP_ISO", "ISGW2"], + "parameters" : [[], ["0.4", "0.51e12", "0.8", "1.15", "0.8", "-1.15", "1.0", "1.15", "1.0", "-1.15"], []], + "extras" : ["Define dm_incohMix_B0 0"], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(BTO2PI_CP_ISO)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.1}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass_daug1", "title" : "m(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "mass_daug1", "title" : "m(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "mass_daug2", "title" : "m(D)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.90}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(pi+,pi-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D,e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(pi+,pi-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(D)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5} + ], + "outfile" : "VSS=BTO2PI_CP_ISO=ISGW2__Upsilon4S_Bd_2pi,Denue.root", + "reference" : "RefVSS=BTO2PI_CP_ISO=ISGW2__Upsilon4S_Bd_2pi,Denue.root" +} diff --git a/test/jsonFiles/VSS=BTOKPI_CP_ISO=ISGW2__Upsilon4S_Bd_Kpi,Denue.json b/test/jsonFiles/VSS=BTOKPI_CP_ISO=ISGW2__Upsilon4S_Bd_Kpi,Denue.json new file mode 100644 index 0000000..207a457 --- /dev/null +++ b/test/jsonFiles/VSS=BTOKPI_CP_ISO=ISGW2__Upsilon4S_Bd_Kpi,Denue.json @@ -0,0 +1,34 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["K+", "pi-"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "BTOKPI_CP_ISO", "ISGW2"], + "parameters" : [[], ["0.4", "0.51e12", "0.8", "1.48", "0.8", "-1.48", "0.8", "1.48", "0.8", "-1.48", "1.0", "1.48", "1.0", "-1.48"], []], + "extras" : ["Define dm_incohMix_B0 0"], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(BTO2PI_CP_ISO)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.1}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass_daug1", "title" : "m(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.45, "xmax" : 0.55}, + {"variable" : "mass_daug1", "title" : "m(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "mass_daug2", "title" : "m(D)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.90}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(K+,pi-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D,e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(K+,pi-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(K+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(D)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.5} + ], + "outfile" : "VSS=BTOKPI_CP_ISO=ISGW2__Upsilon4S_Bd_Kpi,Denue.root", + "reference" : "RefVSS=BTOKPI_CP_ISO=ISGW2__Upsilon4S_Bd_Kpi,Denue.root" +} diff --git a/test/jsonFiles/VSS=SSD_CP=HQET__Upsilon4S_Bd_Dpi,Dstenue.json b/test/jsonFiles/VSS=SSD_CP=HQET__Upsilon4S_Bd_Dpi,Dstenue.json new file mode 100644 index 0000000..a5c1d3c --- /dev/null +++ b/test/jsonFiles/VSS=SSD_CP=HQET__Upsilon4S_Bd_Dpi,Dstenue.json @@ -0,0 +1,31 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["D-", "pi+"], ["D*+","e-","anti-nu_e"]], + "models" : ["VSS", "SSD_CP", "HQET"], + "parameters" : [[], ["0.472e12", "0.0", "1.0", "-0.85", "1.0", "0.0", "0.6", "-0.5", "0.6", "1.5", "1.0", "0.0"], ["0.91", "1.18", "0.72"]], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SSD_CP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(HQET)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug1", "title" : "m(D-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.9}, + {"variable" : "mass_daug1", "title" : "m(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.3}, + {"variable" : "mass_daug2", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.2}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D*+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p_daug1", "title" : "p(D-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.0, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SSD_CP=HQET__Upsilon4S_Bd_Dpi,Dstenue.root", + "reference" : "RefVSS=SSD_CP=HQET__Upsilon4S_Bd_Dpi,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SSS_CP=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json b/test/jsonFiles/VSS=SSS_CP=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json new file mode 100644 index 0000000..2008a08 --- /dev/null +++ b/test/jsonFiles/VSS=SSS_CP=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json @@ -0,0 +1,29 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["pi+","pi-"], ["D*+","e-","anti-nu_e"]], + "models" : ["VSS", "SSS_CP", "ISGW2"], + "parameters" : [[], ["0.4", "0.51e12", "1.0", "1.0", "0.0", "1.0", "0.0"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SSS_CP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug2", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.2}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D*+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p_daug1", "title" : "p(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SSS_CP=ISGW2__Upsilon4S_Bd_pipi,Dstenue.root", + "reference" : "RefVSS=SSS_CP=ISGW2__Upsilon4S_Bd_pipi,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SSS_CPT=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json b/test/jsonFiles/VSS=SSS_CPT=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json new file mode 100644 index 0000000..13fac83 --- /dev/null +++ b/test/jsonFiles/VSS=SSS_CPT=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json @@ -0,0 +1,29 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["pi+","pi-"], ["D*+","e-","anti-nu_e"]], + "models" : ["VSS", "SSS_CPT", "ISGW2"], + "parameters" : [[], ["0.0", "0.51e12", "1.0", "0.0", "1.0", "0.0", "0.1", "-0.4"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SSS_CPT)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug2", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.2}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D*+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p_daug1", "title" : "p(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SSS_CPT=ISGW2__Upsilon4S_Bd_pipi,Dstenue.root", + "reference" : "RefVSS=SSS_CPT=ISGW2__Upsilon4S_Bd_pipi,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SSS_CP_PNG=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json b/test/jsonFiles/VSS=SSS_CP_PNG=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json new file mode 100644 index 0000000..be71939 --- /dev/null +++ b/test/jsonFiles/VSS=SSS_CP_PNG=ISGW2__Upsilon4S_Bd_pipi,Dstenue.json @@ -0,0 +1,29 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["pi+","pi-"], ["D*+","e-","anti-nu_e"]], + "models" : ["VSS", "SSS_CP_PNG", "ISGW2"], + "parameters" : [[], ["0.4", "1.2", "0.1", "0.51e12", "1.0", "1.0", "0.2"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SSS_CP_PNG)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug2", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.2}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D*+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p_daug1", "title" : "p(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SSS_CP_PNG=ISGW2__Upsilon4S_Bd_pipi,Dstenue.root", + "reference" : "RefVSS=SSS_CP_PNG=ISGW2__Upsilon4S_Bd_pipi,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SVS_CP=ISGW2__Upsilon4S_Bd_JpsiK0,Dstenue.json b/test/jsonFiles/VSS=SVS_CP=ISGW2__Upsilon4S_Bd_JpsiK0,Dstenue.json new file mode 100644 index 0000000..dd6e736 --- /dev/null +++ b/test/jsonFiles/VSS=SVS_CP=ISGW2__Upsilon4S_Bd_JpsiK0,Dstenue.json @@ -0,0 +1,31 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["J/psi", "K0"], ["D*+","e-","anti-nu_e"]], + "models" : ["VSS", "SVS_CP", "ISGW2"], + "parameters" : [[], ["0.4", "0.51e12", "1.0", "1.0", "0.0", "1.0", "0.0"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVS_CP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug1", "title" : "m(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "mass_daug1", "title" : "m(K0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass_daug2", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.2}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D*+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p_daug1", "title" : "p(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.0}, + {"variable" : "p_daug1", "title" : "p(K0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.5, "xmax" : 2.0}, + {"variable" : "p_daug2", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SVS_CP=ISGW2__Upsilon4S_Bd_JpsiK0,Dstenue.root", + "reference" : "RefVSS=SVS_CP=ISGW2__Upsilon4S_Bd_JpsiK0,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SVS_CPLH=ISGW2__Upsilon4S_Bd_JpsiK0s,Denue.json b/test/jsonFiles/VSS=SVS_CPLH=ISGW2__Upsilon4S_Bd_JpsiK0s,Denue.json new file mode 100644 index 0000000..73bdcd3 --- /dev/null +++ b/test/jsonFiles/VSS=SVS_CPLH=ISGW2__Upsilon4S_Bd_JpsiK0s,Denue.json @@ -0,0 +1,31 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["J/psi", "K_S0"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "SVS_CPLH", "ISGW2"], + "parameters" : [[], ["0.472e12", "0.2", "1.0", "-0.77", "1.0", "0.0", "1.0", "0.0"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVS_CPLH)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug1", "title" : "m(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "mass_daug1", "title" : "m(K_S0)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass_daug2", "title" : "m(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.0}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(J/psi,K_S0)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "DecayAngle(Jpsi,K_S0)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug2", "title" : "p(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SVS_CPLH=ISGW2__Upsilon4S_Bd_JpsiK0s,Denue.root", + "reference" : "RefVSS=SVS_CPLH=ISGW2__Upsilon4S_Bd_JpsiK0s,Denue.root" +} diff --git a/test/jsonFiles/VSS=SVS_CP_ISO=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.json b/test/jsonFiles/VSS=SVS_CP_ISO=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.json new file mode 100644 index 0000000..b59a5c2 --- /dev/null +++ b/test/jsonFiles/VSS=SVS_CP_ISO=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.json @@ -0,0 +1,31 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["a_1-", "pi+"], ["D*+","e-","anti-nu_e"]], + "models" : ["VSS", "SVS_CP_ISO", "ISGW2"], + "parameters" : [[], ["0.4", "0.51e12", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0", "1.0", "1.2", "3.0", "-1.2", "3.0", "1.2", "1.0", "-1.2"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVS_CP_ISO)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug1", "title" : "m(a1-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.05, "xmax" : 5.0}, + {"variable" : "mass_daug1", "title" : "m(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "mass_daug2", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.2}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D*+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "p_daug1", "title" : "p(a1-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SVS_CP_ISO=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.root", + "reference" : "RefVSS=SVS_CP_ISO=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SVS_NONCPEIGEN=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.json b/test/jsonFiles/VSS=SVS_NONCPEIGEN=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.json new file mode 100644 index 0000000..8ce126a --- /dev/null +++ b/test/jsonFiles/VSS=SVS_NONCPEIGEN=ISGW2__Upsilon4S_Bd_a1pi,Dstenue.json @@ -0,0 +1,32 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["a_1-", "pi+"], ["D*+","e-","anti-nu_e"]], + "models" : ["VSS", "SVS_NONCPEIGEN", "ISGW2"], + "parameters" : [[], ["0.35", "0.51e12", "1.0", "1.0", "0.0", "3.0", "0.0", "3.0", "0.0", "1.0", "0.0"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVS_NONCPEIGEN)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug1", "title" : "m(a_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 4.0}, + {"variable" : "mass_daug1", "title" : "m(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.3}, + {"variable" : "mass_daug2", "title" : "m(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.2}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D*+,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "DecayAngle(a1, pi)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 200.0}, + {"variable" : "p_daug1", "title" : "p(a_1)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug1", "title" : "p(pi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(D*+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SSD_CP=HQET__Upsilon4S_Bd_Dpi,Dstenue.root", + "reference" : "RefVSS=SSD_CP=HQET__Upsilon4S_Bd_Dpi,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SVV_CP=ISGW2__Upsilon4S_Bd_JpsiKst,Denue.json b/test/jsonFiles/VSS=SVV_CP=ISGW2__Upsilon4S_Bd_JpsiKst,Denue.json new file mode 100644 index 0000000..33dcffb --- /dev/null +++ b/test/jsonFiles/VSS=SVV_CP=ISGW2__Upsilon4S_Bd_JpsiKst,Denue.json @@ -0,0 +1,32 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["J/psi", "K*0"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "SVV_CP", "ISGW2"], + "parameters" : [[], ["0.4", "0.51e12", "1.0", "1.0", "0.0", "1.0", "0.0", "1.0", "0.0"], []], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVV_CP)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.2, "xmax" : 5.3}, + {"variable" : "mass_daug1", "title" : "m(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 2.5, "xmax" : 3.5}, + {"variable" : "mass_daug1", "title" : "m(K*)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.5, "xmax" : 1.5}, + {"variable" : "mass_daug2", "title" : "m(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.0}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D+,e-)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "DecayAngle(Jpsi,K*0)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(J/psi)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.1, "xmax" : 1.7}, + {"variable" : "p_daug1", "title" : "p(K*)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.1, "xmax" : 1.7}, + {"variable" : "p_daug2", "title" : "p(D+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e-)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SVV_CP=ISGW2__Upsilon4S_Bd_JpsiKst,Dstenue.root", + "reference" : "RefVSS=SVV_CP=ISGW2__Upsilon4S_Bd_JpsiKst,Dstenue.root" +} diff --git a/test/jsonFiles/VSS=SVV_NONCPEIGEN=ISGW2__Upsilon4S_Bd_Dstrho,Denue.json b/test/jsonFiles/VSS=SVV_NONCPEIGEN=ISGW2__Upsilon4S_Bd_Dstrho,Denue.json new file mode 100644 index 0000000..2b2db2c --- /dev/null +++ b/test/jsonFiles/VSS=SVV_NONCPEIGEN=ISGW2__Upsilon4S_Bd_Dstrho,Denue.json @@ -0,0 +1,34 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "grand_daughters" : [["D*-", "rho+"], ["D+","e-","anti-nu_e"]], + "models" : ["VSS", "SVV_NONCPEIGEN", "ISGW2"], + "parameters" : [[], ["0.51e12", "0.4", "1.15", "0.152", "1.48", "0.936", "0.0", "0.317", "0.19", "0.00152", "1.48", "0.00936", "0.0", "0.00317", "0.19"], []], + "extras" : ["Define dm_incohMix_B0 0"], + "do_conjugate_decay" : [false, true, true], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob(VSS)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug1", "title" : "Prob(SVV_NONCPEIGEN)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "prob_daug2", "title" : "Prob(ISGW2)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "lifetime", "title" : "tau(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "lifetime", "title" : "tau(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 20.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "mass", "title" : "m(B0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass", "title" : "m(B0b)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 5.27, "xmax" : 5.29}, + {"variable" : "mass_daug1", "title" : "m(D*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.9, "xmax" : 2.1}, + {"variable" : "mass_daug1", "title" : "m(rho)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.2, "xmax" : 2.0}, + {"variable" : "mass_daug2", "title" : "m(D)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.85, "xmax" : 1.90}, + {"variable" : "pSumSq_daug2", "title" : "qSq(e- anti-nu_e)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "cosHel_daug1", "title" : "cosHel(D*,rho)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel_daug2", "title" : "cosHel(D,e)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "decayangle_daug1", "title" : "decayAngle(D*, rho)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 0.0, "xmax" : 180.0}, + {"variable" : "p_daug1", "title" : "p(D*)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 2.5}, + {"variable" : "p_daug1", "title" : "p(rho)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 2.5}, + {"variable" : "p_daug2", "title" : "p(D)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(e)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p_daug2", "title" : "p(anti-nu_e)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0} + ], + "outfile" : "VSS=SVV_NONCPEIGEN=ISGW2__Upsilon4S_Bd_Dstrho,Denue.root", + "reference" : "RefVSS=SVV_NONCPEIGEN=ISGW2__Upsilon4S_Bd_Dstrho,Denue.root" +} diff --git a/test/jsonFiles/VSS_BMIX__Ups4S,Bd.json b/test/jsonFiles/VSS_BMIX__Ups4S,Bd.json new file mode 100644 index 0000000..943b641 --- /dev/null +++ b/test/jsonFiles/VSS_BMIX__Ups4S,Bd.json @@ -0,0 +1,17 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0", "B0", "anti-B0"], + "models" : ["VSS_BMIX"], + "parameters" : [["0.474e12", "0.5", "0.8", "0.0"]], + "events" : 10000, + "histograms" : [ + {"variable" : "id", "title" : "StdHep ID1", "d1" : 1, "d2" : 0, "nbins" : 2, "xmin" : -600.0, "xmax" : 600.0}, + {"variable" : "id", "title" : "StdHep ID2", "d1" : 2, "d2" : 0, "nbins" : 2, "xmin" : -600.0, "xmax" : 600.0}, + {"variable" : "lifetime", "title" : "tau1", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "lifetime", "title" : "tau2", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0} + ], + "outfile" : "VSS_BMIX__Ups4S,Bd.root", + "reference" : "RefVSS_BMIX__Ups4S,Bd.root" +} diff --git a/test/jsonFiles/VSS_MIX__Ups4S,Bd.json b/test/jsonFiles/VSS_MIX__Ups4S,Bd.json new file mode 100644 index 0000000..6b3f553 --- /dev/null +++ b/test/jsonFiles/VSS_MIX__Ups4S,Bd.json @@ -0,0 +1,17 @@ +{ + "parent" : "Upsilon(4S)", + "daughters" : ["B0", "anti-B0"], + "models" : ["VSS_MIX"], + "parameters" : [["0.474e12"]], + "events" : 10000, + "histograms" : [ + {"variable" : "id", "title" : "StdHep ID1", "d1" : 1, "d2" : 0, "nbins" : 2, "xmin" : -600.0, "xmax" : 600.0}, + {"variable" : "id", "title" : "StdHep ID2", "d1" : 2, "d2" : 0, "nbins" : 2, "xmin" : -600.0, "xmax" : 600.0}, + {"variable" : "lifetime", "title" : "tau1", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "lifetime", "title" : "tau2", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 12.0}, + {"variable" : "deltaT", "title" : "deltaT", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -12.0, "xmax" : 12.0}, + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0} + ], + "outfile" : "VSS_MIX__Ups4S,Bd.root", + "reference" : "RefVSS_MIX__Ups4S,Bd.root" +} diff --git a/test/jsonFiles/VTOSLL=PHSP__Dst0_D0ee,Kpi.json b/test/jsonFiles/VTOSLL=PHSP__Dst0_D0ee,Kpi.json new file mode 100644 index 0000000..0c5828e --- /dev/null +++ b/test/jsonFiles/VTOSLL=PHSP__Dst0_D0ee,Kpi.json @@ -0,0 +1,35 @@ +{ + "parent" : "D*0", + "daughters" : ["D0", "e+", "e-"], + "grand_daughters" : [["K-", "pi+"], [], []], + "models" : ["VTOSLL", "PHSP", ""], + "parameters" : [[], [], []], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "mass", "title" : "m(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.8, "xmax" : 1.95}, + {"variable" : "mass", "title" : "m(D0 e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.1}, + {"variable" : "mass", "title" : "m(D0 e-)", "d1" : 1, "d2" : 3, "nbins" : 100, "xmin" : 1.8, "xmax" : 2.1}, + {"variable" : "mass", "title" : "m(e+e-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.15}, + {"variable" : "pSumSq", "title" : "qSq(e+ e-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.02}, + {"variable" : "p", "title" : "p(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.2}, + {"variable" : "pSq", "title" : "pSq(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.02}, + {"variable" : "pz", "title" : "pz(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -0.15, "xmax" : 0.15}, + {"variable" : "cosHel", "title" : "cosHel(D0,e+)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(e+,e-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(e-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(D0)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "pLab_daug1", "title" : "pLab(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.7, "xmax" : 1.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.7, "xmax" : 1.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(K-)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "VTOSLL=PHSP__Dst0_D0ee,Kpi.root", + "reference" : "RefVTOSLL=PHSP__Dst0_D0ee,Kpi.root" +} diff --git a/test/jsonFiles/VUBHYBRID__Xumunu.json b/test/jsonFiles/VUBHYBRID__Xumunu.json new file mode 100644 index 0000000..545107c --- /dev/null +++ b/test/jsonFiles/VUBHYBRID__Xumunu.json @@ -0,0 +1,29 @@ +{ + "parent" : "B0", + "daughters" : ["Xu-", "mu+", "nu_mu"], + "models" : ["VUBHYBRID"], + "parameters" : [["4.8", "1.29", "0.22"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(#mu #nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(X_{u},#mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#mu,#nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(X_{u} #mu) vs m^{2}(#mu #nu_{#mu})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq", "d1Y" : 2, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 25.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + + ], + "outfile" : "VUBHYBRID__Xumunu.root", + "reference" : "RefVUBHYBRID__Xumunu.root" +} diff --git a/test/jsonFiles/VUB_BLNPHYBRID__Xumunu.json b/test/jsonFiles/VUB_BLNPHYBRID__Xumunu.json new file mode 100644 index 0000000..8ab9b1d --- /dev/null +++ b/test/jsonFiles/VUB_BLNPHYBRID__Xumunu.json @@ -0,0 +1,29 @@ +{ + "parent" : "B0", + "daughters" : ["Xu-", "mu+", "nu_mu"], + "models" : ["VUB_BLNPHYBRID"], + "parameters" : [["3.95", "0.72", "0.5", "1.5", "1.5", "1.0", "1.0", "1.0", "1.0", "1.0"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(#mu #nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(X_{u},#mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#mu,#nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(X_{u} #mu) vs m^{2}(#mu #nu_{#mu})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq", "d1Y" : 2, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + + ], + "outfile" : "VUB_BLNPHYBRID__Xumunu.root", + "reference" : "RefVUB_BLNPHYBRID__Xumunu.root" +} diff --git a/test/jsonFiles/VUB_BLNP__Xumunu.json b/test/jsonFiles/VUB_BLNP__Xumunu.json new file mode 100644 index 0000000..6c92e99 --- /dev/null +++ b/test/jsonFiles/VUB_BLNP__Xumunu.json @@ -0,0 +1,29 @@ +{ + "parent" : "B0", + "daughters" : ["Xu-", "mu+", "nu_mu"], + "models" : ["VUB_BLNP"], + "parameters" : [["3.95", "0.72", "0.5", "1.5", "1.5", "1.0", "1.0", "1.0", "1.0", "1.0"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(#mu #nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(X_{u},#mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#mu,#nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(X_{u} #mu) vs m^{2}(#mu #nu_{#mu})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq", "d1Y" : 2, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + + ], + "outfile" : "VUB_BLNP__Xumunu.root", + "reference" : "RefVUB_BLNP__Xumunu.root" +} diff --git a/test/jsonFiles/VUB_NLO__Xumunu.json b/test/jsonFiles/VUB_NLO__Xumunu.json new file mode 100644 index 0000000..d355ee4 --- /dev/null +++ b/test/jsonFiles/VUB_NLO__Xumunu.json @@ -0,0 +1,29 @@ +{ + "parent" : "B0", + "daughters" : ["Xu-", "mu+", "nu_mu"], + "models" : ["VUB_NLO"], + "parameters" : [["4.8", "1.29", "1.0", "0.0", "1.0", "1.0", "0.3", "1.0"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(#mu #nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(X_{u},#mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#mu,#nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(X_{u} #mu) vs m^{2}(#mu #nu_{#mu})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq", "d1Y" : 2, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 30.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + + ], + "outfile" : "VUB_NLO__Xumunu.root", + "reference" : "RefVUB_NLO__Xumunu.root" +} diff --git a/test/jsonFiles/VUB__Xumunu.json b/test/jsonFiles/VUB__Xumunu.json new file mode 100644 index 0000000..ae3d868 --- /dev/null +++ b/test/jsonFiles/VUB__Xumunu.json @@ -0,0 +1,29 @@ +{ + "parent" : "B0", + "daughters" : ["Xu-", "mu+", "nu_mu"], + "models" : ["VUB"], + "parameters" : [["4.8", "1.29", "0.22", "1.0", "0.3", "1.0"]], + "extras" : ["Define dm_incohMix_B0 0", "noPhotos"], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "Prob", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.2}, + {"variable" : "mass", "title" : "m(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 5.0}, + {"variable" : "pSumSq", "title" : "qSq(#mu #nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 25.0}, + {"variable" : "p", "title" : "p(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "p", "title" : "p(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 3.0}, + {"variable" : "cosHel", "title" : "cosHel(X_{u},#mu)", "d1" : 1, "d2" : 2, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosHel", "title" : "cosHel(#mu,#nu_{#mu})", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(X_{u})", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#mu)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(#nu_{#mu})", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "massSq", "title" : "Dalitz m^{2}(X_{u} #mu) vs m^{2}(#mu #nu_{#mu})", "d1" : 1, "d2" : 2, "nbins" : 50, "xmin" : 0.0, "xmax" : 30.0, "variableY" : "massSq", "d1Y" : 2, "d2Y" : 3, "nbinsY" : 50, "ymin" : 0.0, "ymax" : 25.0}, + {"variable" : "mPrime", "title" : "sqDalitz", "d1" : 1, "d2" : 2, "nbins" : 25, "xmin" : 0.0, "xmax" : 1.00, "variableY" : "thetaPrime", "d1Y" : 1, "d2Y" : 2, "nbinsY" : 25, "ymin" : 0.0, "ymax" : 1.0} + + ], + "outfile" : "VUB__Xumunu.root", + "reference" : "RefVUB__Xumunu.root" +} diff --git a/test/jsonFiles/X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiOmega,mumu,pipi.json b/test/jsonFiles/X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiOmega,mumu,pipi.json new file mode 100644 index 0000000..17b4572 --- /dev/null +++ b/test/jsonFiles/X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiOmega,mumu,pipi.json @@ -0,0 +1,22 @@ +{ + "parent" : "X_2(3872)", + "daughters" : ["omega", "J/psi"], + "grand_daughters" : [["pi+", "pi-"], ["mu+", "mu-"]], + "models" : ["X38722-+_PSI_GAMMA", "VSS", "VLL"], + "parameters" : [[], [], []], + "events" : 5000, + "histograms" : [ + {"variable" : "prob", "title" : "probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 20 }, + {"variable" : "mass", "title" : "m(omega)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.3, "xmax" : 0.8}, + {"variable" : "p", "title" : "p(J/psi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.65}, + {"variable" : "pLab_daug2", "title" : "pLab(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.6}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiOmega,mumu,pipi.root", + "reference" : "RefX38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiOmega,mumu,pipi.root" +} + diff --git a/test/jsonFiles/X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiRho0,mumu,pipi.json b/test/jsonFiles/X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiRho0,mumu,pipi.json new file mode 100644 index 0000000..9d89469 --- /dev/null +++ b/test/jsonFiles/X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiRho0,mumu,pipi.json @@ -0,0 +1,22 @@ +{ + "parent" : "X_2(3872)", + "daughters" : ["rho0", "J/psi"], + "grand_daughters" : [["pi+", "pi-"], ["mu+", "mu-"]], + "models" : ["X38722-+_PSI_GAMMA", "VSS", "VLL"], + "parameters" : [[], [], []], + "events" : 5000, + "histograms" : [ + {"variable" : "prob", "title" : "probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 80 }, + {"variable" : "mass", "title" : "m(rho)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.3, "xmax" : 0.8}, + {"variable" : "p", "title" : "p(J/psi)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.65}, + {"variable" : "pLab_daug2", "title" : "pLab(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 2.0}, + {"variable" : "pLab_daug1", "title" : "pLab(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 0.6}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta_daug1", "title" : "cosTheta(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug1", "title" : "phi(pi+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "X38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiRho0,mumu,pipi.root", + "reference" : "RefX38722-+_PSI_GAMMA=VLL=VSS__X3872_JpsiRho0,mumu,pipi.root" +} + diff --git a/test/jsonFiles/X38722-+_PSI_GAMMA=VLL__X3872_JpsiGamma,mumu.json b/test/jsonFiles/X38722-+_PSI_GAMMA=VLL__X3872_JpsiGamma,mumu.json new file mode 100644 index 0000000..23430c6 --- /dev/null +++ b/test/jsonFiles/X38722-+_PSI_GAMMA=VLL__X3872_JpsiGamma,mumu.json @@ -0,0 +1,17 @@ +{ + "parent" : "X_2(3872)", + "daughters" : ["gamma", "J/psi"], + "grand_daughters" : [[], ["mu+", "mu-"]], + "models" : ["X38722-+_PSI_GAMMA", "", "VLL"], + "parameters" : [[], [], []], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 2.5 }, + {"variable" : "pLab_daug2", "title" : "pLab(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 1.0, "xmax" : 2.0}, + {"variable" : "cosTheta_daug2", "title" : "cosTheta(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi_daug2", "title" : "phi(mu+)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "cosTheta", "title" : "cosTheta(gamma)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0} + ], + "outfile" : "X38722-+_PSI_GAMMA=VLL__X3872_JpsiGamma,mumu.root", + "reference" : "RefX38722-+_PSI_GAMMA=VLL__X3872_JpsiGamma,mumu.root" +} diff --git a/test/jsonFiles/Y3STOY1SPIPIMOXHAY__Upsilon3S_Upsilon2pi.json b/test/jsonFiles/Y3STOY1SPIPIMOXHAY__Upsilon3S_Upsilon2pi.json new file mode 100644 index 0000000..4669533 --- /dev/null +++ b/test/jsonFiles/Y3STOY1SPIPIMOXHAY__Upsilon3S_Upsilon2pi.json @@ -0,0 +1,26 @@ +{ + "parent" : "Upsilon(3S)", + "daughters" : ["Upsilon", "pi+", "pi-"], + "models" : ["Y3STOY1SPIPIMOXHAY"], + "parameters" : [["0.2196", "0.2983"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(Upsilon3S)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 10.0, "xmax" : 11.0}, + {"variable" : "mass", "title" : "m(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 9.0, "xmax" : 10.0}, + {"variable" : "mass", "title" : "m(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "mass", "title" : "m(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "p", "title" : "p(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSumSq", "title" : "qSq(pi+pi-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "Y3STOY1SPIPIMOXHAY__Upsilon3S_Upsilon2pi.root", + "reference" : "RefY3STOY1SPIPIMOXHAY__Upsilon3S_Upsilon2pi.root" +} diff --git a/test/jsonFiles/YMSTOYNSPIPICLEO__Upsilon3S_Upsilon2pi.json b/test/jsonFiles/YMSTOYNSPIPICLEO__Upsilon3S_Upsilon2pi.json new file mode 100644 index 0000000..23d74e4 --- /dev/null +++ b/test/jsonFiles/YMSTOYNSPIPICLEO__Upsilon3S_Upsilon2pi.json @@ -0,0 +1,26 @@ +{ + "parent" : "Upsilon(3S)", + "daughters" : ["Upsilon", "pi+", "pi-"], + "models" : ["YMSTOYNSPIPICLEO"], + "parameters" : [["2.523", "1.189"]], + "events" : 10000, + "histograms" : [ + {"variable" : "prob", "title" : "probability", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 0, "xmax" : 1.0}, + {"variable" : "parMass", "title" : "m(Upsilon3S)", "d1" : 0, "d2" : 0, "nbins" : 100, "xmin" : 10.0, "xmax" : 11.0}, + {"variable" : "mass", "title" : "m(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 9.0, "xmax" : 10.0}, + {"variable" : "mass", "title" : "m(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "mass", "title" : "m(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.13, "xmax" : 0.15}, + {"variable" : "p", "title" : "p(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "p", "title" : "p(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "pSumSq", "title" : "qSq(pi+pi-)", "d1" : 2, "d2" : 3, "nbins" : 100, "xmin" : 0.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "cosTheta", "title" : "cosTheta(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -1.0, "xmax" : 1.0}, + {"variable" : "phi", "title" : "phi(Upsilon)", "d1" : 1, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(pi+)", "d1" : 2, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0}, + {"variable" : "phi", "title" : "phi(pi-)", "d1" : 3, "d2" : 0, "nbins" : 100, "xmin" : -180.0, "xmax" : 180.0} + ], + "outfile" : "YMSTOYNSPIPICLEO__Upsilon3S_Upsilon2pi.root", + "reference" : "RefYMSTOYNSPIPICLEO__Upsilon3S_Upsilon2pi.root" +} diff --git a/test/makeModelsJson b/test/makeModelsJson new file mode 100644 index 0000000..a983a09 --- /dev/null +++ b/test/makeModelsJson @@ -0,0 +1,67 @@ +#!/bin/bash + +######################################################################## +# Copyright 1998-2022 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 . # +######################################################################## + +# Script to find all active decay models and create a JSON file that contains fields for: +# class name, header file name, source file name +# for each model, keyed by the model name + +if [ $# -ne 1 ] +then + echo "Usage: makeModelsJson " + exit 1 +fi + +sourceDir=$1 + +declare -a modelClasses + +cd $sourceDir + +modelClasses=(`grep registerModel src/EvtGenModels/EvtModelReg.cpp | grep " new " | awk '{print $3}' | sed -e 's/[\(\)]\{1,2\}//' | sort`) + +declare -i nModels=${#modelClasses[@]} +declare -i lastIndex=$nModels-1 + +echo "{" +for i in `seq 0 $lastIndex` +do + modelClass=${modelClasses[$i]} + modelHeaderFile=`grep -rl "\" EvtGenModels` + modelSourceFile="src/`echo $modelHeaderFile | sed -e 's/\.hh/.cpp/'`" + modelName=`grep getName $modelHeaderFile | grep " return " | awk -F'"' '{print $2}'` + if [ "x$modelName" == "x" ] + then + modelName=`grep -A3 "${modelClass}::getName" $modelSourceFile | grep " return " | awk -F'"' '{print $2}'` + fi + + echo " \"${modelName}\" : {" + echo " \"class\" : \"${modelClass}\"," + echo " \"header\" : \"${modelHeaderFile}\"," + echo " \"source\" : \"${modelSourceFile}\"" + if [ $i -eq $lastIndex ] + then + echo " }" + else + echo " }," + fi + +done +echo "}" diff --git a/test/makeSrcDepsJson b/test/makeSrcDepsJson new file mode 100644 index 0000000..50589b9 --- /dev/null +++ b/test/makeSrcDepsJson @@ -0,0 +1,103 @@ +#!/bin/bash + +######################################################################## +# Copyright 1998-2022 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 . # +######################################################################## + +# Script to find the dependencies for all source files and create a JSON file containing that information + +if [ $# -ne 2 ] +then + echo "Usage: makeDepsJson " + exit 1 +fi +sourceDir=$1 +buildDir=$2 + +# get a list of all the object files that are built in the EvtGen lib +declare -a objFiles=(`awk -F: '{print $1}' $buildDir/src/CMakeFiles/objlib.dir/depend.make | grep '\.cpp\.o$' | sort -u`) + +declare -i nObjFiles=${#objFiles[@]} +declare -i lastIndex=$nObjFiles-1 + +echo "{" +for i in `seq 0 $lastIndex` +do + objFile=${objFiles[$i]} + srcFile=`echo $objFile | sed -e 's%CMakeFiles/objlib\.dir/%%' -e 's%\.o$%%'` + + declare -a depFiles=(`grep "${objFile}:" $buildDir/src/CMakeFiles/objlib.dir/depend.make | awk '{print $NF}' | sed -e "s%$sourceDir[/]\?%%" -e "s%\.\./%%"`) + declare -i nDepFiles=${#depFiles[@]} + declare -i lastDep=$nDepFiles-1 + + echo " \"${srcFile}\" : [" + for j in `seq 0 $lastDep` + do + depFile=${depFiles[$j]} + + if [[ $depFile =~ \.hh$ ]] + then + dephdr=$depFile + depsrc="src/`echo $depFile | sed -e 's/\.hh/.cpp/'`" + if [ ! -e $sourceDir/$depsrc ] + then + depsrc="" + fi + elif [[ $depFile =~ \.cpp$ ]] + then + depsrc=$depFile + dephdr=`echo $depFile | sed -e 's%src/%%' -e 's/\.cpp/.hh/'` + if [ ! -e $sourceDir/$dephdr ] + then + dephdr="" + fi + fi + + if [ $j -eq $lastDep ] + then + if [ "x$dephdr" != "x" -a "x$depsrc" != "x" ] + then + echo " \"${dephdr}\"," + echo " \"${depsrc}\"" + elif [ "x$dephdr" != "x" ] + then + echo " \"${dephdr}\"" + elif [ "x$depsrc" != "x" ] + then + echo " \"${depsrc}\"" + fi + else + if [ "x$dephdr" != "x" ] + then + echo " \"${dephdr}\"," + fi + if [ "x$depsrc" != "x" ] + then + echo " \"${depsrc}\"," + fi + fi + done + + if [ $i -eq $lastIndex ] + then + echo " ]" + else + echo " ]," + fi +done +echo "}" diff --git a/test/runTests.py b/test/runTests.py new file mode 100644 index 0000000..dc1df79 --- /dev/null +++ b/test/runTests.py @@ -0,0 +1,209 @@ +#!/usr/bin/env python + +######################################################################## +# Copyright 1998-2022 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 . # +######################################################################## + +import os +import sys +import json +import subprocess + +# Usage: runTests.py [[changed source file 2] ...] +if len(sys.argv) < 4 : + print('ERROR: must provide model and dependency json files and one or more modified files') + sys.exit(1) + +modelJson = sys.argv[1] +depJson = sys.argv[2] +changedFiles = sys.argv[3:] + +# load the json files that contain: +# - the associations between each model and the header/source pair that define the model class +# - the associations between each source file and the other header/source files on which it depends +with open(modelJson) as f1 : + models = json.load(f1) + +with open(depJson) as f2 : + srcdeps = json.load(f2) + +if not models or not srcdeps or len(models) == 0 or len(srcdeps) == 0 : + print('ERROR: problem loading model dependency information') + sys.exit(1) + +# turn the lists into sets, automatically removes duplicates +for srcfile in srcdeps : + depset = set(srcdeps[srcfile]) + srcdeps[srcfile] = depset + +def getDeps( srcfile, srcdeps, founddeps ) : + """ + Find all the dependencies for a model + Arguments: + srcfile - the model's source file name (or, in recursion, a source file on which it depends) + srcdeps - the dictionary of all source files' dependencies + founddeps - a set of dependencies already found for the model + """ + founddeps.add(srcfile) # make sure our source file is already marked as found + deps = set(srcdeps[srcfile]) # NB need to make a copy here + + # remove already found dependencies from deps, + # then add new ones to founddeps + deps.difference_update(founddeps) + founddeps.update(deps) + + # make list of source files in the dependencies + cpps = [] + for f in deps : + if f.endswith('.cpp') : + cpps.append(f) + + for f in cpps : + # add the dependencies of this source to our set + deps.update( getDeps( f, srcdeps, founddeps ) ) + + return deps + +# create the inverse look-up dictionary +fileDeps = {} +for model in models : + hdrfile = models[model]['header'] + srcfile = models[model]['source'] + + founddeps = set([]) + modeldeps = getDeps(srcfile,srcdeps,founddeps) + modeldeps.add(hdrfile) + modeldeps.add(srcfile) + + for modeldep in modeldeps : + if modeldep in fileDeps : + fileDeps[modeldep].append( model ) + else : + fileDeps[modeldep] = [ model ] + +testAll = False +modelsToTest = [] +skippedFiles = [] +jsonFilesChanged = [] + +for changedFile in changedFiles : + # if one of the test json files has changed we need to re-run that test + if changedFile.startswith('test/jsonFiles/') and changedFile.endswith('.json') : + jsonFilesChanged.append( changedFile ) + + # otherwise only consider source code files (TODO - any others that we should consider? evt.pdl, DECAY.DEC and similar?) + if not ( changedFile.endswith('.hh') or changedFile.endswith('.cpp') or changedFile.endswith('.cc') ) : + skippedFiles.append( changedFile ) + continue + + # the EvtGen, EvtModelReg, or EvtNoRadCorr objects; or the test code itself should trigger a rerun of all tests + # TODO - any others that should be in here? + if changedFile == 'EvtGen/EvtGen.hh' or changedFile == 'src/EvtGen.cpp' or changedFile == 'EvtGenModels/EvtModelReg.hh' or changedFile == 'src/EvtGenModels/EvtModelReg.cpp' or changedFile == 'EvtGenModels/EvtNoRadCorr.hh' or changedFile.startswith('test/') : + testAll = True + modelsToTest = [] + break + + # TODO temporarily skip EvtGenExternal stuff + if 'EvtGenExternal/' in changedFile or changedFile == 'EvtGenModels/EvtAbsExternalGen.hh' : + skippedFiles.append( changedFile ) + continue + + # otherwise check in the model dependency dict + if changedFile not in fileDeps : + print(f'WARNING: no dependency information for modified file: {changedFile}') + continue + + models = fileDeps[changedFile] + if len(models) == 0 : + print(f'WARNING: no models listed for modified file: {changedFile}') + continue + + modelsToTest.extend( models ) + +if testAll : + print('Need to test all models') + modelsToTest = list(models.keys()) + +if len(modelsToTest) == 0 and len(jsonFilesChanged) == 0 : + print('No models to test, exiting...') + if len(skippedFiles) == len(changedFiles) : + sys.exit(0) + else : + sys.exit(1) + +if len(jsonFilesChanged) != 0 : + print(f'The following test configs have changed and so need to be run: {jsonFilesChanged}') + +modelsToTest = set(modelsToTest) +if len(modelsToTest) != 0 : + print(f'Need to test the following models: {modelsToTest}') + +testFilesToRun = [] +allTestFiles = os.listdir('jsonFiles') +for model in modelsToTest : + testFilesForThisModel = [] + for testFile in allTestFiles : + if not testFile.endswith('.json') : + continue + testModelNames = testFile[:testFile.index('__')].split('=') + if model in testModelNames : + testFilesForThisModel.append( testFile ) + if len(testFilesForThisModel) == 0 : + print(f'WARNING: no tests available for model: {model}') + else : + testFilesToRun.extend( testFilesForThisModel ) + +for jsonFile in jsonFilesChanged : + testFilesToRun.append( jsonFile.split('/')[-1] ) + +if len(testFilesToRun) == 0 : + print(f'No tests to run, exiting...') + sys.exit(1) + +testFilesToRun = set(testFilesToRun) +print(f'Will run the following tests: {testFilesToRun}') + +joinOutput = True +allOK = True +for testFile in testFilesToRun : + if joinOutput : + result = subprocess.run(['./testDecayModel', 'jsonFiles/'+testFile], text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + else : + result = subprocess.run(['./testDecayModel', 'jsonFiles/'+testFile], text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + + outFileName = testFile.replace('.json','.out') + with open(outFileName,'w') as outFile : + outFile.write(result.stdout) + + if not joinOutput : + errFileName = testFile.replace('.json','.err') + with open(errFileName,'w') as errFile : + errFile.write(result.stderr) + + if result.returncode == 0 : + print(f'Successfully ran test: {testFile}') + else : + print(f'ERROR: problem running test: {testFile}') + if joinOutput : + print(f' : check the log file: {outFileName}') + else : + print(f' : check the log files: {outFileName} and {errFileName}') + allOK = False + +if not allOK : + sys.exit(1) diff --git a/test/testDecayModel.cc b/test/testDecayModel.cc new file mode 100644 index 0000000..d081e7f --- /dev/null +++ b/test/testDecayModel.cc @@ -0,0 +1,1225 @@ + +/*********************************************************************** +* 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 . * +***********************************************************************/ + +#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 +#include +#include +#include + +using nlohmann::json; + +TestDecayModel::TestDecayModel( const json& config ) : m_config{ config } +{ +} + +bool TestDecayModel::checkMandatoryFields() +{ + const std::array mandatoryFields{ + "parent", "daughters", "models", "parameters", + "outfile", "events", "reference", "histograms" }; + const std::array mandatoryHistoFields{ + "title", "variable", "d1", "d2", "nbins", "xmin", "xmax" }; + const std::array extra2DHistoFields{ "variableY", "d1Y", + "d2Y", "nbinsY", + "ymin", "ymax" }; + + bool allMandatoryFields{ true }; + + for ( const auto& field : mandatoryFields ) { + if ( !m_config.contains( field ) ) { + std::cerr << "ERROR : json does not contain required field: " << field + << std::endl; + allMandatoryFields = false; + continue; + } + if ( field == "histograms" ) { + json jHistos = m_config["histograms"]; + for ( 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; +} + +bool TestDecayModel::run() +{ + // Sometimes an array can be wrongly created when copying the json - fix it + if ( m_config.is_array() ) { + if ( m_config.size() != 1 ) { + std::cerr << "ERROR : json config is an array - dumping config for debugging:\n"; + std::cerr << m_config << std::endl; + return false; + } + m_config = m_config[0]; + } + + // Check that we have, and then get all the mandatory fields first + if ( !checkMandatoryFields() ) { + std::cerr << "ERROR : json does not contain all mandatory fields - dumping config for debugging:\n"; + std::cerr << m_config << std::endl; + return false; + } + + const auto parentName = m_config["parent"].get(); + const auto daughterNames = + m_config["daughters"].get>(); + const auto modelNames = m_config["models"].get>(); + const auto modelParameters = + m_config["parameters"].get>>(); + const auto outFileName = m_config["outfile"].get(); + const auto nEvents = m_config["events"].get(); + const auto refFileName = m_config["reference"].get(); + + // Then check for optional fields, setting default values if not present + + json grandDaughters = m_config["grand_daughters"]; + const auto grandDaughterNames = + grandDaughters.is_array() + ? grandDaughters.get>>() + : std::vector>{}; + + json extras = m_config["extras"]; + const auto extraCommands = extras.is_array() + ? extras.get>() + : std::vector{}; + + json debug = m_config["debug_flag"]; + const auto debugFlag = debug.is_boolean() ? debug.get() : false; + + json conjugates = m_config["do_conjugate_decay"]; + std::vector doConjDecay; + if ( conjugates.is_array() ) { + doConjDecay = conjugates.get>(); + } + if ( doConjDecay.size() != modelNames.size() ) { + doConjDecay.resize( modelNames.size(), false ); + } + + // 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 + auto randomEngine = std::make_unique(); + + EvtAbsRadCorr* radCorrEngine = nullptr; + std::list extraModels; + +#ifdef EVTGEN_EXTERNAL + bool convertPythiaCodes( false ); + bool useEvtGenRandom( true ); + EvtExternalGenList genList( convertPythiaCodes, "", "gamma", useEvtGenRandom ); + radCorrEngine = genList.getPhotosModel(); + extraModels = genList.getListOfModels(); +#endif + + EvtGen theGen( "../DECAY.DEC", "../evt.pdl", randomEngine.get(), + radCorrEngine, &extraModels ); + + /*! Creates a decay file based on json file input. */ + const std::string decFileName = outFileName.substr( 0, + outFileName.size() - 5 ); + const std::string decFile = createDecFile( parentName, daughterNames, + grandDaughterNames, modelNames, + modelParameters, doConjDecay, + extraCommands, decFileName ); + + /*! Define the root output file and histograms to be saved. */ + TFile* outFile = TFile::Open( outFileName.c_str(), "recreate" ); + defineHistos( m_config, outFile ); + + /*! Generate events and fill histograms. */ + generateEvents( theGen, decFile, parentName, doConjDecay[0], nEvents, + debugFlag ); + + // Normalize histograms. + for ( auto hist : m_1DhistVect ) { + double area = hist.second->Integral(); + if ( area > 0.0 ) { + hist.second->Scale( 1.0 / area ); + } + } + for ( auto hist : m_2DhistVect ) { + double area = hist.second->Integral(); + if ( area > 0.0 ) { + hist.second->Scale( 1.0 / area ); + } + } + + /*! Compare with reference histograms. */ + compareHistos( refFileName ); + + // Write output. + outFile->cd(); + for ( auto& hist : m_1DhistVect ) { + hist.second->Write(); + } + for ( auto& hist : m_2DhistVect ) { + hist.second->Write(); + } + if ( m_mixedHist ) { + m_mixedHist->Write(); + } + outFile->Close(); + std::cout << "Created output file: " << outFileName.c_str() << std::endl; + + return true; +} + +std::string TestDecayModel::createDecFile( + const std::string& parent, const std::vector& daughterNames, + const std::vector>& grandDaughterNames, + const std::vector& modelNames, + const std::vector>& parameters, + const std::vector& doConjDecay, + const std::vector& extras, const std::string decFileName ) const +{ + // Create (or overwrite) the decay file + std::string decName( decFileName + ".dec" ); + std::ofstream decFile; + decFile.open( decName.c_str() ); + + // Create daughter aliases if needed + std::vector aliasPrefix; + for ( long unsigned int daughter_index = 0; + daughter_index < daughterNames.size(); daughter_index++ ) { + if ( !grandDaughterNames.empty() && + !grandDaughterNames[daughter_index].empty() ) { + decFile << "Alias My" << daughterNames[daughter_index] << " " + << daughterNames[daughter_index] << std::endl; + if ( doConjDecay[daughter_index + 1] ) { + const EvtId daugID{ + EvtPDL::getId( 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( daughterNames ), + std::end( daughterNames ), daugConjID.getName() ) != + std::end( daughterNames ) ) { + conjName_Alias = conjName_Alias + "_" + daughter_index; + } + decFile << "Alias My" << conjName_Alias << " " << conjName + << std::endl; + decFile << "ChargeConj My" << daughterNames[daughter_index] + << " My" << conjName_Alias << std::endl; + } else if ( doConjDecay[0] ) { + decFile << "ChargeConj My" << daughterNames[daughter_index] + << " My" << daughterNames[daughter_index] << std::endl; + } + aliasPrefix.push_back( "My" ); + } else { + aliasPrefix.push_back( "" ); + } + } + + for ( auto iExtra : extras ) { + decFile << iExtra << std::endl; + } + + // Parent decay + decFile << "Decay " << parent << std::endl; + decFile << "1.0"; + + for ( long unsigned int daughter_index = 0; + daughter_index < daughterNames.size(); daughter_index++ ) { + decFile << " " << aliasPrefix[daughter_index] + << daughterNames[daughter_index]; + } + + decFile << " " << modelNames[0]; + + for ( auto par : parameters[0] ) { + decFile << " " << par; + } + + decFile << ";" << std::endl; + decFile << "Enddecay" << std::endl; + if ( doConjDecay[0] ) { + EvtId parID{ EvtPDL::getId( parent ) }; + EvtId parConjID{ EvtPDL::chargeConj( parID ) }; + decFile << "CDecay " << parConjID.getName() << std::endl; + } + + // Daughter decays into granddaughters + for ( long unsigned int daughter_index = 0; + daughter_index < grandDaughterNames.size(); daughter_index++ ) { + if ( grandDaughterNames[daughter_index].empty() ) + continue; + decFile << "Decay " << aliasPrefix[daughter_index] + << daughterNames[daughter_index] << std::endl; + decFile << "1.0"; + for ( long unsigned int grandDaughter_index = 0; + grandDaughter_index < grandDaughterNames[daughter_index].size(); + grandDaughter_index++ ) { + decFile << " " + << grandDaughterNames[daughter_index][grandDaughter_index]; + } + decFile << " " << modelNames[daughter_index + 1]; + for ( auto par : parameters[daughter_index + 1] ) { + decFile << " " << par; + } + decFile << ";" << std::endl; + decFile << "Enddecay" << std::endl; + if ( doConjDecay[daughter_index + 1] ) { + EvtId daugID{ EvtPDL::getId( daughterNames[daughter_index] ) }; + EvtId daugConjID{ EvtPDL::chargeConj( daugID ) }; + std::string conjName_Alias{ daugConjID.getName() }; + if ( std::find( std::begin( daughterNames ), + std::end( daughterNames ), daugConjID.getName() ) != + std::end( daughterNames ) ) { + conjName_Alias = conjName_Alias + "_" + daughter_index; + } + decFile << "CDecay " << aliasPrefix[daughter_index] + << conjName_Alias << std::endl; + } + } + + decFile << "End" << std::endl; + + decFile.close(); + + return decName; +} + +void TestDecayModel::defineHistos( json& m_config, TFile* outFile ) +{ + // Histogram information + json jHistos = m_config["histograms"]; + size_t nHistos = jHistos.size(); + + m_1DhistVect.reserve( nHistos ); + m_2DhistVect.reserve( nHistos ); + + for ( auto hInfo : jHistos ) { + const auto varTitle = hInfo["title"].get(); + + const auto varName = hInfo["variable"].get(); + // Integer values that define what particles need to be used + // for invariant mass combinations or helicity angles etc + const auto d1 = hInfo["d1"].get(); + const auto d2 = hInfo["d2"].get(); + + const auto nBins = hInfo["nbins"].get(); + const auto xmin = hInfo["xmin"].get(); + const auto xmax = hInfo["xmax"].get(); + + 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" ) ) { + TH1D* hist = new TH1D( histName.c_str(), varTitle.c_str(), nBins, + xmin, xmax ); + hist->SetDirectory( outFile ); + m_1DhistVect.emplace_back( + std::make_pair( TestInfo( varName, d1, d2 ), hist ) ); + continue; + } else { + const auto varNameY = hInfo["variableY"].get(); + const auto d1Y = hInfo["d1Y"].get(); + const auto d2Y = hInfo["d2Y"].get(); + + const auto nBinsY = hInfo["nbinsY"].get(); + const auto ymin = hInfo["ymin"].get(); + const auto ymax = hInfo["ymax"].get(); + + histName += "_"; + histName += varNameY; + if ( d1Y != 0 ) { + histName += "_"; + histName += std::to_string( d1Y ); + } + if ( d2Y != 0 ) { + histName += "_"; + histName += std::to_string( d2Y ); + } + TH2D* hist = new TH2D( histName.c_str(), varTitle.c_str(), nBins, + xmin, xmax, nBinsY, ymin, ymax ); + hist->SetDirectory( outFile ); + m_2DhistVect.emplace_back( std::make_pair( + TestInfo( varName, d1, d2, varNameY, d1Y, d2Y ), hist ) ); + } + } + + // For the case where the parent is either a neutral B or D add a mixed/unmixed histogram + const auto parentName = m_config["parent"].get(); + const int parentID = abs( EvtPDL::getStdHep( EvtPDL::getId( parentName ) ) ); + if ( parentID == 511 || parentID == 531 || parentID == 421 ) { + const std::string varTitle{ parentName + " mixed" }; + m_mixedHist = new TH1D( "mixed", varTitle.c_str(), 2, 0.0, 2.0 ); + // TODO maybe set bin labels? + m_mixedHist->SetDirectory( outFile ); + } +} + +void TestDecayModel::generateEvents( EvtGen& theGen, const std::string& decFile, + const std::string& parentName, + bool doConjDecay, int nEvents, + bool debug_flag ) +{ + // Read the decay file + theGen.readUDecay( decFile.c_str() ); + + // Generate the decays + EvtId parId = EvtPDL::getId( parentName.c_str() ); + EvtId conjId = doConjDecay ? EvtPDL::chargeConj( parId ) : parId; + for ( int i = 0; i < nEvents; i++ ) { + if ( i % 1000 == 0 ) { + std::cout << "Event " << nEvents - i << std::endl; + } + + // 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 }; + if ( m_mixedHist ) { + if ( parent->getNDaug() == 1 ) { + prodParent = parent; + parent = prodParent->getDaug( 0 ); + + m_mixedHist->Fill( 1 ); + } else { + m_mixedHist->Fill( 0 ); + } + } + + // To debug + + if ( debug_flag ) { + std::cout << "Parent PDG code: " << parent->getPDGId() + << " has daughters " << parent->getNDaug() << std::endl; + for ( 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 ( 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; + } + } + } + + // Store information + for ( auto& hist : m_1DhistVect ) { + const auto& info = hist.first; + const double value = getValue( parent, info.getName(), info.getd1(), + info.getd2() ); + + if ( hist.second ) { + hist.second->Fill( value ); + } + } + for ( auto& hist : m_2DhistVect ) { + const auto& info = hist.first; + const double valueX = getValue( parent, info.getName(), + info.getd1(), info.getd2() ); + const double valueY = getValue( parent, info.getName( 2 ), + info.getd1( 2 ), info.getd2( 2 ) ); + if ( hist.second ) { + hist.second->Fill( valueX, valueY ); + } + } + + if ( debug_flag ) { + if ( prodParent ) { + prodParent->printTree(); + } else { + parent->printTree(); + } + } + + // Cleanup + if ( prodParent ) { + prodParent->deleteTree(); + } else { + parent->deleteTree(); + } + } +} + +double TestDecayModel::getValue( EvtParticle* parent, const std::string& varName, + const int d1, const int d2 ) const +{ + double value = std::numeric_limits::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 + 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( "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 = std::sqrt( en1 * en1 - m1Sq ); + double p3 = std::sqrt( en3 * en3 - m3Sq ); + double cosTheta = ( -m13Sq + m1Sq + m3Sq + 2. * en1 * en3 ) / + ( 2. * p1 * p3 ); + 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" ) ) { + // Cosine of helicity angle + EvtVector4R p12; + EvtVector4R p1Res; + + 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::quiet_NaN(); + double hel = std::numeric_limits::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( "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( "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 + 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; + } + + } 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; + } else { + std::cerr << "Warning: Did not recognise variable name " + << selectedVarName << std::endl; + } + + return value; +} + +void TestDecayModel::compareHistos( const std::string& refFileName ) const +{ + // Compare histograms with the same name, calculating the chi-squared + TFile* refFile = TFile::Open( refFileName.c_str(), "read" ); + + if ( !refFile ) { + std::cerr << "Could not open reference file " << refFileName << std::endl; + return; + } + + for ( auto& hist : m_1DhistVect ) { + const std::string histName = hist.second->GetName(); + // Get equivalent reference histogram + const TH1* refHist = dynamic_cast( + refFile->Get( histName.c_str() ) ); + + if ( refHist ) { + double chiSq( 0.0 ); + int nDof( 0 ); + int iGood( 0 ); + double pValue = refHist->Chi2TestX( hist.second, chiSq, nDof, iGood, + "WW" ); + std::cout << "Histogram " << histName << " chiSq/nDof = " << chiSq + << "/" << nDof << ", pValue = " << pValue << std::endl; + + } else { + std::cerr << "Could not find reference histogram " << histName + << std::endl; + } + } + for ( auto& hist : m_2DhistVect ) { + const std::string histName = hist.second->GetName(); + // Get equivalent reference histogram + const TH2* refHist = dynamic_cast( + refFile->Get( histName.c_str() ) ); + + if ( refHist ) { + double chiSq( 0.0 ); + int nDof( 0 ); + int iGood( 0 ); + double pValue = refHist->Chi2TestX( hist.second, chiSq, nDof, iGood, + "WW" ); + std::cout << "Histogram " << histName << " chiSq/nDof = " << chiSq + << "/" << nDof << ", pValue = " << pValue << std::endl; + + } else { + std::cerr << "Could not find reference histogram " << histName + << std::endl; + } + } + + refFile->Close(); +} + +double TestDecayModel::getCosAcoplanarityAngle( EvtParticle* selectedParent, + int sel_NDaugMax, int d1, + 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 + EvtVector4R daughter4Vector1_boosted = boostTo( daughter4Vector1, + parentBoost ); + EvtVector4R daughter4Vector2_boosted = boostTo( daughter4Vector2, + parentBoost ); + + // Boosting each granddaughter to reference frame of its mother + EvtVector4R grandDaughter4Vector1_boosted = boostTo( grandDaughter4Vector1, + daughter1Boost ); + 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 ) { + std::cerr << "Expecting one argument: json input file" << std::endl; + return 1; + } + + /*! Load input file in json format. */ + json config; + std::ifstream inputStr( argv[1] ); + inputStr >> config; + inputStr.close(); + + bool allOK{ true }; + if ( config.is_array() ) { + for ( const auto& cc : config ) { + TestDecayModel test( cc ); + allOK &= test.run(); + } + } else { + TestDecayModel test( config ); + allOK &= test.run(); + } + + return allOK ? 0 : 1; +} diff --git a/test/testDecayModel.hh b/test/testDecayModel.hh new file mode 100644 index 0000000..6a09b5b --- /dev/null +++ b/test/testDecayModel.hh @@ -0,0 +1,101 @@ + +/*********************************************************************** +* 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 . * +***********************************************************************/ + +#ifndef TEST_DECAY_MODEL_HH +#define TEST_DECAY_MODEL_HH + +#include "TFile.h" +#include "TH1D.h" +#include "TH2D.h" + +#include "nlohmann/json.hpp" + +#include +#include +#include +#include + +class EvtGen; +class EvtParticle; + +class TestInfo { + public: + TestInfo( const std::string& name, const int d1, const int d2, + const std::string& nameY = "", const int d1Y = 0, + const int d2Y = 0 ) : + m_name{ name }, m_nameY{ nameY }, m_d1{ d1 }, m_d2{ d2 }, m_d1Y{ d1Y }, m_d2Y{ d2Y } + { + } + + const std::string getName( const int var = 1 ) const + { + return var == 2 ? m_nameY : m_name; + } + int getd1( const int var = 1 ) const { return var == 2 ? m_d1Y : m_d1; } + int getd2( const int var = 1 ) const { return var == 2 ? m_d2Y : m_d2; } + + private: + std::string m_name; + std::string m_nameY; + int m_d1; + int m_d2; + int m_d1Y; + int m_d2Y; +}; + +class TestDecayModel { + public: + TestDecayModel( const nlohmann::json& config ); + + bool run(); + + private: + bool checkMandatoryFields(); + + std::string createDecFile( + const std::string& parent, const std::vector& daughterNames, + const std::vector>& grandDaughterNames, + const std::vector& models, + const std::vector>& parameters, + const std::vector& doConjDecay, + const std::vector& extras, + const std::string decFileName ) const; + + void defineHistos( nlohmann::json& config, TFile* theFile ); + + void generateEvents( EvtGen& theGen, const std::string& decFile, + const std::string& parentName, bool doConjDecay, + int nEvents, bool debugFlag ); + + double getValue( EvtParticle* rootPart, const std::string& varName, + const int d1, const int d2 ) const; + + void compareHistos( const std::string& refFileName ) const; + + double getCosAcoplanarityAngle( EvtParticle* selectedParent, + int sel_NDaugMax, int d1, int d2 ) const; + + nlohmann::json m_config; + std::vector> m_1DhistVect; + std::vector> m_2DhistVect; + TH1D* m_mixedHist{ nullptr }; +}; + +#endif