Merge pull request #2 from AAAlvesJr/master

Merge to first patch version

Author: AAAlvesJr

CMakeLists.txt

@@ -50,8 +50,8 @@ option(BUILD_DOCUMENTATION "Create and install the HTML based API documentation
 #options to gcc
 include(CheckCXXCompilerFlag)
 CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
-if(COMPILER_SUPPORTS_CXX11)
- message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
+if(NOT COMPILER_SUPPORTS_CXX11)
+ message(FATAL "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")
 endif()
 
 #options to gcc
@@ -72,15 +72,17 @@ if(CUDA_FOUND)
 	# Detect CUDA architecture and get best NVCC flags
 
 	INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindCudaArch.cmake)
+	
 	SELECT_NVCC_ARCH_FLAGS(NVCC_FLAGS_EXTRA)
+	
 	LIST(APPEND CUDA_NVCC_FLAGS ${NVCC_FLAGS_EXTRA})
 	#hack for gcc 5.x.x
 	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9)
 	    LIST(APPEND CUDA_NVCC_FLAGS " -D_MWAITXINTRIN_H_INCLUDED ")
     	endif()
 endif(CUDA_FOUND)
 
-if((CUDA_FOUND) AND (CUDA_GPU_DETECT_OUTPUT))
+if( CUDA_FOUND )
 
 	SET(BUILD_CUDA_TARGETS  ON)
 

mcbooster/Generate.h

@@ -49,6 +49,7 @@
 #include <mcbooster/functors/DecayMothers.h>
 #include <mcbooster/functors/RandGen.h>
 #include <mcbooster/functors/FlagAcceptReject.h>
+#include <mcbooster/functors/IsAccepted.h>
 #include <mcbooster/strided_iterator.h>
 
 #include <thrust/copy.h>
