G4QGSMFragmentation Class Reference

#include <G4QGSMFragmentation.hh>

Inheritance diagram for G4QGSMFragmentation:

Public Member Functions
	G4QGSMFragmentation ()
	~G4QGSMFragmentation ()
virtual G4KineticTrackVector *	FragmentString (const G4ExcitedString &theString)

---

Detailed Description

Definition at line 40 of file G4QGSMFragmentation.hh.

---

Constructor & Destructor Documentation

G4QGSMFragmentation::G4QGSMFragmentation

(

)

Definition at line 45 of file G4QGSMFragmentation.cc.

                                         :
arho(0.5), aphi(0.), an(-0.5), ala(-0.75), aksi(-1.), alft(0.5)
   {
   }

G4QGSMFragmentation::~G4QGSMFragmentation

(

)

Definition at line 50 of file G4QGSMFragmentation.cc.

   {
   }

---

Member Function Documentation

G4KineticTrackVector * G4QGSMFragmentation::FragmentString

(

const G4ExcitedString &

theString

)

[virtual]

Implements G4VLongitudinalStringDecay.

Definition at line 56 of file G4QGSMFragmentation.cc.

References C1, G4VLongitudinalStringDecay::CalculateHadronTimePosition(), G4VLongitudinalStringDecay::CPExcited(), G4ExcitedString::Get4Momentum(), G4FragmentingString::GetDecayDirection(), G4ExcitedString::GetPosition(), G4VLongitudinalStringDecay::LightFragmentationTest(), G4VLongitudinalStringDecay::PastInitPhase, G4VLongitudinalStringDecay::Splitup(), G4VLongitudinalStringDecay::StringLoopInterrupt, and G4ExcitedString::TransformToAlignedCms().

{
//    Can no longer modify Parameters for Fragmentation.
        PastInitPhase=true;
        
//      check if string has enough mass to fragment...
        G4KineticTrackVector * LeftVector=LightFragmentationTest(&theString);
        if ( LeftVector != 0 ) return LeftVector;
        
        LeftVector = new G4KineticTrackVector;
        G4KineticTrackVector * RightVector=new G4KineticTrackVector;

// this should work but its only a semi deep copy. %GF  G4ExcitedString theStringInCMS(theString);
        G4ExcitedString *theStringInCMS=CPExcited(theString);
        G4LorentzRotation toCms=theStringInCMS->TransformToAlignedCms();

        G4bool success=false, inner_sucess=true;
        G4int attempt=0;
        while ( !success && attempt++ < StringLoopInterrupt )
        {
                G4FragmentingString *currentString=new G4FragmentingString(*theStringInCMS);

                std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
                LeftVector->clear();
                std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
                RightVector->clear();
                
                inner_sucess=true;  // set false on failure..
                while (! StopFragmenting(currentString) )
                {  // Split current string into hadron + new string
                        G4FragmentingString *newString=0;  // used as output from SplitUp...
                        G4KineticTrack * Hadron=Splitup(currentString,newString);
                        if ( Hadron != 0 && IsFragmentable(newString)) 
                        {
                           if ( currentString->GetDecayDirection() > 0 )
                                   LeftVector->push_back(Hadron);
                           else
                                   RightVector->push_back(Hadron);
                           delete currentString;
                           currentString=newString;
                        } else {
                         // abandon ... start from the beginning
                           if (newString) delete newString;          // Uzhi restore 20.06.08
                           if (Hadron)    delete Hadron;
                           inner_sucess=false;
                           break;
                        }
                } 
                // Split current string into 2 final Hadrons
                if ( inner_sucess && 
                     SplitLast(currentString,LeftVector, RightVector) ) 
                {
                        success=true;
                }
                delete currentString;
        }
        
        delete theStringInCMS;
        
        if ( ! success )
        {
                std::for_each(LeftVector->begin(), LeftVector->end(), DeleteKineticTrack());
                LeftVector->clear();
                std::for_each(RightVector->begin(), RightVector->end(), DeleteKineticTrack());
                delete RightVector;
                return LeftVector;
        }
                
        // Join Left- and RightVector into LeftVector in correct order.
        while(!RightVector->empty())
        {
            LeftVector->push_back(RightVector->back());
            RightVector->erase(RightVector->end()-1);
        }
        delete RightVector;

        CalculateHadronTimePosition(theString.Get4Momentum().mag(), LeftVector);

        G4LorentzRotation toObserverFrame(toCms.inverse());

        for(size_t C1 = 0; C1 < LeftVector->size(); C1++)
        {
           G4KineticTrack* Hadron = LeftVector->operator[](C1);
           G4LorentzVector Momentum = Hadron->Get4Momentum();
           Momentum = toObserverFrame*Momentum;
           Hadron->Set4Momentum(Momentum);
           G4LorentzVector Coordinate(Hadron->GetPosition(), Hadron->GetFormationTime());
           Momentum = toObserverFrame*Coordinate;
           Hadron->SetFormationTime(Momentum.e());
           G4ThreeVector aPosition(Momentum.vect());
           Hadron->SetPosition(theString.GetPosition()+aPosition);
        }
        return LeftVector;
                


}

---

The documentation for this class was generated from the following files:

• G4QGSMFragmentation.hh
• G4QGSMFragmentation.cc

---