## main18

Back to index.

    // main18.cc is a part of the PYTHIA event generator.
    // Copyright (C) 2024 Torbjorn Sjostrand.
    // PYTHIA is licenced under the GNU GPL v2 or later, see COPYING for details.
    // Please respect the MCnet Guidelines, see GUIDELINES for details.

    // Keywords:
    //            Event filter
    //            Analysis

    // This is a simple test program.
    // It illustrates how to write an event filter.
    // No new functionality is involved - all could be done in the main program
    // - but the division of tasks may be more convenient for recurrent cuts.

    #include "Pythia8/Pythia.h"

    using namespace Pythia8;

    //==========================================================================

    // The EventFilter class.

    // The constructor takes the following arguments
    // select = 1 : keep only final particles.
    //        = 2 : keep only final visible particles (i.e. not neutrinos).
    //        = 3 : keep only final charged particles.
    // etaMax (default = 50) : keep only particles with pseudorapidity
    //        |eta| < etaMax.
    // pTminCharged (default = 0) : keep a charged particle only if
    //        its transverse momentum pT < pTminCharged.
    // pTminNeutral (default = 0) : keep a neutral particle only if
    //        its transverse momentum pT < pTminNeutral.

    // Main methods:
    // filter( event) takes an event record as input and analyzes it.
    // size() returns the number of particles kept.
    // index(i) returns the index in the full event of the i'th kept particle.
    // particlePtr(i) returns a pointer to the i'th kept particle.
    // particleRef(i) returns a reference to the i'th kept particle.
    // list() gives a listing of the kept particles only.

    class EventFilter {

    public:

      // Constructor sets properties of filter.
      EventFilter( int selectIn, double etaMaxIn = 50.,
        double pTminChargedIn = 0., double pTminNeutralIn = 0.)
        : select(selectIn), etaMax(etaMaxIn), pTminCharged(pTminChargedIn),
        pTminNeutral(pTminNeutralIn) {}

      // Analysis of each new event to find acceptable particles.
      void filter(Event& event);

      // Return size of array, and index of a particle.
      int size()       const {return keptPtrs.size();}
      int index(int i) const {return keptIndx[i];}

      // Return pointer or reference to a particle.
      Particle* particlePtr(int i) {return  keptPtrs[i];}
      Particle& particleRef(int i) {return *keptPtrs[i];}

      // List kept particles only.
      void list(ostream& os = cout);

    private:

      // Filter properties, set by constructor.
      int    select;
      double etaMax, pTminCharged, pTminNeutral;

      // Kept particle indices and pointers, referring to original event.
      vector<int>       keptIndx;
      vector<Particle*> keptPtrs;

    };

    //--------------------------------------------------------------------------

    // The filter method.

    void EventFilter::filter(Event& event) {

      // Reset arrays in preparation for new event.
      keptIndx.resize(0);
      keptPtrs.resize(0);

      // Loop over all particles in the event record.
      for (int i = 0; i < event.size(); ++i) {

        // Skip if particle kind selection criteria not fulfilled.
        if (!event[i].isFinal()) continue;
        if (select == 2 && !event[i].isVisible()) continue;
        bool isCharged = event[i].isCharged();
        if (select == 3 && !isCharged) continue;

        // Skip if too large pseudorapidity.
        if (abs(event[i].eta()) > etaMax) continue;

        // Skip if too small pT.
        if       (isCharged && event[i].pT() < pTminCharged) continue;
        else if (!isCharged && event[i].pT() < pTminNeutral) continue;

        // Add particle to vectors of indices and pointers.
        keptIndx.push_back( i );
        keptPtrs.push_back( &event[i] );

      // End of particle loop. Done.
      }

    }

    //--------------------------------------------------------------------------

    // The list method: downscaled version of Event::list.

    void EventFilter::list(ostream& os) {

      // Header.
      os << "\n --------  PYTHIA Event Listing  (filtered)  ------------------"
         << "-----------------------------------------------------------------"
         << "----\n \n    no        id   name            status     mothers  "
         << " daughters     colours      p_x        p_y        p_z         e  "
         << "        m \n";

      // At high energy switch to scientific format for momenta.
      double eSum = 0.;
      for (int iKept = 0; iKept < size(); ++iKept) eSum += keptPtrs[iKept]->e();
      bool useFixed = (eSum < 1e5);

      // Listing of kept particles in event.
      for (int iKept = 0; iKept < size(); ++iKept) {
        int i = keptIndx[iKept];
        Particle& pt = *keptPtrs[iKept];

        // Basic line for a particle, always printed.
        os << setw(6) << i << setw(10) << pt.id() << "   " << left
           << setw(18) << pt.nameWithStatus(18) << right << setw(4)
           << pt.status() << setw(6) << pt.mother1() << setw(6)
           << pt.mother2() << setw(6) << pt.daughter1() << setw(6)
           << pt.daughter2() << setw(6) << pt.col() << setw(6) << pt.acol()
           << ( (useFixed) ? fixed : scientific ) << setprecision(3)
           << setw(11) << pt.px() << setw(11) << pt.py() << setw(11)
           << pt.pz() << setw(11) << pt.e() << setw(11) << pt.m() << "\n";
      }

      // Listing finished.
      os << "\n --------  End PYTHIA Event Listing  ----------------------------"
         << "-------------------------------------------------------------------"
         << endl;
    }

    //==========================================================================

    // Use the EventFilter method to plot some event properties.

    int main() {

      // Number of events to generate, to list, to allow aborts.
      int    nEvent   = 100;
      int    nList    = 1;
      int    nAbort   = 3;

      // Declare generator.
      Pythia pythia;

      // Hard QCD events with pThat > 100.
      pythia.readString("HardQCD:all = on");
      pythia.readString("PhaseSpace:pTHatMin = 100.");

      // No automatic event listings - do it manually below.
      pythia.readString("Next:numberShowInfo = 0");
      pythia.readString("Next:numberShowProcess = 0");
      pythia.readString("Next:numberShowEvent = 0");

      // Initialization for LHC.
      pythia.init();

      // Values for filter.
      int    select   = 3;
      double etaMax   = 3.;
      double pTminChg = 1.;

      // Declare Event Filter according to specification.
      EventFilter filter( select, etaMax, pTminChg);

      // Histograms.
      Hist nCharged(   "selected charged multiplicity",     100, -0.5, 199.5);
      Hist etaCharged( "selected charged eta distribution", 100, -5.0, 5.0);
      Hist pTCharged(  "selected charged pT distribution",  100,  0.0, 50.0);

      // Begin event loop.
      int iAbort = 0;
      for (int iEvent = 0; iEvent < nEvent; ++iEvent) {

        // Generate events. Quit if too many failures.
        if (!pythia.next()) {
          if (++iAbort < nAbort) continue;
          cout << " Event generation aborted prematurely, owing to error!\n";
          break;
        }

        // Find final charged particles with |eta| < 3 and pT > 1 GeV.
        filter.filter( pythia.event);

        // List first few events, both complete and after filtering.
        if (iEvent < nList) {
          pythia.info.list();
          pythia.process.list();
          pythia.event.list();
          filter.list();
        }

        // Analyze selected particle sample.
        nCharged.fill( filter.size() );
        for (int i = 0; i < filter.size(); ++i) {
          // Use both reference and pointer notation to illustrate freedom.
          etaCharged.fill( filter.particleRef(i).eta() );
          pTCharged.fill(  filter.particlePtr(i)->pT() );
        }

      // End of event loop.
      }

      // Final statistics.
      pythia.stat();

      // Histograms.
      cout << nCharged << etaCharged << pTCharged;

      // Done.
      return 0;
    }