@@ -169,9 +170,10 @@ class PhaseSpace {
 	 * - _NEvents: it is the number of events to be generated.
 	 */
 	PhaseSpace(GReal_t _MotherMass, vector<GReal_t> _Masses, GLong_t _NEvents) :
-			fNDaughters(_Masses.size()), fNEvents(_NEvents), fRandNumbers(
-					(3 * _Masses.size() - 2) * _NEvents, 0.0), fMaxWeight(0.0), RND_Time(
-					0.0), EVT_Time(0.0), EXP_Time(0.0) {
+			fNDaughters(_Masses.size()), fNEvents(_NEvents),
+			fRandNumbers((3 * _Masses.size() - 2) * _NEvents, 0.0), fMaxWeight(0.0),
+			RND_Time(0.0), EVT_Time(0.0), EXP_Time(0.0), fNAccepted(0)
+        {
 
 		if (_Masses.size() < 2 || _Masses.size() > 9) {
 			cout
@@ -252,6 +254,10 @@ class PhaseSpace {
 		return fNEvents;
 	}
 
+	inline GLong_t GetNAccepted() const {
+			return fNAccepted;
+		}
+
 	/**
 	 * Returns a device vector with the event weights.
 	 */
@@ -292,7 +298,7 @@ class PhaseSpace {
 	 * Export the events and all related information to host.
 	 */
 	void Export(Events *_Events);
-
+	void ExportUnweighted(Events *_Events);
 	/**
 	 * Flag the accepted and rejected events
 	 */
@@ -328,6 +334,7 @@ class PhaseSpace {
 
 	GLong_t fNEvents; ///< Number of events.
 	GInt_t fNDaughters;///< Number of daughters.
+	GLong_t fNAccepted;
 	GReal_t RND_Time;///< Random number generation time interval seconds.
 	GReal_t EVT_Time;///< Event generation time interval in seconds.
 	GReal_t EXP_Time;///< Events export time interval in seconds.
@@ -339,6 +346,7 @@ class PhaseSpace {
 	Particles_d fDaughters[kMAXP];///< Array of device vectors with the daughter four-vectors
 	RealVector_d fRandNumbers;///<
 
+
 };
 
 GULong_t PhaseSpace::Unweight()
@@ -365,11 +373,90 @@ GULong_t PhaseSpace::Unweight()
 			kTrue);
 
 	}
+	fNAccepted=count;
 	return count;
 
 }
 
 
+
+void PhaseSpace::ExportUnweighted(Events *_Events) {
+	/**
+	 * Export the events and all related information to an Events object properly initialized.
+	 */
+
+	if(!fNAccepted) Unweight();
+
+
+	_Events->fMaxWeight = fMaxWeight;
+
+#if THRUST_DEVICE_SYSTEM==THRUST_DEVICE_BACKEND_OMP || THRUST_DEVICE_SYSTEM==THRUST_DEVICE_BACKEND_TBB
+
+#pragma omp parallel num_threads( fNDaughters + 1 )
+	{
+
+		if (omp_get_thread_num() < fNDaughters )
+		{
+			thrust::copy_if( fDaughters[omp_get_thread_num()].begin(),fDaughters[omp_get_thread_num()].end(),
+					fAccRejFlags.begin(),
+					_Events->fDaughters[omp_get_thread_num()].begin(), isAccepted() );
+		}
+
+		if (omp_get_thread_num() == fNDaughters )
+		{
+			thrust::copy_if(fWeights.begin(), fWeights.end(),
+					fAccRejFlags.begin(),
+					_Events->fWeights.begin(), isAccepted() );
+
+			thrust::copy_if(fAccRejFlags.begin(), fAccRejFlags.end(),
+					fAccRejFlags.begin(),
+					_Events->fAccRejFlags.begin(), isAccepted() );
+
+		}
+
+	}
+
+#else
+
+	cudaStream_t s[fNDaughters + 1];
+
+	for (GInt_t d = 0; d <= fNDaughters; d++) {
+
+		CUDA_CHECK_RETURN(
+				cudaStreamCreateWithFlags(&s[d], cudaStreamNonBlocking));
+	}
+
+
+
+	thrust::copy_if( thrust::cuda::par.on(s[fNDaughters]),
+			fWeights.begin(), fWeights.end(),
+									fAccRejFlags.begin(),
+									_Events->fWeights.begin(), isAccepted() );
+
+
+	thrust::copy_if( thrust::cuda::par.on(s[fNDaughters]),
+			fAccRejFlags.begin(), fAccRejFlags.end(),
+								fAccRejFlags.begin(),
+								_Events->fAccRejFlags.begin(), isAccepted() );
+
+
+	for (GInt_t d = 0; d < fNDaughters; d++) {
+
+		thrust::copy_if( thrust::cuda::par.on(s[d]),
+				fDaughters[d].begin(),fDaughters[d].end(),
+							fAccRejFlags.begin(),
+							_Events->fDaughters[d].begin(), isAccepted() );
+
+	}
+
+	cudaDeviceSynchronize();
+	for (GInt_t d = 0; d <= fNDaughters; d++)
+		cudaStreamDestroy(s[d]);
+
+#endif
+
+}
+
 void PhaseSpace::Export(Events *_Events) {
 	/**
 	 * Export the events and all related information to an Events object properly initialized.

mcbooster/MCBooster.h

@@ -4,67 +4,159 @@
 #define MCBooster_VERSION_PATCH 0
 /**
  \mainpage
- 
  MCBooster
 =========
 
 What is it?
 -----------
+
 MCBooster is an header only library designed for the fast generation of
-phase space events. The library make use of thrust library and can deploy OpenMP
-threads, CUDA and Xeon Phi cores. It is focused on performance and precision.  
+phase space events. The library makes use of Thrust and can deploy OpenMP
+threads, CUDA and Xeon Phi cores. It is focused on performance and precision.
+
+The libray core algorithm follow as close as it is possible the implementation of the class [TGenPhaseSpace](https://root.cern.ch/doc/master/TGenPhaseSpace_8cxx.html)
+from [ROOT framwork](https://root.cern.ch/),
+which is based on the [GENBOD function (W515 from CERNLIB)](http://cernlib.web.cern.ch/cernlib/mc/genbod.html)
+using the Raubold and Lynch method as described in
+
+[_F. James, Monte Carlo Phase Space, CERN 68-15 (1968)_](https://cds.cern.ch/record/275743/files/CERN-68-15.pdf).
+
+Main features
+-------------
+
+Generates phase space Monte Carlo samples with up to nine particles in the final state, using very simple
+and intuitive interface. Example:
+```c++
+//generating 10M events of B0 -> J/psi K pi
+#include <mcbooster/GTypes.h>
+#include <mcbooster/Vector4R.h>
+#include <mcbooster/Generate.h>
+ ...
+//setting the mother particle
+Vector4R B0(5.2795, 0.0, 0.0, 0.0);
+
+//setting the masses of the daughter particles
+vector<GReal_t> masses;
+masses.push_back(3.096916); // J/psi
+masses.push_back(0.493677); // K
+masses.push_back(0.13957018); // pi
+
+//generator ctor for 10M events
+PhaseSpace phsp(B0.mass(), massesB0, 10000000);
+
+//run the generator
+phsp.Generate(B0);
+
+//Unweight the events flags the accepted and rejected events
+phsp.Unweight();
+
+//export events to the host (in case it is necessary)
+Events *GenEvents = new Events(masses.size(), 10000000);
+phsp.Export(GenEvents);
+...
+```
+Other key features are:
+
+1. Decays can be generated with mother particles are rest or with a definite four-vector.
+this feature allows the generation of sequential decays.
+
+2. Generates weighted and "unweighted" samples simultaneously.
+
+3. Allows the fast parallel evaluation of arbitrary functions taking as
+argument up to ten particles as input.
+
+4. Allows the fast parallel evaluation of arrays of variables simultaneously.
+
+MCBooster also provides a bunch of custom types, containers and an increasing number of algorithms
+to maximaze performance, avoid unecessary usage of memory and grant flexibility and protability between
+host and device calculations and deployment scenarios.
+
+Just changing .cu to .cpp in any source code writen only using the provided cosntructs is enough
+to compile your application for OpenMP using GCC in a machine without a NVIDIA GPU installed.
+
+Many other possibilities and functionaties, bounded only by the creativity of the users.
 
 The Latest Version
 ------------------
 
-The latest version can be found on the 
+The latest version can be found on the
 [project relases page](https://github.com/MultithreadCorner/MCBooster/releases).
 
 Documentation
 -------------
 
 The complete and updated [Doxygen](http://www.doxygen.org/) source code documentation of this release is available in HTML format on the
 [reference manual](http://multithreadcorner.github.io/MCBooster/) webpage.
-User can also browse the documentation by class, file or name using the following links:
+Users can also browse the documentation by class, file or name using the following links:
 
-1.[classe](http://multithreadcorner.github.io/MCBooster/classes.html)
+1.[classes](http://multithreadcorner.github.io/MCBooster/classes.html)
 
-2.[file](http://multithreadcorner.github.io/MCBooster/files.html)
+2.[files](http://multithreadcorner.github.io/MCBooster/files.html)
 
-3.[name](http://multithreadcorner.github.io/MCBooster/namespacemembers.html)
+3.[names](http://multithreadcorner.github.io/MCBooster/namespacemembers.html)
 
+Installation and requirements
+-----------------------------
+
+MCBooster is a header only library, so no build process is necessary to install it.
+Just place the `mcbooter` folder and its contents where your system can find it.
+The library run on Linux systems and requires C++11 and the [Thrust library](https://thrust.github.io/).
+Some examples demonstrating the basic features of the library are included in the `src` folder.
+These code samples require [ROOT](https://root.cern.ch/) and [TCLAP](http://tclap.sourceforge.net/) library.
+CUDA based projects will require a local installation of [CUDA Tookit](https://developer.nvidia.com/cuda-toolkit) with version 6.5 or higher.
+Alternatively, projects the targeting [OpenMP](http://openmp.org/wp/) backend can be compiled with either nvcc or gcc.
+The CUDA runtime is not required to use OpemMP with gcc.
 
 Examples
 --------
 
-Some example code samples demonstrating the basic usage of the library are stored in the src directory. 
+Some example code samples demonstrating the basic usage of the library are stored in the src directory, in the project source tree.
 These samples can be built using [CMAKE](https://cmake.org/) according the following instructions:
 
 1. clone the git repository: `git clone https://github.com/MultithreadCorner/MCBooster.git`
 2. go to MCBooster directory: `cd MCBooster`
-3. create a build directory: `mkdir build` 
+3. create a build directory: `mkdir build`
+4. go to build directory: `cd build`
 4. `cmake ../`
 5. `make`
 
-The targets will be installed into directory-of-the-project/bin. To run an example do ./example-name
+Users with root privilegies can do `make install` and get the targets installed into system-install-dir/bin
+(usually /usr/local. __Notice the project installation path is printed out in the setp 4__). Users without root privileges can point the installation path to a different location cmake `-DCMAKE_INSTALL_PREFIX=<user-path>/ ../`.
 
-Installation and requirements 
------------------------------
+The examples are named according to the convention `MCBooster_Example_<BACKEND AND COMPILER>_<EXAMPLE NAME>`. To run an example do `./example-name`.
+The examples are described below:
 
-MCBooster is a header only library, so no build process is necessary to install it.
-The library run on Linux systems and requires C++11 and the [Thrust library](https://thrust.github.io/). The code samples require [ROOT](https://root.cern.ch/) and [TCLAP](http://tclap.sourceforge.net/) library. 
-CUDA based projects will require a local installation of [CUDA Tookit](https://developer.nvidia.com/cuda-toolkit) with version 6.5 or higher.  
-Alternatively, projects the targeting [OpenMP](http://openmp.org/wp/) backend can be compiled with nvcc or gcc directly. 
+1. __B2KPiJpsi__ : Generates a sample of B0 -> Jpsi K pi, with J/psi -> mu+ mu- and calculates in parallel, for each event, the variables:
+  * M(K,pi), the Kpi invariant mass.
+  * M(J/psi,pi), the J/psipi invariant mass.
+  * cos theta(K), the helicity angle of the Kpi.
+  * cos theta(mu), the helicity angle of the J/psi
+  * phi, the angle between the decay planes
+
+The program print some events and timing information to sdtout and plotsthe distributions of the above variables plus the B0 -> J/psiK pi Dalitz plot.
+
+2. __GenerateSample__ : Takes arguments from the command line, generates a sample and save it into a ROOT TTree.
+
+3. __PerformanceTest__: Meausure the time to generate and export samples in function of the number of events and number of particles.
 
 Licensing
 ---------
 
 MCBooster is released under the [GNU General Public License version 3](http://www.gnu.org/licenses/gpl-3.0.en.html). Please see the file called [COPYING](https://github.com/MultithreadCorner/MCBooster/blob/master/COPYING).
 
+Contact the developers
+----------------------
+Here’s what you should do if you need help or would like to contribute:
+
+1. If you need help or would like to ask a general question, subscribe and use https://groups.google.com/d/forum/mcbooster.
+2. If you found a bug, use GitHub issues.
+3. If you have an idea, use GitHub issues.
+4. If you want to contribute, submit a pull request.
+
 Author
 --------
 
-MCBooster is developed and mantained by [Antonio Augusto Alves Jr](@AAAlvesJr).
+MCBooster was created and is mantained by [Antonio Augusto Alves Jr](@AAAlvesJr).
 
 Acknowledgement
 ---------------