Hydra  4.0.1
A header-only templated C++ framework to perform data analysis on massively parallel platforms.
phsp_unweighting.inl File Reference
#include <iostream>
#include <assert.h>
#include <time.h>
#include <vector>
#include <array>
#include <chrono>
#include <tclap/CmdLine.h>
#include <hydra/Types.h>
#include <hydra/Vector4R.h>
#include <hydra/PhaseSpace.h>
#include <hydra/Function.h>
#include <hydra/Lambda.h>
#include <hydra/Algorithm.h>
#include <hydra/Tuple.h>
#include <hydra/host/System.h>
#include <hydra/device/System.h>
#include <hydra/Decays.h>
#include <hydra/DenseHistogram.h>
#include <hydra/Range.h>
Include dependency graph for phsp_unweighting.inl:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define PHSP_UNWEIGHTING_INL_
 

Functions

cmd add (NArg)
 
 catch (TCLAP::ArgException &e)
 
 declarg (A, hydra::Vector4R) declarg(B
 
hydra::Vector4R declarg (C, hydra::Vector4R) int main(int argv
 
phsp Generate (Parent, Events)
 
TCLAP::ValueArg< size_t > NArg ("n", "nevents", "Number of events to generate. Default is [ 10e6 ].", true, 10e6, "unsigned long")
 
hydra::Vector4R Parent (P_mass, 0.0, 0.0, 0.0)
 
cmd parse (argv, argc)
 

Variables

double A_mass = 0.13957061
 
hydra::Vector4R char ** argc
 
double B_mass = 0.13957061
 
double C_mass = 0.13957061
 
auto dalitz_calculator
 
std::chrono::duration< double, std::milli > elapsed = end - start
 
auto end = std::chrono::high_resolution_clock::now()
 
double masses [3] {A_mass, B_mass, C_mass }
 
 nentries = NArg.getValue()
 
double P_mass = 0.493677
 
hydra::PhaseSpace< 3 > phsp {P_mass, masses}
 
auto start = std::chrono::high_resolution_clock::now()
 
 try
 

Macro Definition Documentation

◆ PHSP_UNWEIGHTING_INL_

#define PHSP_UNWEIGHTING_INL_

Function Documentation

◆ add()

cmd add ( NArg  )

◆ catch()

catch ( TCLAP::ArgException &  e)

◆ declarg() [1/2]

declarg ( A  ,
hydra::Vector4R   
)

◆ declarg() [2/2]

hydra::Vector4R declarg ( C  ,
hydra::Vector4R   
)

◆ Generate()

phsp Generate ( Parent  ,
Events   
)

◆ NArg()

TCLAP::ValueArg<size_t> NArg ( "n"  ,
"nevents"  ,
"Number of events to generate. Default is ."  [10e6],
true  ,
10e6  ,
"unsigned long"   
)

◆ Parent()

hydra::Vector4R Parent ( P_mass  ,
0.  0,
0.  0,
0.  0 
)

◆ parse()

cmd parse ( argv  ,
argc   
)

Variable Documentation

◆ A_mass

◆ argc

hydra::Vector4R char** argc
Initial value:
{
size_t nentries = 0
nentries
Definition: phsp_unweighting.inl:130
Examples:
phsp_unweighting.inl.

◆ B_mass

◆ C_mass

◆ dalitz_calculator

auto dalitz_calculator
Initial value:
[] __hydra_dual__ (A a, B b, C c) {
return hydra::make_tuple( (a + b).mass2(), (b + c).mass2());
})
__hydra_host__ __hydra_device__ auto make_tuple(T &&... t) -> decltype(hydra::thrust::make_tuple(std::forward< T >(t)...))
This version of make_tuple creates a new tuple object from a list of objects.
Definition: Tuple.h:261
auto B
Definition: basic_distributions.inl:145
#define __hydra_dual__
Definition: Config.h:104
hydra::Lambda< LambdaType, 0 > wrap_lambda(LambdaType const &lambda)
Definition: Lambda.h:528
auto A
Definition: basic_distributions.inl:144
auto C
Definition: basic_distributions.inl:146
Examples:
phsp_unweighting.inl.

◆ elapsed

std::chrono::duration<double, std::milli> elapsed = end - start

◆ end

auto end = std::chrono::high_resolution_clock::now()

◆ masses

◆ nentries

nentries = NArg.getValue()

◆ P_mass

◆ phsp

◆ start

auto start = std::chrono::high_resolution_clock::now()

◆ try

try
Initial value:
{
TCLAP::CmdLine cmd("Command line arguments for PHSP B0 -> J/psi K pi", '=')