TupleAlg3.cpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <utility>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/IRndmGenSvc.h"
#include "GaudiKernel/RndmGenerators.h"
#include "GaudiKernel/SystemOfUnits.h"
// ============================================================================
// GaudiAlg
// ============================================================================
#include "GaudiAlg/GaudiTupleAlg.h"
#include "GaudiAlg/Tuple.h"
// ============================================================================
 
// ============================================================================
// ============================================================================
 
class TupleAlg3 : public GaudiTupleAlg {
public:
  StatusCode initialize() override {
    StatusCode sc = GaudiTupleAlg::initialize();
    if ( sc.isFailure() ) { return sc; }
    // check for random numbers service
    Assert( randSvc() != 0, "Random Service is not available!" );
    //
    return StatusCode::SUCCESS;
  }
  StatusCode execute() override;
  using GaudiTupleAlg::GaudiTupleAlg;
 
private:
  // copy constructor is disabled
  TupleAlg3( const TupleAlg3& );
  // assignement op[erator is disabled
  TupleAlg3& operator=( const TupleAlg3& );
};
// ============================================================================
DECLARE_COMPONENT( TupleAlg3 )
// ============================================================================
// ============================================================================
StatusCode TupleAlg3::execute() {
  using namespace Tuples;
  using namespace Gaudi::Units;
 
  Rndm::Numbers gauss( randSvc(), Rndm::Gauss( 0.0, 1.0 ) );
  Rndm::Numbers flat( randSvc(), Rndm::Flat( -10.0, 10.0 ) );
  Rndm::Numbers expo( randSvc(), Rndm::Exponential( 1.0 ) );
  Rndm::Numbers breit( randSvc(), Rndm::BreitWigner( 0.0, 1.0 ) );
  Rndm::Numbers poisson( randSvc(), Rndm::Poisson( 2.0 ) );
  Rndm::Numbers binom( randSvc(), Rndm::Binomial( 8, 0.25 ) );
 
  // ==========================================================================
  // book and fill simple NTuple with Lorentz Vectors
  // ==========================================================================
  {
    Tuple tuple = nTuple( "LorentzVectors", "Tuple with Lorentz Vectors " );
 
    typedef ROOT::Math::PxPyPzEVector LV;
 
    LV lv;
 
    lv.SetPx( gauss() );
    lv.SetPy( gauss() );
    lv.SetPz( flat() );
    lv.SetE( ::sqrt( lv.P2() + 1 * GeV * GeV ) );
 
    LV lv2 = lv;
    lv2.SetE( ::sqrt( lv.P2() + 4 * GeV * GeV ) );
 
    tuple->column( "lv1", lv ).ignore();
    tuple->column( "lv2", lv2 ).ignore();
 
    tuple->write().ignore();
  }
  // ==========================================================================
  // book and fill simple NTuple with 3D Vectors & Points
  // ==========================================================================
  {
 
    Tuple tuple = nTuple( "Vectors-3D", "Tuple with Vectors in 3D " );
 
    typedef ROOT::Math::XYZPoint  P3;
    typedef ROOT::Math::XYZVector V3;
 
    P3 p1;
    p1.SetX( flat() );
    p1.SetY( flat() );
    p1.SetZ( flat() );
 
    tuple->column( "p3", p1 ).ignore();
 
    V3 p2;
    p2.SetX( gauss() );
    p2.SetY( gauss() );
    p2.SetZ( gauss() );
 
    tuple->column( "v3", p2 ).ignore();
 
    tuple->write().ignore();
  }
  // ==========================================================================
  // book and fill simple NTuple with Math-vectors
  // ==========================================================================
  {
 
    Tuple tuple = nTuple( "Math-vectors", "Tuple with Math Vectors" );
 
    ROOT::Math::SVector<float, 4>        v1;
    ROOT::Math::SVector<double, 25>      v2;
    ROOT::Math::SVector<long double, 50> v3;
 
    std::generate( v1.begin(), v1.end(), gauss );
    std::generate( v2.begin(), v2.end(), breit );
    std::generate( v3.begin(), v3.end(), flat );
 
    tuple->array( "g", v1 ).ignore();
    tuple->array( "b", v2 ).ignore();
    tuple->array( "f", v3 ).ignore();
 
    tuple->write().ignore();
  }
  // ==========================================================================
  // book and fill simple NTuple with S-matrices
  // ==========================================================================
  {
 
    Tuple tuple = nTuple( "S-matrices", "Tuple with S-matrices" );
 
    ROOT::Math::SMatrix<float, 4>                                                 v1;
    ROOT::Math::SMatrix<double, 3, 15>                                            v2;
    ROOT::Math::SMatrix<long double, 5, 5, ROOT::Math::MatRepSym<long double, 5>> v3;
 
    std::generate( v1.begin(), v1.end(), gauss );
    std::generate( v2.begin(), v2.end(), breit );
    std::generate( v3.begin(), v3.end(), flat );
 
    tuple->matrix( "g", v1 ).ignore();
    tuple->matrix( "b", v2 ).ignore();
    tuple->matrix( "f", v3 ).ignore();
 
    tuple->write().ignore();
  }
 
  // ==========================================================================
  // book and fill simple NTuple with VectorMap
  // ==========================================================================
  {
 
    Tuple tuple = nTuple( "VectorMaps", "Tuple with VectorMaps/'ExtraInfo'" );
 
    typedef GaudiUtils::VectorMap<int, double>       VM1;
    typedef GaudiUtils::VectorMap<char, long double> VM2;
    typedef GaudiUtils::VectorMap<int, float>        VM3;
    typedef GaudiUtils::VectorMap<long, double>      VM4;
 
    VM1 vm1;
    VM2 vm2;
    VM3 vm3;
    VM4 vm4;
 
    for ( int i = 200; 0 < i; --i ) {
      vm1.insert( std::make_pair( i, i * 2 ) );
      vm2.insert( std::make_pair( i, i * 3 ) );
      vm3.insert( std::make_pair( i, float( i * 4 ) ) );
      vm4.insert( std::make_pair( i, i * 5 ) );
    }
 
    tuple->fmatrix( "map1", vm1, "n1", 500 ).ignore();
    tuple->fmatrix( "map2", vm2, "n2", 500 ).ignore();
    tuple->fmatrix( "map3", vm3, "n3", 500 ).ignore();
    tuple->fmatrix( "map4", vm4, "n4", 500 ).ignore();
 
    tuple->write().ignore();
  }
 
  return StatusCode::SUCCESS;
}
// ============================================================================
 
// ============================================================================
// The END
// ============================================================================