## main62

Back to index.

    // main62.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:
    //            Userhooks
    //            LHE file
    //            Resonance decay
    //            External resonance

    // Example how you can use UserHooks to set angular decay distributions
    // for undecayed resonances from Les Houches input using the polarization
    // information of the boson defined in its rest frame.

    #include "Pythia8/Pythia.h"
    using namespace Pythia8;

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

    // Write own derived UserHooks class.
    // Assumptions in this particular case:
    // The W+- bosons were undecayed in the Les Houches Events input file,
    // and subsequently decayed isotropically by the Pythia machinery.
    // Now the angular distribution will be corrected for each W,
    // based on the polarization value stored in the LHEF.
    // For W- this is (1 -+ cos(theta))^2 for +-1, sin^2(theta) for 0,
    // and isotropic for 9. For W+ it is flipped (i.e. theta->pi-theta).
    // The Pythia decay products (i.e. the branching ratios) are retained.

    class MyUserHooks : public UserHooks {

    public:

      // Constructor can set helicity definition and book a histogram.
      MyUserHooks(const Info* infoPtrIn, bool inputOption = true)
        : infoPtr(infoPtrIn), helicityDefinedByMother(inputOption) {
        // Book a histogram to test the angular distribution in the UserHook.
        cosRaw = new Hist("cos(the*) raw", 100, -1., 1.);
      }

      // Destructor prints histogram and deletes it.
      ~MyUserHooks() { cout << *cosRaw; delete cosRaw; }

      // Allow a veto for the process level, to gain access to decays.
      bool canVetoProcessLevel() {return true;}

      // Access the event after resonance decays.
      bool doVetoProcessLevel(Event& process) {

        // Identify decayed W+- bosons for study.
        // Assume isotropic decay if polarization is unphysically big (|pol|>2)
        for (int i = 0; i < process.size(); ++i) {
          if (process[i].idAbs() == 24 && process[i].status() == -22
              && abs(process[i].pol()) < 2.) {

            // Pick decay angles according to desired distribution
            // based on polarization and particle/antiparticle.
            double cosThe = selectAngle( process[i].pol(), process[i].id() );
            // Accumulate the raw angular distribution.
            cosRaw->fill( cosThe );
            double sinThe = sqrt(1.0 - pow2(cosThe));
            double phi    = 2.0 * M_PI * rndmPtr->flat();

            // Identify W+- daughters, properly ordered.
            int idV = process[i].id();
            int i1  = process[i].daughter1();
            int i2  = process[i].daughter2();
            // The current distributions are for the particle with the
            // same charge sign as the mother, i.e. W- -> e-.
            if (process[i1].id() * idV > 0) swap( i1, i2);

            // Set up decay in rest frame of W+-.
            double mV = process[i].m();
            double m1 = process[i1].m();
            double m2 = process[i2].m();
            // Energy and absolute momentum of first decay product in W rest frame.
            double e1 = 0.5* (pow2(mV) + pow2(m1) - pow2(m2))/mV;
            double pA = sqrt(pow2(e1) - pow2(m1));
            // Four-vectors for the two decay products.
            Vec4 p1( pA * sinThe * cos(phi), pA *sinThe * sin(phi),
              pA * cosThe, e1);
            Vec4 p2   = Vec4(0,0,0,mV) - p1;

            // Reference four-vector for helicity definition.
            Vec4 pM;
            // Helicity is defined in the mother frame.
            if( helicityDefinedByMother ) {
              pM = process[process[i].mother1()].p();
            // Helicity is defined in the process CMS frame.
            // This is the convention for MadGraph.
            } else {
              pM = Vec4( 0., 0., 0., infoPtr->mHat());
            }

            // Angular reference axis defined as opposite the mother
            // direction in W rest frame.
            pM.bstback( process[i].p() );
            pM.flip3();
            RotBstMatrix Mrotbst;
            Mrotbst.rot( pM);

            // Rotate and boost W decay products.
            Mrotbst.bst( process[i].p() );
            p1.rotbst(Mrotbst);
            p2.rotbst(Mrotbst);
            process[i1].p( p1 );
            process[i2].p( p2 );
          }
          // End of loop over W's. Do not veto any events.
        }
        return false;
      }

      // Select polar angle for the W decay.
      double selectAngle( double inputSpin, double inputId ) {

        // Set up initial angles.
        double rdNow = rndmPtr->flat();
        double cosThe;
        // Small number to distinguish -1, 1, and 0 with round-off.
        double eps = 1e-10;

        // W+ distribution is "opposite" of W-.
        if (inputId > 0) inputSpin *= -1;

        // Different decay angular distributions.
        // 3/8 * (1 - cos(theta))^2  ++
        if (inputSpin > eps) {
          cosThe = max( 1.0 - 2.0 * pow(rdNow, 1./3.), -1.0);
        // 3/8 * (1 + cos(theta))^2  --
        } else if (inputSpin < -eps) {
          cosThe = min( 2.0 * pow(rdNow, 1./3.) - 1.0,  1.0);
        // 3/4 * sin(theta)^2        00
        // Solution of cubic equation that yields the correct result.
        } else {
          double theA = (acos(1.0 - 2.0 * rdNow) + 4.0 * M_PI) / 3.0;
          cosThe = 2.0 * cos(theA);
        }

        // Return the selected cos(theta) value.
        return cosThe;
      }

    private:

      const Info* infoPtr;
       // bool to define the frame for helicity.
      bool helicityDefinedByMother;
      Hist* cosRaw;

    };

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

    int main() {

      // Generator. Shorthand for the event.
      Pythia pythia;
      Event& event = pythia.event;

      // Set up to do a user veto and send it in. Initialize.
      //  Use this line for CMS definition of helicity.
      //  MyUserHooks* myUserHooks = new MyUserHooks(&pythia.info,false);
      // Default constructor uses mother frame for helicity.
      shared_ptr<MyUserHooks> myUserHooks = make_shared<MyUserHooks>(&pythia.info);
      pythia.setUserHooksPtr( (UserHooksPtr)myUserHooks);
      pythia.readFile("main62.cmnd");
      pythia.init();

      // Histograms.
      Hist polarization("W polarization", 99, -9.9, 9.9);
      Hist cosPlus( "cos(theta) W- -> f",    100, -1.0, 1.0);
      Hist cosMinus("cos(theta) W+ -> fbar", 100, -1.0, 1.0);
      Hist energy("daughter energy in W rest frame", 100, 0.0, 100.0);

      // Extract settings to be used in the main program.
      int nEvent = pythia.mode("Main:numberOfEvents");

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

        // Generate events.
        pythia.next();

        // Loop through event, looking for a W and its daughters.
        for (int i = 0; i < event.size(); ++i) {
          // Select W boson when it decays to two partons,
          // not when it is a recoil in FSR.
          if (event[i].idAbs() == 24
              && event[i].daughter1() != event[i].daughter2() ) {
            int i1 = event[i].daughter1();
            // Angular distribution is defined with respect to the decay product
            // with the same sign charge as the W boson.
            if (event[i1].id() * event[i].id() > 0 ) i1 = event[i].daughter2();

            // Reconstruct W+- decay angle by boosting daughter and mother to W
            // rest frame. W direction in mother rest frame opposite to mother now.
            RotBstMatrix Mrotbst;
            Mrotbst.bstback( event[i].p() );
            Vec4 p1 = event[i1].p();
            p1.rotbst( Mrotbst );
            Vec4 pM = event[event[i].mother1()].p();
            pM.rotbst( Mrotbst );
            pM.flip3();
            double costhe = costheta( p1, pM );

            // Histogram information.
            polarization.fill( event[i].pol() );
            if ( event[i].id() > 0 ) cosPlus.fill( costhe );
            else                    cosMinus.fill( costhe );
            energy.fill( p1.e() );
          }
        }

      // End of event loop.
      }

      // Statistics. Histograms.
      pythia.stat();
      cout << polarization << cosPlus << cosMinus << energy;

      // Done.
      return 0;
    }