Ignore:
Timestamp:
Nov 5, 2010, 3:45:55 PM (14 years ago)
Author:
garnier
Message:

update ti head

Location:
trunk/source/processes/hadronic/models/parton_string
Files:
45 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/processes/hadronic/models/parton_string/diffraction/History

    r1337 r1340  
    1 $Id: History,v 1.31 2010/06/14 16:28:32 gcosmo Exp $
     1$Id: History,v 1.33 2010/09/20 15:55:33 vuzhinsk Exp $
    22-------------------------------------------------------------------
    33
    … …  
    1515     * Please list in reverse chronological order (last date on top)
    1616     ---------------------------------------------------------------
     1720 Sept. 2010, V, Uzhinsky (hadr-string-diff-V09-03-03)
     18FTF with new tuned parameters of nuclear destrustion is implemented.
     19The parameters were tuned using HARP-CDP data on p+Cu interactions.
     20They will be re-tuned for heavy nuclei a little bit.
     21
     22----------------------------------------------------
     238 Sept 2010 G.Folger  (hadr-string-diff-V09-03-02)
     24   G4FTFModel.cc: use integer interace of G4Nucleus     
    1725
    182614 Jun 2010 G.Cosmo  (hadr-string-diff-V09-03-01)

  • trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4DiffractiveSplitableHadron.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4DiffractiveSplitableHadron.hh,v 1.5 2009/08/03 13:14:19 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4DiffractiveSplitableHadron.hh,v 1.6 2010/09/20 15:50:46 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4FTFModel.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4FTFModel.hh,v 1.10 2009/10/25 10:50:54 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4FTFModel.hh,v 1.11 2010/09/20 15:50:46 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// Class Description

  • trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4FTFParameters.hh

    r1337 r1340  
    2727#define G4FTFParameters_h 1
    2828//
    29 // $Id: G4FTFParameters.hh,v 1.7 2009/10/25 10:50:54 vuzhinsk Exp $
    30 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     29// $Id: G4FTFParameters.hh,v 1.8 2010/09/20 15:50:46 vuzhinsk Exp $
     30// GEANT4 tag $Name: geant4-09-03-ref-09 $
    3131//
    3232#include "G4Proton.hh"
    … …  
    8181
    8282// --------- Set parameters of nuclear destruction--------------------
     83        void SetMaxNumberOfCollisions(const G4double aValue, const G4double bValue);
     84        void SetProbOfInteraction(const G4double aValue);
     85
    8386        void SetCofNuclearDestruction(const G4double aValue);
    8487        void SetR2ofNuclearDestruction(const G4double aValue);
    … …  
    125128
    126129// --------- Get parameters of nuclear destruction---------------------
     130        G4double GetMaxNumberOfCollisions();
     131        G4double GetProbOfInteraction();
     132
    127133        G4double GetCofNuclearDestruction();
    128134        G4double GetR2ofNuclearDestruction();
    … …  
    171177
    172178// --------- Parameters of nuclear destruction------------------------
     179        G4double MaxNumberOfCollisions;
     180        G4double ProbOfInelInteraction;
     181
    173182        G4double CofNuclearDestruction;         // Cnd of nuclear destruction
    174183        G4double R2ofNuclearDestruction;        // R2nd
    … …  
    260269
    261270// --------- Set parameters of nuclear destruction--------------------
     271inline   void G4FTFParameters::SetMaxNumberOfCollisions(const G4double Plab,
     272                                                        const G4double Pbound)
     273              {
     274               if(Plab > Pbound)
     275               {
     276                MaxNumberOfCollisions = Plab/Pbound;
     277                SetProbOfInteraction(-1.);
     278               } else
     279               {
     280//                MaxNumberOfCollisions = -1.;
     281//                SetProbOfInteraction(std::exp(0.25*(Plab-Pbound)));
     282                MaxNumberOfCollisions = 1;
     283                SetProbOfInteraction(-1.);
     284               }
     285              }
     286inline  void G4FTFParameters::SetProbOfInteraction(const G4double aValue)
     287             {ProbOfInelInteraction = aValue;}
     288
    262289inline  void G4FTFParameters::SetCofNuclearDestruction(const G4double aValue)
    263290             {CofNuclearDestruction = aValue;}
    … …  
    325352
    326353// --------- Get parameters of nuclear destruction---------------------
     354inline  G4double G4FTFParameters::GetMaxNumberOfCollisions(){return MaxNumberOfCollisions;}
     355inline  G4double G4FTFParameters::GetProbOfInteraction()    {return ProbOfInelInteraction;}
     356
    327357inline  G4double G4FTFParameters::GetCofNuclearDestruction(){return CofNuclearDestruction;}
    328358inline  G4double G4FTFParameters::GetR2ofNuclearDestruction(){return R2ofNuclearDestruction;}

  • trunk/source/processes/hadronic/models/parton_string/diffraction/include/G4FTFParticipants.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4FTFParticipants.hh,v 1.6 2009/08/03 13:14:19 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4FTFParticipants.hh,v 1.7 2010/09/20 15:50:46 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4DiffractiveExcitation.cc

    r1228 r1340  
    2525//
    2626//
    27 // $Id: G4DiffractiveExcitation.cc,v 1.21 2009/12/15 19:14:31 vuzhinsk Exp $
     27// $Id: G4DiffractiveExcitation.cc,v 1.22 2010/09/20 15:50:46 vuzhinsk Exp $
    2828// ------------------------------------------------------------
    2929//      GEANT 4 class implemetation file
    … …  
    108108     G4int    TargetPDGcode=target->GetDefinition()->GetPDGEncoding();
    109109     G4int    absTargetPDGcode=std::abs(TargetPDGcode);
     110//G4cout<<"Excit "<<ProjectilePDGcode<<" "<<TargetPDGcode<<G4endl;
    110111
    111112     G4LorentzVector Ptarget=target->Get4Momentum();
    … …  
    113114     G4double M0target = Ptarget.mag();
    114115
    115      G4double TargetRapidity = Ptarget.rapidity();
     116//   G4double TargetRapidity = Ptarget.rapidity();
    116117
    117118     if(M0target < target->GetDefinition()->GetPDGMass())
    … …  
    129130     G4double AveragePt2=theParameters->GetAveragePt2();
    130131
    131      G4double ProbOfDiffraction=ProbProjectileDiffraction +
    132                                 ProbTargetDiffraction;
     132//     G4double ProbOfDiffraction=ProbProjectileDiffraction +
     133//                                ProbTargetDiffraction;
    133134
    134135     G4double SumMasses=M0projectile+M0target+200.*MeV;
    … …  
    162163
    163164     G4double SqrtS=std::sqrt(S);
    164               
     165           
    165166     if(absProjectilePDGcode > 1000 && (SqrtS < 2300*MeV || SqrtS < SumMasses))
    166167     {target->SetStatus(2);  return false;}  // The model cannot work for
    … …  
    215216
    216217     G4double maxPtSquare; // = PZcms2;
    217 
     218/*
     219G4cout<<"Start --------------------"<<G4endl;
     220G4cout<<"Proj "<<M0projectile<<" "<<ProjectileDiffStateMinMass<<"  "<<ProjectileNonDiffStateMinMass<<G4endl;
     221G4cout<<"Targ "<<M0target    <<" "<<TargetDiffStateMinMass    <<" "<<TargetNonDiffStateMinMass<<G4endl;
     222G4cout<<"SqrtS "<<SqrtS<<G4endl;
     223G4cout<<"Rapid "<<ProjectileRapidity<<" "<<TargetRapidity<<G4endl;
     224*/
    218225// Charge exchange can be possible for baryons -----------------
    219226
    … …  
    223230     G4double DeltaProbAtQuarkExchange=theParameters->GetDeltaProbAtQuarkExchange();
    224231
     232//G4cout<<"Q exc "<<MagQuarkExchange<<" "<<SlopeQuarkExchange<<" "<<DeltaProbAtQuarkExchange<<G4endl;
    225233//     G4double NucleonMass=
    226234//              (G4ParticleTable::GetParticleTable()->FindParticle(2112))->GetPDGMass();     
    … …  
    228236              (G4ParticleTable::GetParticleTable()->FindParticle(2224))->GetPDGMass();
    229237
    230 // Check for possible quark excjane -----------------------------------
     238//G4cout<<MagQuarkExchange*std::exp(-SlopeQuarkExchange*(ProjectileRapidity - TargetRapidity))<<G4endl;
     239//G4cout<<MagQuarkExchange*std::exp(-SlopeQuarkExchange*(ProjectileRapidity))<<G4endl;
     240//G4cout<<MagQuarkExchange*std::exp(-SlopeQuarkExchange*(ProjectileRapidity - 1.36))<<G4endl;
     241//G4int Uzhi; G4cin>>Uzhi;
     242// Check for possible quark exchange -----------------------------------
     243
    231244     if(G4UniformRand() < MagQuarkExchange*
    232         std::exp(-SlopeQuarkExchange*(ProjectileRapidity - TargetRapidity)))
     245        std::exp(-SlopeQuarkExchange*ProjectileRapidity))  //TargetRapidity))) 1.45
    233246     {   
     247//        std::exp(-SlopeQuarkExchange*(ProjectileRapidity - 1.36)))  //TargetRapidity))) 1.45
     248//G4cout<<"Q exchange"<<G4endl;
    234249      G4int NewProjCode(0), NewTargCode(0);
    235250
    … …  
    249264      UnpackBaryon(TargetPDGcode, TargQ1, TargQ2, TargQ3);
    250265
     266//G4cout<<ProjQ1<<" "<<ProjQ2<<" "<<ProjQ3<<G4endl;
     267//G4cout<<TargQ1<<" "<<TargQ2<<" "<<TargQ3<<G4endl;
    251268// Sampling of exchanged quarks -------------------
    252269      G4int ProjExchangeQ(0);
    … …  
    326343        {ProjExchangeQ = ProjQ3;}
    327344
     345//G4cout<<"ProjExchangeQ "<<ProjExchangeQ<<G4endl;
    328346        if((ProjExchangeQ != TargQ1)||(G4UniformRand()<Same))
    329347        {
    … …  
    338356        }
    339357
     358//G4cout<<"ProjExchangeQ "<<ProjExchangeQ<<G4endl;
     359//G4cout<<"TargExchangeQ "<<TargExchangeQ<<G4endl;
    340360        if( Ksi < 0.333333 )
    341361        {ProjQ1=ProjExchangeQ;}
    … …  
    376396
    377397       NewProjCode = NewNucleonId(ProjQ1, ProjQ2, ProjQ3); // *****************************
     398
     399//G4cout<<"ProjQ1, ProjQ2, ProjQ3 "<<ProjQ1<<" "<<ProjQ2<<" "<<ProjQ3<<" "<<NewProjCode<<G4endl;
     400
     401G4int                 TestParticleID=NewProjCode;
     402G4ParticleDefinition* TestParticle=0;
     403G4double              TestParticleMass=DBL_MAX;
     404
     405TestParticle=G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode);
     406if(TestParticle) TestParticleMass=TestParticle->GetPDGMass();
    378407
    379408       if((ProjQ1==ProjQ2) && (ProjQ1==ProjQ3)) {NewProjCode +=2; ProjDeltaHasCreated=true;}
    … …  
    390419       }
    391420
     421G4ParticleDefinition* NewTestParticle=
     422                      G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode);
     423//G4cout<<"TestParticleMass NewTestParticle->GetPDGMass() "<<TestParticleMass<<" "<< NewTestParticle->GetPDGMass()<<G4endl;
     424//if(TestParticleMass < NewTestParticle->GetPDGMass()) {NewProjCode=TestParticleID;}
     425 
     426//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++=
     427
    392428       NewTargCode = NewNucleonId(TargQ1, TargQ2, TargQ3); // *****************************
     429
     430//G4cout<<"TargQ1, TargQ2, TargQ3 "<<TargQ1<<" "<<TargQ2<<" "<<TargQ3<<" "<<NewTargCode<<G4endl;
     431
     432TestParticleID=NewTargCode;
     433TestParticleMass=DBL_MAX;
     434
     435TestParticle=G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode);
     436if(TestParticle) TestParticleMass=TestParticle->GetPDGMass();
    393437
    394438       if((TargQ1==TargQ2) && (TargQ1==TargQ3)) {NewTargCode +=2; TargDeltaHasCreated=true;} 
    … …  
    405449       }         
    406450
     451NewTestParticle=G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode);
     452//G4cout<<"TestParticleMass NewTestParticle->GetPDGMass() "<<TestParticleMass<<" "<< NewTestParticle->GetPDGMass()<<G4endl;
     453//if(TestParticleMass < NewTestParticle->GetPDGMass()) {NewTargCode=TestParticleID;}
     454
     455//G4cout<<"NewProjCode NewTargCode "<<NewProjCode<<" "<<NewTargCode<<G4endl;
     456//G4int Uzhi; G4cin>>Uzhi;
     457
    407458       if((absProjectilePDGcode == NewProjCode) && (absTargetPDGcode == NewTargCode))
    408459       { // Nothing was changed! It is not right!?
    409460       }
    410461// Forming baryons --------------------------------------------------
    411 
     462if(ProjDeltaHasCreated) {ProbProjectileDiffraction=1.; ProbTargetDiffraction=0.;}
     463if(TargDeltaHasCreated) {ProbProjectileDiffraction=0.; ProbTargetDiffraction=1.;}
     464       if(ProjDeltaHasCreated)
     465       {
     466        M0projectile=
     467          (G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode))->GetPDGMass();
     468        M0projectile2 = M0projectile * M0projectile;
     469
     470        ProjectileDiffStateMinMass   =M0projectile+210.*MeV; //210 MeV=m_pi+70 MeV
     471        ProjectileNonDiffStateMinMass=M0projectile+210.*MeV; //210 MeV=m_pi+70 MeV
     472       }
     473
     474//      if(M0target <
     475//         (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass())
     476       if(TargDeltaHasCreated)
     477       {
     478        M0target=
     479          (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass();
     480        M0target2 = M0target * M0target;
     481
     482        TargetDiffStateMinMass   =M0target+210.*MeV;         //210 MeV=m_pi+70 MeV;   
     483        TargetNonDiffStateMinMass=M0target+210.*MeV;         //210 MeV=m_pi+70 MeV;
     484       }
    412485      } // End of if projectile is baryon ---------------------------
    413486
    … …  
    416489// in the ground states, we have to put ----------------------------------
    417490
    418       if(M0projectile <
    419          (G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode))->GetPDGMass())
     491/*
     492//      if(M0projectile <
     493//         (G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode))->GetPDGMass())
     494      if(ProjDeltaHasCreated)
    420495      {
    421496       M0projectile=
    422497         (G4ParticleTable::GetParticleTable()->FindParticle(NewProjCode))->GetPDGMass();
    423498       M0projectile2 = M0projectile * M0projectile;
     499
     500       ProjectileDiffStateMinMass   =M0projectile+160.*MeV; //160 MeV=m_pi+20 MeV
     501       ProjectileNonDiffStateMinMass=M0projectile+160.*MeV; //160 MeV=m_pi+20 MeV
    424502      }
    425503
    426       if(M0target <
    427          (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass())
     504//      if(M0target <
     505//         (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass())
     506      if(TargDeltaHasCreated)
    428507      {
    429508       M0target=
    430509         (G4ParticleTable::GetParticleTable()->FindParticle(NewTargCode))->GetPDGMass();
    431510       M0target2 = M0target * M0target;
     511
     512       TargetDiffStateMinMass   =M0target+160.*MeV;         //160 MeV=m_pi+20 MeV;   
     513       TargetNonDiffStateMinMass=M0target+160.*MeV;         //160 MeV=m_pi+20 MeV;
    432514      }
    433 
     515*/
    434516      PZcms2=(S*S+M0projectile2*M0projectile2+M0target2*M0target2-
    435517             2*S*M0projectile2 - 2*S*M0target2 - 2*M0projectile2*M0target2)
    436518             /4./S;
    437 
     519//G4cout<<"PZcms2 1 "<<PZcms2<<G4endl;
    438520      if(PZcms2 < 0) {return false;}  // It can be if energy is not sufficient for Delta
    439521//----------------------------------------------------------
    … …  
    452534      Ptarget.setE(std::sqrt(M0target2+PZcms2));
    453535
    454       {
     536// ----------------------------------------------------------
     537
     538//      G4double Wexcit=1.-1.97*std::exp(-0.5*ProjectileRapidity);
     539      G4double Wexcit=1.-2.256*std::exp(-0.6*ProjectileRapidity);
     540
     541//G4cout<<ProjectileRapidity<<" "<<1.72*std::exp(-0.4*ProjectileRapidity)<<" "<<std::exp(0.4*ProjectileRapidity)<<G4endl;
     542//G4int Uzhi;G4cin>>Uzhi;
     543//Wexcit=0.;
     544      if(G4UniformRand() > Wexcit)
     545      {                             // Make elastic scattering
     546//G4cout<<"Make elastic scattering"<<G4endl;
    455547       Pprojectile.transform(toLab);
    456548       Ptarget.transform(toLab);
    … …  
    463555
    464556       G4bool Result= theElastic->ElasticScattering (projectile,target,theParameters);
    465 
    466557       return Result;
    467       }
     558      } // end of if(G4UniformRand() > Wexcit)
    468559     }  // End of charge exchange part ------------------------------
    469560
    470561// ------------------------------------------------------------------
     562     G4double ProbOfDiffraction=ProbProjectileDiffraction + ProbTargetDiffraction;
     563/*
     564G4cout<<"Excite --------------------"<<G4endl;
     565G4cout<<"Proj "<<M0projectile<<" "<<ProjectileDiffStateMinMass<<"  "<<ProjectileNonDiffStateMinMass<<G4endl;
     566G4cout<<"Targ "<<M0target    <<" "<<TargetDiffStateMinMass    <<" "<<TargetNonDiffStateMinMass<<G4endl;
     567G4cout<<"SqrtS "<<SqrtS<<G4endl;
     568
     569G4cout<<"Prob ProjDiff TargDiff "<<ProbProjectileDiffraction<<" "<<ProbTargetDiffraction<<" "<<ProbOfDiffraction<<G4endl;
     570G4cout<<"Pr Y "<<Pprojectile.rapidity()<<" Tr Y "<<Ptarget.rapidity()<<G4endl;
     571//G4int Uzhi; G4cin>>Uzhi;
     572*/
     573/*
     574     if(ProjectileNonDiffStateMinMass + TargetNonDiffStateMinMass > SqrtS) // 24.07.10
     575     {
     576      if(ProbOfDiffraction!=0.)
     577      {
     578       ProbProjectileDiffraction/=ProbOfDiffraction;
     579       ProbOfDiffraction=1.;
     580      } else {return false;}     
     581     }
     582
     583*/
     584
    471585     if(ProbOfDiffraction!=0.)
    472586     {
    … …  
    478592     }
    479593
     594//G4cout<<"Prob ProjDiff TargDiff "<<ProbProjectileDiffraction<<" "<<ProbTargetDiffraction<<" "<<ProbOfDiffraction<<G4endl;
     595
    480596     G4double ProjectileDiffStateMinMass2    = ProjectileDiffStateMinMass    *
    481597                                               ProjectileDiffStateMinMass;
    … …  
    500616
    501617     G4int whilecount=0;
     618
    502619//   Choose a process ---------------------------
    503620
    … …  
    506623        if(G4UniformRand() < ProbProjectileDiffraction)
    507624        { //-------- projectile diffraction ---------------
     625//G4cout<<"projectile diffraction"<<G4endl;
     626
    508627         do {
    509628//             Generate pt
    … …  
    512631//               << ", loop count/ maxPtSquare : "
    513632//               << whilecount << " / " << maxPtSquare << G4endl;
     633
     634//             whilecount++;
    514635             if (whilecount > 1000 )
    515636             {
    … …  
    517638              target->SetStatus(2);  return false;    //  Ignore this interaction
    518639             };
     640
    519641// --------------- Check that the interaction is possible -----------
    520642             ProjMassT2=ProjectileDiffStateMinMass2;
    … …  
    523645             TargMassT2=M0target2;
    524646             TargMassT =M0target;
    525 
     647//G4cout<<"Masses "<<ProjMassT<<" "<<TargMassT<<" "<<SqrtS<<" "<<ProjMassT+TargMassT<<G4endl;
    526648             PZcms2=(S*S + ProjMassT2*ProjMassT2 + TargMassT2*TargMassT2-
    527649                     2.*S*ProjMassT2-2.*S*TargMassT2-2.*ProjMassT2*TargMassT2)
    528650                    /4./S;
    529651
     652//G4cout<<"PZcms2 PrD"<<PZcms2<<G4endl;
    530653             if(PZcms2 < 0 )
    531654             {
    … …  
    556679             PMinusNew=ChooseP(PMinusMin, PMinusMax);
    557680// PMinusNew=1./sqrt(1./PMinusMin-G4UniformRand()*(1./PMinusMin-1./PMinusMax));
     681//PMinusNew=1./sqr(1./std::sqrt(PMinusMin)-G4UniformRand()*(1./std::sqrt(PMinusMin)-1./std::sqrt(PMinusMax)));
    558682
    559683             TMinusNew=SqrtS-PMinusNew;
    … …  
    564688             Qmomentum.setPz( (Qplus-Qminus)/2 );
    565689             Qmomentum.setE(  (Qplus+Qminus)/2 );
    566           } while (
    567 ((Pprojectile+Qmomentum).mag2() <  ProjectileDiffStateMinMass2) ||  //No without excitation
    568 ((Ptarget    -Qmomentum).mag2() <  M0target2                  ));
     690
     691          } while ((Pprojectile+Qmomentum).mag2() <  ProjectileDiffStateMinMass2); //|| 
     692                  //Repeat the sampling because there was not any excitation
     693//((Ptarget    -Qmomentum).mag2() <  M0target2                  )) );
    569694        }
    570695        else
    571696        { // -------------- Target diffraction ----------------
     697
     698//G4cout<<"Target diffraction"<<G4endl;
    572699         do {
    573700//             Generate pt
    … …  
    576703//               << ", loop count/ maxPtSquare : "
    577704//               << whilecount << " / " << maxPtSquare << G4endl;
     705
     706//             whilecount++;
    578707             if (whilecount > 1000 )
    579708             {
    … …  
    581710              target->SetStatus(2);  return false;    //  Ignore this interaction
    582711             };
     712//G4cout<<"Qm while "<<Qmomentum<<" "<<whilecount<<G4endl;
    583713// --------------- Check that the interaction is possible -----------
    584714             ProjMassT2=M0projectile2;
    … …  
    592722                    /4./S;
    593723
     724//G4cout<<"PZcms2 TrD <0 "<<PZcms2<<" return"<<G4endl;
    594725             if(PZcms2 < 0 )
    595726             {
    … …  
    600731
    601732             Qmomentum=G4LorentzVector(GaussianPt(AveragePt2,maxPtSquare),0);
     733
     734//G4cout<<"Qm while "<<Qmomentum<<" "<<whilecount<<G4endl;
    602735             Pt2=G4ThreeVector(Qmomentum.vect()).mag2();
    603736
    … …  
    612745                    /4./S;
    613746
     747//G4cout<<"PZcms2 <0 "<<PZcms2<<" continue"<<G4endl;
    614748             if(PZcms2 < 0 ) continue;
    615749             PZcms =std::sqrt(PZcms2);
    … …  
    619753
    620754             TPlusNew=ChooseP(TPlusMin, TPlusMax);
     755//TPlusNew=1./sqr(1./std::sqrt(TPlusMin)-G4UniformRand()*(1./std::sqrt(TPlusMin)-1./std::sqrt(TPlusMax)));
    621756
    622757//TPlusNew=TPlusMax;
    … …  
    630765             Qmomentum.setE(  (Qplus+Qminus)/2 );
    631766
    632           } while (
    633  ((Pprojectile+Qmomentum).mag2() <  M0projectile2          ) ||  //No without excitation
    634  ((Ptarget    -Qmomentum).mag2() <  TargetDiffStateMinMass2));
    635          }
     767/*
     768G4cout<<(Pprojectile+Qmomentum).mag()<<" "<<M0projectile<<G4endl;
     769G4bool First=(Pprojectile+Qmomentum).mag2() <  M0projectile2;
     770G4cout<<First<<G4endl;
     771
     772G4cout<<(Ptarget    -Qmomentum).mag()<<" "<<TargetDiffStateMinMass<<" "<<TargetDiffStateMinMass2<<G4endl;
     773G4bool Seco=(Ptarget    -Qmomentum).mag2() < TargetDiffStateMinMass2;
     774G4cout<<Seco<<G4endl;
     775*/
     776
     777         } while ((Ptarget    -Qmomentum).mag2() <  TargetDiffStateMinMass2);
     778                 // Repeat the sampling because there was not any excitation
     779// (((Pprojectile+Qmomentum).mag2() <  M0projectile2          ) ||  //No without excitation
     780//  ((Ptarget    -Qmomentum).mag2() <  TargetDiffStateMinMass2)) );
     781//G4cout<<"Go out"<<G4endl;
     782         } // End of if(G4UniformRand() < ProbProjectileDiffraction)
    636783        }
    637784        else  //----------- Non-diffraction process ------------
    638785        {
     786
     787//G4cout<<"Non-diffraction process"<<G4endl;
    639788         do {
    640789//             Generate pt
    … …  
    643792//               << ", loop count/ maxPtSquare : "
    644793//               << whilecount << " / " << maxPtSquare << G4endl;
     794
     795//             whilecount++;
    645796             if (whilecount > 1000 )
    646797             {
    … …  
    677828                    2.*S*ProjMassT2-2.*S*TargMassT2-2.*ProjMassT2*TargMassT2)
    678829                   /4./S;
     830//G4cout<<"PZcms2 ND"<<PZcms2<<G4endl;
    679831
    680832             if(PZcms2 < 0 ) continue;
    … …  
    698850             Qmomentum.setPz( (Qplus-Qminus)/2 );
    699851             Qmomentum.setE(  (Qplus+Qminus)/2 );
    700 
     852/*
     853G4cout<<(Pprojectile+Qmomentum).mag2()<<" "<<ProjectileNonDiffStateMinMass2<<G4endl;
     854G4cout<<(Ptarget    -Qmomentum).mag2()<<" "<<TargetNonDiffStateMinMass2<<G4endl;
     855G4int Uzhi; G4cin>>Uzhi;
     856*/
    701857       } while (
    702858 ((Pprojectile+Qmomentum).mag2() <  ProjectileNonDiffStateMinMass2) || //No double Diffraction
    703859 ((Ptarget    -Qmomentum).mag2() <  TargetNonDiffStateMinMass2    ));
    704          }
    705 
    706            Pprojectile += Qmomentum;
    707            Ptarget     -= Qmomentum;
     860     }
     861
     862     Pprojectile += Qmomentum;
     863     Ptarget     -= Qmomentum;
     864
     865//G4cout<<"Pr Y "<<Pprojectile.rapidity()<<" Tr Y "<<Ptarget.rapidity()<<G4endl;
    708866
    709867// Transform back and update SplitableHadron Participant.
    710            Pprojectile.transform(toLab);
    711            Ptarget.transform(toLab);
     868     Pprojectile.transform(toLab);
     869     Ptarget.transform(toLab);
    712870
    713871// Calculation of the creation time ---------------------
    714       projectile->SetTimeOfCreation(target->GetTimeOfCreation());
    715       projectile->SetPosition(target->GetPosition());
     872     projectile->SetTimeOfCreation(target->GetTimeOfCreation());
     873     projectile->SetPosition(target->GetPosition());
    716874// Creation time and position of target nucleon were determined at
    717875// ReggeonCascade() of G4FTFModel
    718876// ------------------------------------------------------
    719877
    720            projectile->Set4Momentum(Pprojectile);
    721            target->Set4Momentum(Ptarget);
    722 
    723            projectile->IncrementCollisionCount(1);
    724            target->IncrementCollisionCount(1);
    725 
    726            return true;
     878//G4cout<<"Mproj "<<Pprojectile.mag()<<G4endl;
     879//G4cout<<"Mtarg "<<Ptarget.mag()<<G4endl;
     880     projectile->Set4Momentum(Pprojectile);
     881     target->Set4Momentum(Ptarget);
     882
     883     projectile->IncrementCollisionCount(1);
     884     target->IncrementCollisionCount(1);
     885
     886     return true;
    727887}
    728888

  • trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4DiffractiveSplitableHadron.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4DiffractiveSplitableHadron.cc,v 1.8 2009/07/31 11:03:00 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4DiffractiveSplitableHadron.cc,v 1.9 2010/09/20 15:50:46 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4FTFModel.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4FTFModel.cc,v 1.34 2009/12/15 19:14:31 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4FTFModel.cc,v 1.36 2010/09/20 15:50:46 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030
    … …  
    9999{
    100100        theProjectile = aProjectile; 
    101         theParticipants.Init(aNucleus.GetN(),aNucleus.GetZ());
     101
     102        theParticipants.Init(aNucleus.GetA_asInt(),aNucleus.GetZ_asInt());
     103
    102104// ----------- N-mass number Z-charge -------------------------
    103105
    … …  
    113115
    114116//theParameters->SetProbabilityOfElasticScatt(0.);
     117//G4cout<<theParameters->GetProbabilityOfElasticScatt()<<G4endl;
     118//G4int Uzhi; G4cin>>Uzhi;
    115119// To turn on/off (1/0) elastic scattering
    116120
    … …  
    125129{
    126130        G4ExcitedStringVector * theStrings(0);
    127 
     131//G4cout<<"GetString"<<G4endl;
    128132        theParticipants.GetList(theProjectile,theParameters);
    129 
     133//G4cout<<"Reggeon"<<G4endl;
    130134        ReggeonCascade();
    131135
    … …  
    133137        if( PutOnMassShell() )
    134138        {
     139//G4cout<<"PutOn mass Shell OK"<<G4endl;
    135140         if( ExciteParticipants() )
    136141         {
     142//G4cout<<"Excite partic OK"<<G4endl;
    137143          theStrings = BuildStrings();
    138 
     144//G4cout<<"Build String OK"<<G4endl;
    139145          GetResidualNucleus();
    140146
    … …  
    194200           TheInvolvedNucleon[NumberOfInvolvedNucleon]=TargetNucleon;
    195201           NumberOfInvolvedNucleon++;
    196 
     202//G4cout<<"Prim NumberOfInvolvedNucleon "<<NumberOfInvolvedNucleon<<G4endl;
    197203           G4double XofWoundedNucleon = TargetNucleon->GetPosition().x();
    198204           G4double YofWoundedNucleon = TargetNucleon->GetPosition().y();
    … …  
    214220              TheInvolvedNucleon[NumberOfInvolvedNucleon]=Neighbour;
    215221              NumberOfInvolvedNucleon++;
     222//G4cout<<"Seco NumberOfInvolvedNucleon "<<NumberOfInvolvedNucleon<<G4endl;
    216223
    217224              G4VSplitableHadron *targetSplitable;
    … …  
    274281        G4LorentzVector Pprojectile=primary->Get4Momentum();
    275282
     283//G4cout<<"Pprojectile "<<Pprojectile<<G4endl;
    276284// To get original projectile particle
    277285
    … …  
    284292        G4double        SumMasses = Mprojectile + 20.*MeV; // 13.12.09
    285293                                               // Separation energy for projectile
    286 
     294//G4cout<<"SumMasses Pr "<<SumMasses<<G4endl;
    287295//--------------- Target nucleus ------------------------------
    288296        G4V3DNucleus *theNucleus = GetWoundedNucleus();
    … …  
    305313          SumMasses += aNucleon->GetDefinition()->GetPDGMass();
    306314          SumMasses += 20.*MeV;   // 13.12.09 Separation energy for a nucleon
     315//G4cout<<"SumMasses Tr "<<SumMasses<<G4endl;
    307316          ResidualMassNumber--;
    308317          ResidualCharge-=(G4int) aNucleon->GetDefinition()->GetPDGCharge();
    … …  
    316325
    317326        Psum += PnuclearResidual;
    318 
     327//G4cout<<"ResidualCharge ,ResidualMassNumber "<<ResidualCharge<<" "<<ResidualMassNumber<<G4endl;
    319328        G4double ResidualMass(0.);
    320329        if(ResidualMassNumber == 0)
    … …  
    331340 
    332341//      ResidualMass +=ResidualExcitationEnergy; // Will be given after checks
     342//G4cout<<"SumMasses End ResidualMass "<<SumMasses<<" "<<ResidualMass<<G4endl;
    333343        SumMasses += ResidualMass;
    334 
     344//G4cout<<"SumMasses + ResM "<<SumMasses<<G4endl;
     345//G4cout<<"Psum "<<Psum<<G4endl;
    335346//-------------------------------------------------------------
    336347
    … …  
    338349        G4double     S=Psum.mag2();
    339350
     351//G4cout<<"SqrtS < SumMasses "<<SqrtS<<" "<<SumMasses<<G4endl;
    340352        if(SqrtS < SumMasses)      {return false;} // It is impossible to simulate
    341353                                                   // after putting nuclear nucleons
    … …  
    346358        ResidualMass +=ResidualExcitationEnergy;
    347359        SumMasses    +=ResidualExcitationEnergy;
    348 
     360//G4cout<<"ResidualMass "<<ResidualMass<<" "<<SumMasses<<G4endl;
    349361//-------------------------------------------------------------
    350362// Sampling of nucleons what are transfered to delta-isobars --
    … …  
    373385        }   // end of if(theNucleus.GetMassNumber() != 1)
    374386//-------------------------------------------------------------
     387
    375388        G4LorentzRotation toCms(-1*Psum.boostVector());
    376389        G4LorentzVector Ptmp=toCms*Pprojectile;
    … …  
    393406        G4double AveragePt2  = theParameters->GetPt2ofNuclearDestruction();
    394407        G4double maxPtSquare = theParameters->GetMaxPt2ofNuclearDestruction();
    395 
     408//G4cout<<"Dcor "<<Dcor<<" AveragePt2 "<<AveragePt2<<G4endl;
    396409        G4double M2target(0.);
    397410        G4double WminusTarget(0.);
    … …  
    409422
    410423            NumberOfTries++;
     424//G4cout<<"NumberOfTries "<<NumberOfTries<<G4endl;
    411425            if(NumberOfTries == 100*(NumberOfTries/100))   // 100
    412426            { // At large number of tries it would be better to reduce the values
    … …  
    439453
    440454               G4LorentzVector tmp(tmpPt.x(),tmpPt.y(),Xminus,0.);
     455//G4cout<<"Inv i mom "<<i<<" "<<tmp<<G4endl;
    441456               aNucleon->SetMomentum(tmp);
    442457             }   // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
    … …  
    447462             G4double DeltaXminus(0.);
    448463
     464//G4cout<<"ResidualMassNumber "<<ResidualMassNumber<<" "<<PtSum<<G4endl;
    449465             if(ResidualMassNumber == 0)
    450466             {
    … …  
    457473              DeltaXminus = -1./theNucleus->GetMassNumber();
    458474             }
    459 
     475//G4cout<<"Dx y xmin "<<DeltaX<<" "<<DeltaY<<" "<<DeltaXminus<<G4endl;
    460476             XminusSum=1.;
    461477             M2target =0.;
    … …  
    467483               Xminus = aNucleon->Get4Momentum().pz() - DeltaXminus;
    468484               XminusSum-=Xminus;               
    469 
    470                if((Xminus <= 0.)   || (Xminus > 1.) ||
    471                   (XminusSum <=0.) || (XminusSum > 1.)) {InerSuccess=false; break;}
    472  
     485//G4cout<<" i X-sum "<<i<<" "<<Xminus<<" "<<XminusSum<<G4endl;
     486               if(ResidualMassNumber == 0)                // Uzhi 5.07.10
     487               {
     488                if((Xminus <= 0.)   || (Xminus > 1.))    {InerSuccess=false; break;}
     489               } else
     490               {
     491                if((Xminus <= 0.)   || (Xminus > 1.) ||
     492                   (XminusSum <=0.) || (XminusSum > 1.)) {InerSuccess=false; break;}
     493               }                                          // Uzhi 5.07.10
     494
    473495               G4double Px=aNucleon->Get4Momentum().px() - DeltaX;
    474496               G4double Py=aNucleon->Get4Momentum().py() - DeltaY;
    … …  
    482504             }   // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
    483505
     506//G4cout<<"Rescale O.K."<<G4endl;
     507
    484508             if(InerSuccess && (ResidualMassNumber != 0))
    485509             {
    486510              M2target +=(ResidualMass*ResidualMass + PtSum.mag2())/XminusSum;
    487511             }
     512//G4cout<<"InerSuccess "<<InerSuccess<<G4endl;
     513//G4int Uzhi;G4cin>>Uzhi;
    488514            } while(!InerSuccess);
    489515          } while (SqrtS < Mprojectile + std::sqrt(M2target));
    … …  
    495521          WminusTarget=(S-M2projectile+M2target+std::sqrt(DecayMomentum2))/2./SqrtS;
    496522          WplusProjectile=SqrtS - M2target/WminusTarget;
     523//G4cout<<"DecayMomentum2 "<<DecayMomentum2<<G4endl;
    497524//-------------------------------------------------------------
    498525          for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
    … …  
    511538           if( E+Pz > WplusProjectile ){OuterSuccess=false; break;}
    512539          }   // end of for(G4int i=0; i < NumberOfInvolvedNucleon; i++ )
     540//G4int Uzhi;G4cin>>Uzhi;
    513541        } while(!OuterSuccess);
    514542
    … …  
    575603        Successfull=false;
    576604        theParticipants.StartLoop();
     605
     606G4int MaxNumOfInelCollisions=G4int(theParameters->GetMaxNumberOfCollisions());
     607G4double NumberOfInel(0.);
     608//
     609if(MaxNumOfInelCollisions > 0) 
     610{   //  Plab > Pbound, Normal application of FTF is possible
     611 G4double ProbMaxNumber=theParameters->GetMaxNumberOfCollisions()-MaxNumOfInelCollisions;
     612 if(G4UniformRand() < ProbMaxNumber) {MaxNumOfInelCollisions++;}
     613 NumberOfInel=MaxNumOfInelCollisions;
     614} else
     615{   //  Plab < Pbound, Normal application of FTF is impossible, low energy corrections
     616 if(theParticipants.theNucleus->GetMassNumber() > 1)
     617 {
     618  NumberOfInel = theParameters->GetProbOfInteraction();
     619  MaxNumOfInelCollisions = 1;
     620 } else
     621 { // Special case for hadron-nucleon interactions
     622  NumberOfInel = 1.;
     623  MaxNumOfInelCollisions = 1;
     624 }
     625}  // end of if(MaxNumOfInelCollisions > 0)
     626//
    577627        while (theParticipants.Next())
    578628        {         
    … …  
    581631           G4VSplitableHadron * projectile=collision.GetProjectile();
    582632           G4VSplitableHadron * target=collision.GetTarget();
    583 
     633//G4cout<<"ProbabilityOfElasticScatt "<<theParameters->GetProbabilityOfElasticScatt()<<G4endl;
    584634           if(G4UniformRand()< theParameters->GetProbabilityOfElasticScatt())
    585635           { //   Elastic scattering -------------------------
     636//G4cout<<"Elastic FTF"<<G4endl;
    586637            if(theElastic->ElasticScattering(projectile, target, theParameters))
    587638            {
    … …  
    595646           else
    596647           { //   Inelastic scattering ----------------------
     648/*
    597649            if(theExcitation->ExciteParticipants(projectile, target,
    598650                                                 theParameters, theElastic))
    … …  
    604656             target->SetStatus(2);
    605657            }
     658*/
     659//G4cout<<"InElastic FTF"<<G4endl;
     660            if(G4UniformRand()< NumberOfInel/MaxNumOfInelCollisions)
     661            {
     662             if(theExcitation->ExciteParticipants(projectile, target,
     663                                                 theParameters, theElastic))
     664             {
     665              Successfull = Successfull || true;
     666NumberOfInel--;
     667             } else
     668             {
     669              Successfull = Successfull || false;
     670              target->SetStatus(2);
     671             }
     672            } else // If NumOfInel
     673            {
     674             if(theElastic->ElasticScattering(projectile, target, theParameters))
     675             {
     676              Successfull = Successfull || true;
     677             } else
     678             {
     679              Successfull = Successfull || false;
     680              target->SetStatus(2);
     681             }
     682            }   // end if NumOfInel
    606683           }
    607684        }       // end of while (theParticipants.Next())
    … …  
    624701
    625702        theParticipants.StartLoop();    // restart a loop
    626 
     703//
    627704        while ( theParticipants.Next() )
    628705        {
    … …  
    634711                primaries.push_back(interaction.GetProjectile());     
    635712        }
    636            
     713
    637714        unsigned int ahadron;
    638715        for ( ahadron=0; ahadron < primaries.size() ; ahadron++)
    … …  
    650727            if(SecondString != 0) strings->push_back(SecondString);
    651728        }
    652 
     729//
    653730        for (G4int ahadron=0; ahadron < NumberOfInvolvedNucleon ; ahadron++)
    654731        {
    … …  
    669746        std::for_each(primaries.begin(), primaries.end(), DeleteVSplitableHadron());
    670747        primaries.clear();
    671 
    672748        return strings;
    673749}

  • trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4FTFParameters.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4FTFParameters.cc,v 1.13 2009/12/16 17:51:15 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4FTFParameters.cc,v 1.14 2010/09/20 15:50:46 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030
    … …  
    5656    G4double Plab = std::sqrt(Elab * Elab - ProjectileMass*ProjectileMass);
    5757
     58    G4double Ylab=0.5*std::log((Elab+Plab)/(Elab-Plab));
     59
     60    Plab/=GeV;                               // Uzhi 8.07.10
    5861    G4double LogPlab = std::log( Plab );
    5962    G4double sqrLogPlab = LogPlab * LogPlab;
    … …  
    186189      SetInelasticCrossSection(Xtotal-Xelastic);
    187190
     191//G4cout<<"Xtotal, Xelastic "<<Xtotal<<" "<<Xelastic<<G4endl;
    188192//  // Interactions with elastic and inelastic collisions
    189193      SetProbabilityOfElasticScatt(Xtotal, Xelastic);
    … …  
    196200
    197201//----------------------------------------------------------------------------------- 
     202
    198203      SetSlope( Xtotal*Xtotal/16./pi/Xelastic/0.3894 ); // Slope parameter of elastic scattering
    199204                                                        //      (GeV/c)^(-2))
    … …  
    209214           if( absPDGcode > 1000 )                        //------Projectile is baryon --------
    210215             {
    211               SetMagQuarkExchange(3.4); //3.8);
    212               SetSlopeQuarkExchange(1.2);
    213               SetDeltaProbAtQuarkExchange(0.1); //(0.1*4.);
    214 
    215               SetProjMinDiffMass(1.1);                    // GeV
    216               SetProjMinNonDiffMass(1.1);                 // GeV
    217               SetProbabilityOfProjDiff(0.76*std::pow(s/GeV/GeV,-0.35));
    218 
    219               SetTarMinDiffMass(1.1);                     // GeV
    220               SetTarMinNonDiffMass(1.1);                  // GeV
    221               SetProbabilityOfTarDiff(0.76*std::pow(s/GeV/GeV,-0.35));
    222 
    223               SetAveragePt2(0.3);                         // GeV^2
     216              SetMagQuarkExchange(1.84);//(3.63);
     217              SetSlopeQuarkExchange(0.7);//(1.2);
     218              SetDeltaProbAtQuarkExchange(0.);
     219
     220              SetProjMinDiffMass(1.16);                   // GeV
     221              SetProjMinNonDiffMass(1.16);                // GeV
     222             
     223SetProbabilityOfProjDiff(0.805*std::exp(-0.35*Ylab));// 0.5
     224
     225              SetTarMinDiffMass(1.16);                    // GeV
     226              SetTarMinNonDiffMass(1.16);                 // GeV
     227             
     228SetProbabilityOfTarDiff(0.805*std::exp(-0.35*Ylab));// 0.5
     229
     230              SetAveragePt2(0.15);                        // 0.15 GeV^2
    224231             }
    225232           else if( absPDGcode == 211 || PDGcode ==  111) //------Projectile is Pion -----------
    … …  
    286293    if( absPDGcode < 1000 )
    287294    {
    288       SetCofNuclearDestruction(1.); //1.0);                 // for meson projectile
    289     } else if( theA > 20. )
     295      SetMaxNumberOfCollisions(1000.,1.); //(Plab,2.); //3.); ##############################
     296
     297      SetCofNuclearDestruction(0.3); //1.0);           // for meson projectile
     298
     299      SetDofNuclearDestruction(0.4);
     300      SetPt2ofNuclearDestruction(0.17*GeV*GeV);
     301      SetMaxPt2ofNuclearDestruction(1.0*GeV*GeV);
     302
     303      SetExcitationEnergyPerWoundedNucleon(100*MeV);
     304    } else                                             // for baryon projectile
    290305    {
    291       SetCofNuclearDestruction(0.2); //2);                 // for baryon projectile and heavy target
    292     } else
    293     {
    294       SetCofNuclearDestruction(0.2); //1.0);                 // for baryon projectile and light target
     306//      SetMaxNumberOfCollisions(Plab,0.1); //6.); // ##############################
     307      SetMaxNumberOfCollisions(Plab,4.); //6.); // ##############################
     308
     309      SetCofNuclearDestruction(0.62*std::exp(4.*(Ylab-2.1))/(1.+std::exp(4.*(Ylab-2.1))));
     310
     311      SetDofNuclearDestruction(0.4);
     312      SetPt2ofNuclearDestruction((0.035+
     313          0.04*std::exp(4.*(Ylab-2.5))/(1.+std::exp(4.*(Ylab-2.5))))*GeV*GeV); //0.09
     314      SetMaxPt2ofNuclearDestruction(1.0*GeV*GeV);
     315
     316      SetExcitationEnergyPerWoundedNucleon(75.*MeV);
    295317    }
    296318
    297319    SetR2ofNuclearDestruction(1.5*fermi*fermi);
    298320
    299     SetExcitationEnergyPerWoundedNucleon(100*MeV);
    300 
    301     SetDofNuclearDestruction(0.4);
    302     SetPt2ofNuclearDestruction(0.17*GeV*GeV);
    303     SetMaxPt2ofNuclearDestruction(1.0*GeV*GeV);
     321//SetCofNuclearDestruction(0.47*std::exp(2.*(Ylab-2.5))/(1.+std::exp(2.*(Ylab-2.5))));
     322//SetPt2ofNuclearDestruction((0.035+0.1*std::exp(4.*(Ylab-3.))/(1.+std::exp(4.*(Ylab-3.))))*GeV*GeV);
     323
     324//SetProbabilityOfElasticScatt(1.,1.); //(Xtotal, Xelastic);
     325//SetProbabilityOfProjDiff(1.*0.62*std::pow(s/GeV/GeV,-0.51)); // 0->1
     326//SetProbabilityOfTarDiff(4.*0.62*std::pow(s/GeV/GeV,-0.51)); // 2->4
     327//SetAveragePt2(0.3);                              //(0.15);
     328//SetAvaragePt2ofElasticScattering(0.);
     329
     330//SetCofNuclearDestruction(0.6); //(0.4);                 
     331SetExcitationEnergyPerWoundedNucleon(75.*MeV); //(75.*MeV);
     332//SetDofNuclearDestruction(0.6); //(0.4);                 
     333//SetPt2ofNuclearDestruction(0.12*GeV*GeV); //(0.168*GeV*GeV);
     334
    304335}
    305336//**********************************************************************************************

  • trunk/source/processes/hadronic/models/parton_string/diffraction/src/G4FTFParticipants.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4FTFParticipants.cc,v 1.16 2009/11/25 09:14:03 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4FTFParticipants.cc,v 1.17 2010/09/20 15:50:46 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// ------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/hadronization/History

    r1337 r1340  
    1 $Id: History,v 1.13 2010/06/22 07:29:35 gcosmo Exp $
     1$Id: History,v 1.17 2010/09/28 09:03:07 gcosmo Exp $
    22-------------------------------------------------------------------
    33
    … …  
    1515     * Please list in reverse chronological order (last date on top)
    1616     ---------------------------------------------------------------
     17
     1822-September-2010  V. Uzhinsky          (had-hadronization-V09-03-01)
     19--------------------------------------------------------------
     20- Warning messages are erased in G4LundStringFragmentation.cc
     21
     2220-September-2010  V. Uzhinsky
     23------------------------------
     24- Phase space restrictions are introduced at small mass string
     25  fragmentation.
     26
     275-August-2010  V. Uzhinsky
     28--------------------------
     29- Small re-organization is done in G4ExcitedStringDecay.hh. Inline
     30  methods were moved to G4ExcitedStringDecay.cc.
     31
     32- An action is introduced in FragmentStrings. It acts when
     33  EnergyAndMomentumCorrector can not be done due to large sum masses
     34  of produced hadrons. This led to energy-momentum violation. Now
     35  string fragmentation is repeted 100 times in a bad case.
    1736
    183721-June-2010  V. Uzhinsky               (had-hadronization-V09-03-00)

  • trunk/source/processes/hadronic/models/parton_string/hadronization/include/G4ExcitedStringDecay.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4ExcitedStringDecay.hh,v 1.12 2010/06/21 17:50:48 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4ExcitedStringDecay.hh,v 1.13 2010/08/05 08:44:37 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030#ifndef G4ExcitedStringDecay_h
    … …  
    4242      G4ExcitedStringDecay();
    4343      G4ExcitedStringDecay(G4VLongitudinalStringDecay * aStringDecay);
    44       ~G4ExcitedStringDecay();
     44      virtual ~G4ExcitedStringDecay();
    4545
    4646  private:
    … …  
    6262};
    6363
    64 inline
    65 G4KineticTrackVector *G4ExcitedStringDecay::
    66 FragmentString(const G4ExcitedString &theString)
    67 {
    68         if ( theStringDecay == NULL )
    69             theStringDecay=new G4LundStringFragmentation();
    70            
    71         return theStringDecay->FragmentString(theString);
    72 }
    73        
    74 
    75 inline
    76 G4KineticTrackVector *G4ExcitedStringDecay::
    77 FragmentStrings(const G4ExcitedStringVector * theStrings)
    78 {
    79   G4KineticTrackVector * theResult = new G4KineticTrackVector;
    80 
    81   G4LorentzVector KTsum(0.,0.,0.,0.);
    82   G4LorentzVector KTsecondaries(0.,0.,0.,0.);
    83   G4bool NeedEnergyCorrector=false;
    84 
    85   for ( unsigned int astring=0; astring < theStrings->size(); astring++)
    86   {
    87         KTsum+= theStrings->operator[](astring)->Get4Momentum();
    88 
    89         if( !(KTsum.e()<1) && !(KTsum.e()>-1) )
    90         {
    91           throw G4HadronicException(__FILE__, __LINE__,
    92                                    "G4ExcitedStringDecay::FragmentStrings received nan string...");
    93         }
    94         G4KineticTrackVector * generatedKineticTracks = NULL;
    95  
    96         if ( theStrings->operator[](astring)->IsExcited() )
    97         {
    98              generatedKineticTracks=FragmentString(*theStrings->operator[](astring));
    99         } else {
    100              generatedKineticTracks = new G4KineticTrackVector;
    101              generatedKineticTracks->push_back(theStrings->operator[](astring)->GetKineticTrack());
    102         }   
    103 
    104         if (generatedKineticTracks == NULL)
    105         {
    106                 G4cerr << "G4VPartonStringModel:No KineticTracks produced" << G4endl;
    107                 continue;
    108         }
    109 
    110         G4LorentzVector KTsum1(0.,0.,0.,0.);
    111         for ( unsigned int aTrack=0; aTrack<generatedKineticTracks->size();aTrack++)
    112         {
    113                 theResult->push_back(generatedKineticTracks->operator[](aTrack));
    114                 KTsum1+= (*generatedKineticTracks)[aTrack]->Get4Momentum();
    115         }
    116         KTsecondaries+=KTsum1;
    117        
    118         if  ( KTsum1.e() > 0 && std::abs((KTsum1.e()-theStrings->operator[](astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion )
    119         {
    120 //--debug--           G4cout << "String secondaries(" <<generatedKineticTracks->size()<< ")  momentum: "
    121 //--debug--               << theStrings->operator[](astring)->Get4Momentum() << " " << KTsum1 << G4endl;
    122            NeedEnergyCorrector=true;
    123         }
    124 
    125 //      clean up
    126         delete generatedKineticTracks;
    127   }
    128 //--DEBUG  G4cout << "Strings/secs total  4 momentum " << KTsum << " " <<KTsecondaries << G4endl;
    129 
    130   G4bool success=true;
    131   if ( NeedEnergyCorrector ) success=EnergyAndMomentumCorrector(theResult, KTsum);
    132 
    133 
    134 #ifdef debug_ExcitedStringDecay
    135   G4LorentzVector  KTsum1=0;
    136   for ( unsigned int aTrack=0; aTrack<theResult->size();aTrack++)
    137   {
    138       G4cout << " corrected tracks .. " << (*theResult)[aTrack]->GetDefinition()->GetParticleName()
    139       <<"  " << (*theResult)[aTrack]->Get4Momentum() << G4endl;
    140       KTsum1+= (*theResult)[aTrack]->Get4Momentum();
    141   }
    142   G4cout << "Needcorrector/success " << NeedEnergyCorrector << "/" << success << ", Corrected total  4 momentum " << KTsum1  << G4endl;
    143   if ( ! success ) G4cout << "failed to correct E/p" << G4endl; 
    144 #endif
    145 
    146   return theResult;
    147 }
    148 
    14964#endif
    15065

  • trunk/source/processes/hadronic/models/parton_string/hadronization/include/G4FragmentingString.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4FragmentingString.hh,v 1.4 2007/12/20 15:38:06 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4FragmentingString.hh,v 1.5 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/hadronization/include/G4HadronBuilder.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4HadronBuilder.hh,v 1.5 2009/05/18 09:43:40 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4HadronBuilder.hh,v 1.6 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// -----------------------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/hadronization/include/G4LundStringFragmentation.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4LundStringFragmentation.hh,v 1.6 2008/04/25 14:20:14 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $ Maxim Komogorov
     27// $Id: G4LundStringFragmentation.hh,v 1.7 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $ Maxim Komogorov
    2929//
    3030// -----------------------------------------------------------------------------
    … …  
    7878                                  G4ParticleDefinition* pHadron,
    7979                                  G4double Px, G4double Py);     
    80            
     80
     81   G4double lambda(G4double s, G4double m1_Sqr, G4double m2_Sqr);
     82
    8183private:
    8284// ------ For estimation of a minimal string mass ---------------
    … …  
    8991// ------ Minimal invariant mass used at a string fragmentation -
    9092   G4double WminLUND;               
     93
     94   G4int          Meson[3][3][6];
     95   G4double MesonWeight[3][3][6];
     96
     97   G4int          Baryon[3][3][3][4];
     98   G4double BaryonWeight[3][3][3][4];
     99
     100   G4double Prob_QQbar[3];
    91101};
    92102

  • trunk/source/processes/hadronic/models/parton_string/hadronization/include/G4QGSMFragmentation.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4QGSMFragmentation.hh,v 1.5 2007/12/20 15:38:07 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4QGSMFragmentation.hh,v 1.6 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// -----------------------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/hadronization/include/G4VKinkyStringDecay.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4VKinkyStringDecay.hh,v 1.3 2006/06/29 20:54:53 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VKinkyStringDecay.hh,v 1.4 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//  Maxim Komogorov
    3030//

  • trunk/source/processes/hadronic/models/parton_string/hadronization/include/G4VLongitudinalStringDecay.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4VLongitudinalStringDecay.hh,v 1.7 2009/05/22 16:35:47 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VLongitudinalStringDecay.hh,v 1.8 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929// Maxim Komogorov
    3030//

  • trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4ExcitedStringDecay.cc

    r1337 r1340  
    6161}
    6262
    63 G4bool G4ExcitedStringDecay::
    64 EnergyAndMomentumCorrector(G4KineticTrackVector* Output, G4LorentzVector& TotalCollisionMom)   
     63G4KineticTrackVector *G4ExcitedStringDecay::FragmentString
     64                                (const G4ExcitedString &theString)
     65{
     66        if ( theStringDecay == NULL )
     67
     68            theStringDecay=new G4LundStringFragmentation();
     69   
     70        return theStringDecay->FragmentString(theString);
     71}
     72       
     73G4KineticTrackVector *G4ExcitedStringDecay::FragmentStrings
     74                                (const G4ExcitedStringVector * theStrings)
     75{
     76  G4LorentzVector KTsum(0.,0.,0.,0.);
     77  for ( unsigned int astring=0; astring < theStrings->size(); astring++)
     78  {
     79        KTsum+= theStrings->operator[](astring)->Get4Momentum();
     80
     81        if( !(KTsum.e()<1) && !(KTsum.e()>-1) )
     82        {
     83          throw G4HadronicException(__FILE__, __LINE__,
     84                                   "G4ExcitedStringDecay::FragmentStrings received nan string...");
     85        }
     86  }
     87
     88  G4KineticTrackVector * theResult = new G4KineticTrackVector;
     89  G4int attempts(0);
     90  G4bool success=false;
     91  do {
     92
     93        std::for_each(theResult->begin() , theResult->end() , DeleteKineticTrack());
     94        theResult->clear();
     95
     96        attempts++;
     97        G4LorentzVector KTsecondaries(0.,0.,0.,0.);
     98        G4bool NeedEnergyCorrector=false;
     99
     100        for ( unsigned int astring=0; astring < theStrings->size(); astring++)
     101        {
     102//G4cout<<G4endl<<"String No "<<astring+1<<" "<<theStrings->operator[](astring)->Get4Momentum().mag()<<G4endl;
     103
     104          G4KineticTrackVector * generatedKineticTracks = NULL;
     105 
     106          if ( theStrings->operator[](astring)->IsExcited() )
     107          {
     108             generatedKineticTracks=FragmentString(*theStrings->operator[](astring));
     109          } else {
     110             generatedKineticTracks = new G4KineticTrackVector;
     111             generatedKineticTracks->push_back(theStrings->operator[](astring)->GetKineticTrack());
     112          }   
     113
     114          if (generatedKineticTracks == NULL)
     115          {
     116             G4cerr << "G4VPartonStringModel:No KineticTracks produced" << G4endl;
     117             continue;
     118          }
     119
     120          G4LorentzVector KTsum1(0.,0.,0.,0.);
     121          for ( unsigned int aTrack=0; aTrack<generatedKineticTracks->size();aTrack++)
     122          {
     123//G4cout<<" Prod part "<<(*generatedKineticTracks)[aTrack]->GetDefinition()->GetParticleName()<<" "<<(*generatedKineticTracks)[aTrack]->Get4Momentum()<<G4endl;
     124             theResult->push_back(generatedKineticTracks->operator[](aTrack));
     125             KTsum1+= (*generatedKineticTracks)[aTrack]->Get4Momentum();
     126          }
     127          KTsecondaries+=KTsum1;
     128       
     129          if  ( KTsum1.e() > 0 && std::abs((KTsum1.e()-theStrings->operator[](astring)->Get4Momentum().e()) / KTsum1.e()) > perMillion )
     130          {
     131//--debug--           G4cout << "String secondaries(" <<generatedKineticTracks->size()<< ")  momentum: "
     132//--debug--               << theStrings->operator[](astring)->Get4Momentum() << " " << KTsum1 << G4endl;
     133            NeedEnergyCorrector=true;
     134          }
     135
     136//        clean up
     137          delete generatedKineticTracks;
     138        }
     139//--DEBUG  G4cout << "Strings/secs total  4 momentum " << KTsum << " " <<KTsecondaries << G4endl;
     140
     141        success=true;
     142        if ( NeedEnergyCorrector ) success=EnergyAndMomentumCorrector(theResult, KTsum);
     143
     144  } while(!success && (attempts < 100));
     145
     146#ifdef debug_ExcitedStringDecay
     147  G4LorentzVector  KTsum1=0;
     148  for ( unsigned int aTrack=0; aTrack<theResult->size();aTrack++)
     149  {
     150      G4cout << " corrected tracks .. " << (*theResult)[aTrack]->GetDefinition()->GetParticleName()
     151      <<"  " << (*theResult)[aTrack]->Get4Momentum() << G4endl;
     152      KTsum1+= (*theResult)[aTrack]->Get4Momentum();
     153  }
     154  G4cout << "Needcorrector/success " << NeedEnergyCorrector << "/" << success << ", Corrected total  4 momentum " << KTsum1  << G4endl;
     155  if ( ! success ) G4cout << "failed to correct E/p" << G4endl; 
     156#endif
     157
     158  return theResult;
     159}
     160
     161G4bool G4ExcitedStringDecay::EnergyAndMomentumCorrector
     162                (G4KineticTrackVector* Output, G4LorentzVector& TotalCollisionMom)   
    65163  {
    66164    const int    nAttemptScale = 500;
    … …  
    71169    G4double        SumMass = 0;     
    72170    G4double        TotalCollisionMass = TotalCollisionMom.m();
     171
    73172    if( !(TotalCollisionMass<1) && !(TotalCollisionMass>-1) )
    74173    {
    … …  
    77176    }
    78177
     178//G4cout<<G4endl<<"EnergyAndMomentumCorrector "<<Output->size()<<G4endl;
    79179    // Calculate sum hadron 4-momenta and summing hadron mass
    80180    unsigned int cHadron;
    … …  
    92192        }
    93193    }
     194
     195//G4cout<<"SumMass TotalCollisionMass "<<SumMass<<" "<<TotalCollisionMass<<G4endl;
    94196
    95197    // Cannot correct a single particle

  • trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4HadronBuilder.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4HadronBuilder.cc,v 1.10 2009/05/22 16:34:31 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4HadronBuilder.cc,v 1.11 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// -----------------------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4LundStringFragmentation.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4LundStringFragmentation.cc,v 1.20 2010/06/21 17:50:48 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $ 1.8
     27// $Id: G4LundStringFragmentation.cc,v 1.23 2010/09/22 12:36:37 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $ 1.8
    2929//
    3030// -----------------------------------------------------------------------------
    … …  
    5353    MinimalStringMass2 = 0.;             
    5454// ------ Minimal invariant mass used at a string fragmentation -
    55     WminLUND = 0.7*GeV;                   // Uzhi 0.8 1.5
     55    WminLUND = 0.45*GeV; //0.23*GeV;                   // Uzhi 0.7 -> 0.23 3.8.10 //0.8 1.5
    5656// ------ Smooth parameter used at a string fragmentation for ---
    5757// ------ smearinr sharp mass cut-off ---------------------------
    … …  
    6060//    SetStringTensionParameter(0.25);                           
    6161    SetStringTensionParameter(1.);                         
     62
     63SetDiquarkBreakProbability(0.05);   // Vova Aug. 22
     64
     65// For treating of small string decays
     66   for(G4int i=0; i<3; i++)
     67   {  for(G4int j=0; j<3; j++)
     68      {  for(G4int k=0; k<6; k++)
     69         {  Meson[i][j][k]=0; MesonWeight[i][j][k]=0.;
     70         }
     71      }
     72   }
     73//--------------------------
     74        Meson[0][0][0]=111;                       // dbar-d Pi0
     75   MesonWeight[0][0][0]=pspin_meson*(1.-scalarMesonMix[0]);
     76
     77         Meson[0][0][1]=221;                       // dbar-d Eta
     78   MesonWeight[0][0][1]=pspin_meson*(scalarMesonMix[0]-scalarMesonMix[1]);
     79
     80         Meson[0][0][2]=331;                       // dbar-d EtaPrime
     81   MesonWeight[0][0][2]=pspin_meson*(scalarMesonMix[1]);
     82
     83         Meson[0][0][3]=113;                       // dbar-d Rho0
     84   MesonWeight[0][0][3]=(1.-pspin_meson)*(1.-vectorMesonMix[0]);
     85
     86         Meson[0][0][4]=223;                       // dbar-d Omega
     87   MesonWeight[0][0][4]=(1.-pspin_meson)*(vectorMesonMix[0]);
     88//--------------------------
     89
     90         Meson[0][1][0]=211;                       // dbar-u Pi+
     91   MesonWeight[0][1][0]=pspin_meson;
     92
     93         Meson[0][1][1]=213;                       // dbar-u Rho+
     94   MesonWeight[0][1][1]=(1.-pspin_meson);
     95//--------------------------
     96
     97         Meson[0][2][0]=311;                      // dbar-s K0bar
     98   MesonWeight[0][2][0]=pspin_meson;
     99
     100         Meson[0][2][1]=313;                       // dbar-s K*0bar
     101   MesonWeight[0][2][1]=(1.-pspin_meson);
     102//--------------------------
     103//--------------------------
     104         Meson[1][0][0]=211;                       // ubar-d Pi-
     105   MesonWeight[1][0][0]=pspin_meson;
     106
     107         Meson[1][0][1]=213;                       // ubar-d Rho-
     108   MesonWeight[1][0][1]=(1.-pspin_meson);
     109//--------------------------
     110
     111         Meson[1][1][0]=111;                       // ubar-u Pi0
     112   MesonWeight[1][1][0]=pspin_meson*(1.-scalarMesonMix[0]);
     113
     114         Meson[1][1][1]=221;                       // ubar-u Eta
     115   MesonWeight[1][1][1]=pspin_meson*(scalarMesonMix[0]-scalarMesonMix[1]);
     116
     117         Meson[1][1][2]=331;                       // ubar-u EtaPrime
     118   MesonWeight[1][1][2]=pspin_meson*(scalarMesonMix[1]);
     119
     120         Meson[1][1][3]=113;                       // ubar-u Rho0
     121   MesonWeight[1][1][3]=(1.-pspin_meson)*(1.-vectorMesonMix[0]);
     122
     123         Meson[1][1][4]=223;                       // ubar-u Omega
     124   MesonWeight[1][1][4]=(1.-pspin_meson)*(scalarMesonMix[0]);
     125//--------------------------
     126
     127         Meson[1][2][0]=321;                      // ubar-s K-
     128   MesonWeight[1][2][0]=pspin_meson;
     129
     130         Meson[1][2][1]=323;                      // ubar-s K*-bar -
     131   MesonWeight[1][2][1]=(1.-pspin_meson);
     132//--------------------------
     133//--------------------------
     134
     135         Meson[2][0][0]=311;                       // sbar-d K0
     136   MesonWeight[2][0][0]=pspin_meson;
     137
     138         Meson[2][0][1]=313;                       // sbar-d K*0
     139   MesonWeight[2][0][1]=(1.-pspin_meson);
     140//--------------------------
     141
     142         Meson[2][1][0]=321;                        // sbar-u K+
     143   MesonWeight[2][1][0]=pspin_meson;
     144
     145         Meson[2][1][1]=323;                       // sbar-u K*+
     146   MesonWeight[2][1][1]=(1.-pspin_meson);
     147//--------------------------
     148
     149         Meson[2][2][0]=221;                       // sbar-s Eta
     150   MesonWeight[2][2][0]=pspin_meson*(1.-scalarMesonMix[5]);
     151
     152         Meson[2][2][1]=331;                       // sbar-s EtaPrime
     153   MesonWeight[2][2][1]=pspin_meson*(1.-scalarMesonMix[5]);
     154
     155         Meson[2][2][3]=333;                       // sbar-s EtaPrime
     156   MesonWeight[2][2][3]=(1.-pspin_meson)*(vectorMesonMix[5]);
     157//--------------------------
     158
     159   for(G4int i=0; i<3; i++)
     160   {  for(G4int j=0; j<3; j++)
     161      {  for(G4int k=0; k<3; k++)
     162         {  for(G4int l=0; l<4; l++)
     163            { Baryon[i][j][k][l]=0; BaryonWeight[i][j][k][l]=0.;}
     164         }
     165      }
     166   }
     167
     168//---------------------------------------
     169         Baryon[0][0][0][0]=1114;         // Delta-
     170   BaryonWeight[0][0][0][0]=1.;
     171
     172//---------------------------------------
     173         Baryon[0][0][1][0]=2112;         // neutron
     174   BaryonWeight[0][0][1][0]=pspin_barion;
     175
     176         Baryon[0][0][1][1]=2114;         // Delta0
     177   BaryonWeight[0][0][1][1]=(1.-pspin_barion);
     178
     179//---------------------------------------
     180         Baryon[0][0][2][0]=3112;         // Sigma-
     181   BaryonWeight[0][0][2][0]=pspin_barion;
     182
     183         Baryon[0][0][2][1]=3114;         // Sigma*-
     184   BaryonWeight[0][0][2][1]=(1.-pspin_barion);
     185
     186//---------------------------------------
     187         Baryon[0][1][0][0]=2112;         // neutron
     188   BaryonWeight[0][1][0][0]=pspin_barion;
     189
     190         Baryon[0][1][0][1]=2114;         // Delta0
     191   BaryonWeight[0][1][0][1]=(1.-pspin_barion);
     192
     193//---------------------------------------
     194         Baryon[0][1][1][0]=2212;         // proton
     195   BaryonWeight[0][1][1][0]=pspin_barion;
     196
     197         Baryon[0][1][1][1]=2214;         // Delta+
     198   BaryonWeight[0][1][1][1]=(1.-pspin_barion);
     199
     200//---------------------------------------
     201         Baryon[0][1][2][0]=3122;         // Lambda
     202   BaryonWeight[0][1][2][0]=pspin_barion*0.5;
     203
     204         Baryon[0][1][2][1]=3212;         // Sigma0
     205   BaryonWeight[0][1][2][2]=pspin_barion*0.5;
     206
     207         Baryon[0][1][2][2]=3214;         // Sigma*0
     208   BaryonWeight[0][1][2][2]=(1.-pspin_barion);
     209
     210//---------------------------------------
     211         Baryon[0][2][0][0]=3112;         // Sigma-
     212   BaryonWeight[0][2][0][0]=pspin_barion;
     213
     214         Baryon[0][2][0][1]=3114;         // Sigma*-
     215   BaryonWeight[0][2][0][1]=(1.-pspin_barion);
     216
     217//---------------------------------------
     218         Baryon[0][2][1][0]=3122;         // Lambda
     219   BaryonWeight[0][2][1][0]=pspin_barion*0.5;
     220
     221         Baryon[0][2][1][1]=3212;         // Sigma0
     222   BaryonWeight[0][2][1][1]=pspin_barion*0.5;
     223
     224         Baryon[0][2][1][2]=3214;         // Sigma*0
     225   BaryonWeight[0][2][1][2]=(1.-pspin_barion);
     226
     227//---------------------------------------
     228         Baryon[0][2][2][0]=3312;         // Theta-
     229   BaryonWeight[0][2][2][0]=pspin_barion;
     230
     231         Baryon[0][2][2][1]=3314;         // Theta*-
     232   BaryonWeight[0][2][2][1]=(1.-pspin_barion);
     233
     234//---------------------------------------
     235//---------------------------------------
     236         Baryon[1][0][0][0]=2112;         // neutron
     237   BaryonWeight[1][0][0][0]=pspin_barion;
     238
     239         Baryon[1][0][0][1]=2114;         // Delta0
     240   BaryonWeight[1][0][0][1]=(1.-pspin_barion);
     241
     242//---------------------------------------
     243         Baryon[1][0][1][0]=2212;         // proton
     244   BaryonWeight[1][0][1][0]=pspin_barion;         
     245
     246         Baryon[1][0][1][1]=2214;         // Delta+
     247   BaryonWeight[1][0][1][1]=(1.-pspin_barion);
     248
     249//---------------------------------------
     250         Baryon[1][0][2][0]=3122;         // Lambda
     251   BaryonWeight[1][0][2][0]=pspin_barion*0.5;
     252
     253         Baryon[1][0][2][1]=3212;         // Sigma0
     254   BaryonWeight[1][0][2][1]=pspin_barion*0.5;
     255
     256         Baryon[1][0][2][2]=3214;         // Sigma*0
     257   BaryonWeight[1][0][2][2]=(1.-pspin_barion);
     258
     259//---------------------------------------
     260         Baryon[1][1][0][0]=2212;         // proton
     261   BaryonWeight[1][1][0][0]=pspin_barion;
     262
     263         Baryon[1][1][0][1]=2214;         // Delta+
     264   BaryonWeight[1][1][0][1]=(1.-pspin_barion);
     265
     266//---------------------------------------
     267         Baryon[1][1][1][0]=2224;         // Delta++
     268   BaryonWeight[1][1][1][0]=1.;
     269
     270//---------------------------------------
     271         Baryon[1][1][2][0]=3222;         // Sigma+
     272   BaryonWeight[1][1][2][0]=pspin_barion;
     273
     274         Baryon[1][1][2][1]=3224;         // Sigma*+
     275   BaryonWeight[1][1][2][1]=(1.-pspin_barion);
     276
     277//---------------------------------------
     278         Baryon[1][2][0][0]=3122;         // Lambda
     279   BaryonWeight[1][2][0][0]=pspin_barion*0.5;
     280
     281         Baryon[1][2][0][1]=3212;         // Sigma0
     282   BaryonWeight[1][2][0][1]=pspin_barion*0.5;
     283
     284         Baryon[1][2][0][2]=3214;         // Sigma*0
     285   BaryonWeight[1][2][0][2]=(1.-pspin_barion);
     286
     287//---------------------------------------
     288         Baryon[1][2][1][0]=3222;         // Sigma+
     289   BaryonWeight[1][2][1][0]=pspin_barion;
     290
     291         Baryon[1][2][1][1]=3224;         // Sigma*+
     292   BaryonWeight[1][2][1][1]=(1.-pspin_barion);
     293
     294//---------------------------------------
     295         Baryon[1][2][2][0]=3322;         // Theta0
     296   BaryonWeight[1][2][2][0]=pspin_barion;
     297
     298         Baryon[1][2][2][1]=3324;         // Theta*0
     299   BaryonWeight[1][2][2][1]=(1.-pspin_barion);
     300
     301//---------------------------------------
     302//---------------------------------------
     303         Baryon[2][0][0][0]=3112;         // Sigma-
     304   BaryonWeight[2][0][0][0]=pspin_barion;
     305
     306         Baryon[2][0][0][1]=3114;         // Sigma*-
     307   BaryonWeight[2][0][0][1]=(1.-pspin_barion);
     308
     309//---------------------------------------
     310         Baryon[2][0][1][0]=3122;         // Lambda
     311   BaryonWeight[2][0][1][0]=pspin_barion*0.5;         
     312
     313         Baryon[2][0][1][1]=3212;         // Sigma0
     314   BaryonWeight[2][0][1][1]=pspin_barion*0.5;
     315
     316         Baryon[2][0][1][2]=3214;         // Sigma*0
     317   BaryonWeight[2][0][1][2]=(1.-pspin_barion);
     318
     319//---------------------------------------
     320         Baryon[2][0][2][0]=3312;         // Sigma-
     321   BaryonWeight[2][0][2][0]=pspin_barion;
     322
     323         Baryon[2][0][2][1]=3314;         // Sigma*-
     324   BaryonWeight[2][0][2][1]=(1.-pspin_barion);
     325
     326//---------------------------------------
     327         Baryon[2][1][0][0]=3122;         // Lambda
     328   BaryonWeight[2][1][0][0]=pspin_barion*0.5;
     329
     330         Baryon[2][1][0][1]=3212;         // Sigma0
     331   BaryonWeight[2][1][0][1]=pspin_barion*0.5;
     332
     333         Baryon[2][1][0][2]=3214;         // Sigma*0
     334   BaryonWeight[2][1][0][2]=(1.-pspin_barion);
     335
     336//---------------------------------------
     337         Baryon[2][1][1][0]=3222;         // Sigma+
     338   BaryonWeight[2][1][1][0]=pspin_barion;
     339
     340         Baryon[2][1][1][1]=3224;         // Sigma*+
     341   BaryonWeight[2][1][1][1]=(1.-pspin_barion);
     342
     343//---------------------------------------
     344         Baryon[2][1][2][0]=3322;         // Theta0
     345   BaryonWeight[2][1][2][0]=pspin_barion;
     346
     347         Baryon[2][1][2][1]=3324;         // Theta*0
     348   BaryonWeight[2][1][2][2]=(1.-pspin_barion);
     349
     350//---------------------------------------
     351         Baryon[2][2][0][0]=3312;         // Theta-
     352   BaryonWeight[2][2][0][0]=pspin_barion;
     353
     354         Baryon[2][2][0][1]=3314;         // Theta*-
     355   BaryonWeight[2][2][0][1]=(1.-pspin_barion);
     356
     357//---------------------------------------
     358         Baryon[2][2][1][0]=3322;         // Theta0
     359   BaryonWeight[2][2][1][0]=pspin_barion;
     360
     361         Baryon[2][2][1][1]=3324;         // Theta*0
     362   BaryonWeight[2][2][1][1]=(1.-pspin_barion);
     363
     364//---------------------------------------
     365         Baryon[2][2][2][0]=3334;         // Omega
     366   BaryonWeight[2][2][2][0]=1.;
     367
     368//---------------------------------------
     369/*
     370   for(G4int i=0; i<3; i++)
     371   {  for(G4int j=0; j<3; j++)
     372      {  for(G4int k=0; k<3; k++)
     373         {  for(G4int l=0; l<4; l++)
     374            { G4cout<<i<<" "<<j<<" "<<k<<" "<<l<<" "<<Baryon[i][j][k][l]<<G4endl;}
     375         }
     376      }
     377   }
     378G4int Uzhi;
     379G4cin>>Uzhi;
     380*/
     381//StrangeSuppress=0.38;
     382    Prob_QQbar[0]=StrangeSuppress;         // Probability of ddbar production
     383    Prob_QQbar[1]=StrangeSuppress;         // Probability of uubar production
     384    Prob_QQbar[2]=StrangeSuppress/(2.+StrangeSuppress);//(1.-2.*StrangeSuppress); // Probability of ssbar production
    62385   }
    63386
    … …  
    160483//    Can no longer modify Parameters for Fragmentation.
    161484        PastInitPhase=true;
     485//SetVectorMesonProbability(1.);
     486//SetSpinThreeHalfBarionProbability(1.);
    162487
    163488//      check if string has enough mass to fragment...
    … …  
    165490        SetMassCut(160.*MeV); // For LightFragmentationTest it is required
    166491                              // that no one pi-meson can be produced
     492//
     493//G4cout<<G4endl<<"G4LundStringFragmentation::"<<G4endl;
     494//G4cout<<"FragmentString Position"<<theString.GetPosition()/fermi<<" "<<theString.GetTimeOfCreation()/fermi<<G4endl;
     495//G4cout<<"FragmentString Momentum"<<theString.Get4Momentum()<<theString.Get4Momentum().mag()<<G4endl;
     496//
     497        G4FragmentingString  aString(theString);
     498        SetMinimalStringMass(&aString);
     499
    167500/*
    168 G4cout<<G4endl<<"G4LundStringFragmentation::"<<G4endl;
    169 G4cout<<"FragmentString Position"<<theString.GetPosition()/fermi<<" "<<
    170 theString.GetTimeOfCreation()/fermi<<G4endl;
    171 G4cout<<"FragmentString Momentum"<<theString.Get4Momentum()<<theString.Get4Momentum().mag()<<G4endl;
     501G4cout<<"St Frag "<<MinimalStringMass<<" "<<WminLUND<<" "<<(1.-SmoothParam)<<" "<< theString.Get4Momentum().mag()<<G4endl;
     502G4cout<<(MinimalStringMass+WminLUND)*(1.-SmoothParam)<<" "<<theString.Get4Momentum().mag()<<G4endl;
     503
     504       if((MinimalStringMass+WminLUND)*(1.-SmoothParam) > theString.Get4Momentum().mag())
     505            {SetMassCut(1000.*MeV);}
     506       else {SetMassCut(160.*MeV);}
    172507*/
    173         G4FragmentingString aString(theString);
    174         SetMinimalStringMass(&aString);
    175 
    176        if((MinimalStringMass+WminLUND)*(1.-SmoothParam) > theString.Get4Momentum().mag())
    177        {SetMassCut(1000.*MeV);}
    178 // V.U. 20.06.10 in order to put un correspondence LightFragTest and MinStrMass
    179 
    180         G4KineticTrackVector * LeftVector=LightFragmentationTest(&theString);
     508// V.U. 20.06.10 in order to put in correspondence LightFragTest and MinStrMass
     509
     510G4KineticTrackVector * LeftVector(0);
     511//      G4KineticTrackVector * LeftVector=LightFragmentationTest(&theString);
     512//G4cout<<"Min Str Mass "<<MinimalStringMass<<G4endl;
     513if(!IsFragmentable(&aString)) // produce 1 hadron
     514{
     515//G4cout<<"Non fragmentable"<<G4endl;
     516 SetMassCut(1000.*MeV);
     517 LeftVector=LightFragmentationTest(&theString);
     518 SetMassCut(160.*MeV);
     519
     520
     521//G4cout<<"Prod hadron "<<LeftVector->operator[](0)->GetDefinition()->GetParticleName()<<G4endl;
     522/*
     523 if(LeftVector->size() == 1)
     524 {
     525  if(! (std::abs(LeftVector->operator[](0)->GetDefinition()->GetPDGMass()-
     526                       theString.Get4Momentum().mag()) < 100*MeV))
     527  {  // produce a particle with arbitrary isospin
     528G4cout<<" produce a particle with arbitrary isospin"<<G4endl;
     529
     530   pDefPair hadrons((G4ParticleDefinition *)0,(G4ParticleDefinition *)0);
     531   Pcreate build=&G4HadronBuilder::Build;
     532   FragmentationMass(&aString,build,&hadrons);   // 0->1
     533G4cout<<"Hadron PDG "<<hadrons.first->GetPDGEncoding()<<G4endl;
     534   if ( hadrons.second ==0 )
     535   {// Substitute string by light hadron, Note that Energy is not conserved here!
     536    // Cleaning up the previously produced hadrons ------------------------------
     537    std::for_each(LeftVector->begin() , LeftVector->end() , DeleteKineticTrack());
     538    LeftVector->clear();
     539
     540    G4ThreeVector Mom3 = aString.Get4Momentum().vect();
     541    G4LorentzVector Mom(Mom3,std::sqrt(Mom3.mag2() + sqr(hadrons.first->GetPDGMass())));
     542    LeftVector->push_back(new G4KineticTrack(hadrons.first, 0,
     543                                                  theString.GetPosition(),
     544                                                          Mom));
     545   } // end of if ( hadrons.second ==0 )
     546  }  // end of produce a particle with arbitrary isospin
     547
     548 } // end of if(LeftVector->size() == 1)
     549*/
     550}  // end of if(!IsFragmentable(&aString))
    181551
    182552        if ( LeftVector != 0 ) {
    … …  
    207577//--------------------- The string can fragment -------------------------------
    208578//--------------- At least two particles can be produced ----------------------
     579//G4cout<<"Fragmentable"<<G4endl;
    209580                               LeftVector =new G4KineticTrackVector;
    210581        G4KineticTrackVector * RightVector=new G4KineticTrackVector;
    … …  
    218589        { // If the string fragmentation do not be happend, repeat the fragmentation---
    219590                G4FragmentingString *currentString=new G4FragmentingString(*theStringInCMS);
    220 
     591//G4cout<<"Main loop start whilecounter "<<attempt<<G4endl;
    221592          // Cleaning up the previously produced hadrons ------------------------------
    222593                std::for_each(LeftVector->begin() , LeftVector->end() , DeleteKineticTrack());
    … …  
    228599          // Main fragmentation loop until the string will not be able to fragment ----
    229600                inner_sucess=true;  // set false on failure..
     601
    230602                while (! StopFragmenting(currentString) )
    231603                {  // Split current string into hadron + new string
     604
    232605                        G4FragmentingString *newString=0;  // used as output from SplitUp...
    233606
    234607                        G4KineticTrack * Hadron=Splitup(currentString,newString);
     608//G4cout<<"SplitUp------"<<Hadron<<G4endl;
    235609
    236610                        if ( Hadron != 0 )  // Store the hadron                               
    237611                        {
     612//G4cout<<"Hadron prod at fragm. "<<Hadron->GetDefinition()->GetParticleName()<<G4endl;
    238613                           if ( currentString->GetDecayDirection() > 0 )
    239614                                   LeftVector->push_back(Hadron);
    … …  
    245620                };
    246621        // Split remaining string into 2 final Hadrons ------------------------
     622//G4cout<<"Split Last"<<G4endl;
    247623                if ( inner_sucess &&                                       
    248624                     SplitLast(currentString,LeftVector, RightVector) )
    … …  
    282658        G4ThreeVector PositionOftheStringCreation(theString.GetPosition());
    283659
     660//G4cout<<"# prod hadrons "<<LeftVector->size()<<G4endl;
    284661        for(size_t C1 = 0; C1 < LeftVector->size(); C1++)
    285662        {
    286663           G4KineticTrack* Hadron = LeftVector->operator[](C1);
    287664           G4LorentzVector Momentum = Hadron->Get4Momentum();
     665//G4cout<<"Hadron "<<Hadron->GetDefinition()->GetParticleName()<<" "<<Momentum<<G4endl;
    288666           Momentum = toObserverFrame*Momentum;
    289667           Hadron->Set4Momentum(Momentum);
    … …  
    306684{
    307685  SetMinimalStringMass(string);                                                     
    308   return sqr(MinimalStringMass + WminLUND) < string->Get4Momentum().mag2();         
     686//  return sqr(MinimalStringMass + WminLUND) < string->Get4Momentum().mag2();
     687  return MinimalStringMass < string->Get4Momentum().mag(); // 21.07.2010
    309688}
    310689
    … …  
    314693  SetMinimalStringMass(string);                                           
    315694
    316 //G4cout<<"StopFragm MinMass "<<MinimalStringMass<<" String Mass "<<std::sqrt(string->Get4Momentum().mag2())<<G4endl;
    317 //G4cout<<"WminLUND "<<WminLUND<<" SmoothParam "<<SmoothParam<<" "<<string->Mass()<<G4endl;
     695/*
     696G4cout<<"StopFragm MinMass "<<MinimalStringMass<<" String Mass "<<string->Get4Momentum().mag()<<G4endl;
     697G4cout<<"WminLUND "<<WminLUND<<" SmoothParam "<<SmoothParam<<" "<<string->Mass()<<G4endl;
     698//G4cout<<std::exp(-(string->Mass()*string->Mass()-MinimalStringMass2)/WminLUND/WminLUND)<<G4endl;
     699//G4int Uzhi; G4cin>>Uzhi;
     700*/
     701//
    318702  return (MinimalStringMass + WminLUND)*
    319703             (1 + SmoothParam * (1.-2*G4UniformRand())) >               
    320704                   string->Mass();                       
     705//
     706//  return G4UniformRand() < std::exp(-(string->Mass()*string->Mass()-MinimalStringMass2)/WminLUND/WminLUND);
    321707}
    322708
    … …  
    327713{
    328714    //... perform last cluster decay
    329 
     715//G4cout<<"Split last-----------------------------------------"<<G4endl;
    330716    G4LorentzVector Str4Mom=string->Get4Momentum();
    331717
    332718    G4ThreeVector ClusterVel =string->Get4Momentum().boostVector();
    333719
    334     G4double ResidualMass   = string->Mass();
    335 
    336     G4ParticleDefinition * LeftHadron, * RightHadron;
    337 
    338     G4int cClusterInterrupt = 0;
    339     do
     720    G4double StringMass   = string->Mass();
     721    G4double StringMassSqr= sqr(StringMass);
     722
     723    G4ParticleDefinition * LeftHadron(0), * RightHadron(0);
     724    G4double LeftHadronMass(0.), RightHadronMass(0.);
     725
     726    G4ParticleDefinition * FS_LeftHadron[25], * FS_RightHadron[25];
     727    G4double FS_Weight[25];
     728    G4int NumberOf_FS=0;
     729
     730    for(G4int i=0; i<25; i++) {FS_Weight[i]=0.;}
     731//***********************************************
     732//G4cout<<"StrMass "<<StringMass<<" q "<<string->GetLeftParton()->GetParticleName()<<" "<<string->GetRightParton()->GetParticleName()<<" StringMassSqr "<<StringMassSqr<<G4endl;
     733
     734
     735    string->SetLeftPartonStable(); // to query quark contents..
     736
     737    if (string->FourQuarkString() )
    340738    {
     739     // The string is qq-qqbar type. Diquarks are on the string ends
     740     G4int cClusterInterrupt = 0;
     741     do
     742     {
     743//G4cout<<"cClusterInterrupt "<<cClusterInterrupt<<G4endl;
    341744        if (cClusterInterrupt++ >= ClusterLoopInterrupt)
    342745        {
    343746          return false;
    344747        }
    345         G4ParticleDefinition * quark = NULL;
    346         string->SetLeftPartonStable(); // to query quark contents..
    347 
    348         if (!string->FourQuarkString() )
     748
     749        G4int LeftQuark1= string->GetLeftParton()->GetPDGEncoding()/1000;
     750        G4int LeftQuark2=(string->GetLeftParton()->GetPDGEncoding()/100)%10;
     751
     752        G4int RightQuark1= string->GetRightParton()->GetPDGEncoding()/1000;
     753        G4int RightQuark2=(string->GetRightParton()->GetPDGEncoding()/100)%10;
     754
     755        if(G4UniformRand()<0.5)
    349756        {
    350             // The string is q-qbar, or q-qq, or qbar-qqbar type
    351            if (string->DecayIsQuark() && string->StableIsQuark() )
    352            {
    353             //... there are quarks on cluster ends
    354               LeftHadron= QuarkSplitup(string->GetLeftParton(), quark);
    355            } else
    356            {
    357            //... there is a Diquark on one of the cluster ends
    358               G4int IsParticle;
    359 
    360               if ( string->StableIsQuark() )
    361               {
    362                  IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? -1 : +1;
    363               } else
    364               {
    365                  IsParticle=(string->GetLeftParton()->GetPDGEncoding()>0) ? +1 : -1;
    366               }
    367 
    368               pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
    369               quark = QuarkPair.second;
    370 
    371               LeftHadron=hadronizer->Build(QuarkPair.first, string->GetLeftParton());
    372            }
    373 
    374            RightHadron = hadronizer->Build(string->GetRightParton(), quark);
     757         LeftHadron =hadronizer->Build(FindParticle( LeftQuark1),
     758                                       FindParticle(RightQuark1));
     759         RightHadron=hadronizer->Build(FindParticle( LeftQuark2),
     760                                       FindParticle(RightQuark2));
    375761        } else
    376762        {
    377             // The string is qq-qqbar type. Diquarks are on the string ends
    378             G4int LiftQuark1= string->GetLeftParton()->GetPDGEncoding()/1000;
    379             G4int LiftQuark2=(string->GetLeftParton()->GetPDGEncoding()/100)%10;
    380 
    381             G4int RightQuark1= string->GetRightParton()->GetPDGEncoding()/1000;
    382             G4int RightQuark2=(string->GetRightParton()->GetPDGEncoding()/100)%10;
    383 
    384            if(G4UniformRand()<0.5)
    385            {
    386               LeftHadron =hadronizer->Build(FindParticle( LiftQuark1),
    387                                             FindParticle(RightQuark1));
    388               RightHadron=hadronizer->Build(FindParticle( LiftQuark2),
    389                                             FindParticle(RightQuark2));
    390            } else
    391            {
    392               LeftHadron =hadronizer->Build(FindParticle( LiftQuark1),
    393                                             FindParticle(RightQuark2));
    394               RightHadron=hadronizer->Build(FindParticle( LiftQuark2),
    395                                             FindParticle(RightQuark1));
    396            }
     763         LeftHadron =hadronizer->Build(FindParticle( LeftQuark1),
     764                                       FindParticle(RightQuark2));
     765         RightHadron=hadronizer->Build(FindParticle( LeftQuark2),
     766                                       FindParticle(RightQuark1));
    397767        }
    398 
     768         
    399769       //... repeat procedure, if mass of cluster is too low to produce hadrons
    400770       //... ClusterMassCut = 0.15*GeV model parameter
    401     }
    402     while (ResidualMass <= LeftHadron->GetPDGMass() + RightHadron->GetPDGMass());
    403 
    404     //... compute hadron momenta and energies   
     771     }
     772     while ((StringMass <= LeftHadron->GetPDGMass() + RightHadron->GetPDGMass()));
     773
     774    } // End of if (string->FourQuarkString() )
     775
     776//***********************************************
     777
     778    if (!string->FourQuarkString())
     779    {
     780     if (string->DecayIsQuark() && string->StableIsQuark() )
     781     {//... there are quarks on cluster ends
     782//G4cout<<"Q Q string"<<G4endl;
     783        G4ParticleDefinition * Quark;
     784        G4ParticleDefinition * Anti_Quark;
     785
     786        if(string->GetLeftParton()->GetPDGEncoding()>0)
     787        {
     788         Quark     =string->GetLeftParton();
     789         Anti_Quark=string->GetRightParton();
     790        } else
     791        {
     792         Quark     =string->GetRightParton();
     793         Anti_Quark=string->GetLeftParton();
     794        }
     795
     796        G4int IDquark        =Quark->GetPDGEncoding();     
     797        G4int AbsIDquark     =std::abs(IDquark);
     798        G4int IDanti_quark   =Anti_Quark->GetPDGEncoding();
     799        G4int AbsIDanti_quark=std::abs(IDanti_quark);
     800
     801        NumberOf_FS=0;
     802        for(G4int ProdQ=1; ProdQ < 4; ProdQ++)
     803        {
     804         G4int                              SignQ=-1;
     805         if(IDquark == 2)                   SignQ= 1;
     806         if((IDquark == 1) && (ProdQ == 3)) SignQ= 1; // K0
     807         if((IDquark == 3) && (ProdQ == 1)) SignQ=-1; // K0bar
     808         if(IDquark == ProdQ)               SignQ= 1;
     809
     810         G4int                                   SignAQ= 1;
     811         if(IDanti_quark == -2)                  SignAQ=-1;
     812         if((IDanti_quark ==-1) && (ProdQ == 3)) SignAQ=-1; // K0bar
     813         if((IDanti_quark ==-3) && (ProdQ == 1)) SignAQ= 1; // K0
     814         if(AbsIDanti_quark == ProdQ)            SignAQ= 1;
     815
     816         G4int StateQ=0;
     817         do  // while(Meson[AbsIDquark-1][ProdQ-1][StateQ]<>0);
     818         {
     819          LeftHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignQ*
     820                                      Meson[AbsIDquark-1][ProdQ-1][StateQ]);
     821          LeftHadronMass=LeftHadron->GetPDGMass();
     822          StateQ++;
     823
     824          G4int StateAQ=0;
     825          do // while(Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]<>0); 
     826          {
     827           RightHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignAQ*
     828                                      Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]);
     829           RightHadronMass=RightHadron->GetPDGMass();
     830           StateAQ++;
     831
     832           if(StringMass >= LeftHadronMass + RightHadronMass)
     833           {
     834            G4double FS_Psqr=lambda(StringMassSqr,sqr(LeftHadronMass),
     835                                                  sqr(RightHadronMass));
     836            FS_Weight[NumberOf_FS]=std::sqrt(FS_Psqr)*
     837                                   MesonWeight[AbsIDquark-1][ProdQ-1][StateQ]*
     838                                   MesonWeight[AbsIDanti_quark-1][ProdQ-1][StateAQ]*
     839                                   Prob_QQbar[ProdQ-1];
     840
     841            FS_LeftHadron[NumberOf_FS] = LeftHadron;
     842            FS_RightHadron[NumberOf_FS]= RightHadron;
     843            NumberOf_FS++;
     844if(NumberOf_FS > 24)
     845{G4int Uzhi; G4cout<<"QQbar string #_FS "<<NumberOf_FS<<G4endl; G4cin>>Uzhi;}
     846           } // End of if(StringMass >= LeftHadronMass + RightHadronMass)
     847          } while(Meson[AbsIDanti_quark-1][ProdQ-1][StateAQ]!=0);
     848         } while(Meson[AbsIDquark-1][ProdQ-1][StateQ]!=0);
     849        } // End of for(G4int ProdQ=1; ProdQ < 4; ProdQ++)
     850//
     851     } else //---------------------------------------------
     852     {  //... there is a Diquark on one of the cluster ends
     853//G4cout<<"DiQ Q string"<<G4endl;
     854        G4ParticleDefinition * Di_Quark;
     855        G4ParticleDefinition * Quark;
     856
     857        if(string->GetLeftParton()->GetParticleSubType()== "quark")
     858        {
     859         Quark   =string->GetLeftParton();
     860         Di_Quark=string->GetRightParton();
     861        } else
     862        {
     863         Quark   =string->GetRightParton();
     864         Di_Quark=string->GetLeftParton();
     865        }
     866
     867        G4int IDquark        =Quark->GetPDGEncoding();     
     868        G4int AbsIDquark     =std::abs(IDquark);
     869        G4int IDdi_quark   =Di_Quark->GetPDGEncoding();
     870        G4int AbsIDdi_quark=std::abs(IDdi_quark);
     871        G4int Di_q1=AbsIDdi_quark/1000;
     872        G4int Di_q2=(AbsIDdi_quark-Di_q1*1000)/100;
     873//G4cout<<"IDs "<<IDdi_quark<<" "<<IDquark<<G4endl;
     874
     875        G4int              SignDiQ= 1;
     876        if(IDdi_quark < 0) SignDiQ=-1;
     877
     878        NumberOf_FS=0;
     879        for(G4int ProdQ=1; ProdQ < 4; ProdQ++)
     880        {
     881         G4int SignQ;
     882         if(IDquark > 0)
     883         {                                   SignQ=-1;
     884          if(IDquark == 2)                   SignQ= 1;
     885          if((IDquark == 1) && (ProdQ == 3)) SignQ= 1; // K0
     886          if((IDquark == 3) && (ProdQ == 1)) SignQ=-1; // K0bar
     887         } else
     888         {
     889                                             SignQ= 1;
     890          if(IDquark == -2)                  SignQ=-1;
     891          if((IDquark ==-1) && (ProdQ == 3)) SignQ=-1; // K0bar
     892          if((IDquark ==-3) && (ProdQ == 1)) SignQ= 1; // K0
     893         }
     894
     895         if(AbsIDquark == ProdQ)            SignQ= 1;
     896
     897//G4cout<<G4endl;
     898//G4cout<<"-------------------------------------------"<<G4endl;
     899//G4cout<<"Insert QQbar "<<ProdQ<<" Sign "<<SignQ<<G4endl;
     900
     901         G4int StateQ=0;
     902         do  // while(Meson[AbsIDquark-1][ProdQ-1][StateQ]<>0);
     903         {
     904//G4cout<<G4endl<<"AbsIDquark ProdQ StateQ "<<MesonWeight[AbsIDquark-1][ProdQ-1][StateQ]<<" "<<AbsIDquark<<" "<<ProdQ<<" "<<StateQ<<G4endl;
     905//G4cout<<G4endl<<"AbsIDquark ProdQ StateQ "<<SignQ*Meson[AbsIDquark-1][ProdQ-1][StateQ]<<" "<<AbsIDquark<<" "<<ProdQ<<" "<<StateQ<<G4endl;
     906          LeftHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignQ*
     907                                      Meson[AbsIDquark-1][ProdQ-1][StateQ]);
     908          LeftHadronMass=LeftHadron->GetPDGMass();
     909
     910//G4cout<<"Meson "<<LeftHadron->GetParticleName()<<G4endl;
     911
     912          G4int StateDiQ=0;
     913          do // while(Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]<>0); 
     914          {
     915//G4cout<<G4endl<<"Di_q1 Di_q2 ProdQ StateDiQ "<<BaryonWeight[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]<<" "<<Di_q1-1<<" "<<Di_q2-1<<" "<<ProdQ-1<<" "<<StateDiQ<<G4endl;
     916           RightHadron=G4ParticleTable::GetParticleTable()->FindParticle(SignDiQ*
     917                                      Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]);
     918           RightHadronMass=RightHadron->GetPDGMass();
     919
     920//G4cout<<"Baryon "<<RightHadron->GetParticleName()<<G4endl;
     921
     922//G4cout<<"StringMass LeftHadronMass RightHadronMass "<<StringMass<<" "<<LeftHadronMass<<" "<< RightHadronMass<<G4endl;
     923
     924           if(StringMass >= LeftHadronMass + RightHadronMass)
     925           {
     926            G4double FS_Psqr=lambda(StringMassSqr,sqr(LeftHadronMass),
     927                                                  sqr(RightHadronMass));
     928            FS_Weight[NumberOf_FS]=std::sqrt(FS_Psqr)*
     929                                   MesonWeight[AbsIDquark-1][ProdQ-1][StateQ]*
     930                                   BaryonWeight[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]*
     931                                   Prob_QQbar[ProdQ-1];
     932
     933            FS_LeftHadron[NumberOf_FS] = LeftHadron;
     934            FS_RightHadron[NumberOf_FS]= RightHadron;
     935
     936//G4cout<<"State "<<NumberOf_FS<<" "<<std::sqrt(FS_Psqr/4./StringMassSqr)<<" "<<std::sqrt(FS_Psqr)<<" "<<FS_Weight[NumberOf_FS]<<G4endl;
     937//G4cout<<"++++++++++++++++++++++++++++++++"<<G4endl;
     938            NumberOf_FS++;
     939
     940if(NumberOf_FS > 24)
     941{G4int Uzhi; G4cout<<"QQbar string #_FS "<<NumberOf_FS<<G4endl; G4cin>>Uzhi;}
     942           } // End of if(StringMass >= LeftHadronMass + RightHadronMass)
     943
     944           StateDiQ++;
     945//G4cout<<Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]<<" "<<Di_q1-1<<" "<<Di_q2-1<<" "<<ProdQ-1<<" "<<StateDiQ<<G4endl;
     946          } while(Baryon[Di_q1-1][Di_q2-1][ProdQ-1][StateDiQ]!=0);
     947
     948          StateQ++;
     949         } while(Meson[AbsIDquark-1][ProdQ-1][StateQ]!=0);
     950        } // End of for(G4int ProdQ=1; ProdQ < 4; ProdQ++)
     951     }
     952//====================================
     953
     954     if(NumberOf_FS == 0) return false;
     955//G4cout<<"NumberOf_FS "<<NumberOf_FS<<G4endl;
     956     G4double SumWeights=0.;
     957     for(G4int i=0; i<NumberOf_FS; i++) {SumWeights+=FS_Weight[i];}
     958
     959     G4double ksi=G4UniformRand();
     960     G4double Sum=0.;
     961     G4int SampledState(0);
     962
     963     for(G4int i=0; i<NumberOf_FS; i++)
     964     {
     965      Sum+=(FS_Weight[i]/SumWeights);
     966      SampledState=i;
     967      if(Sum >= ksi) break;
     968     }
     969
     970     LeftHadron =FS_LeftHadron[SampledState];
     971     RightHadron=FS_RightHadron[SampledState];
     972
     973//G4cout<<"Selected "<<SampledState<<" "<<LeftHadron->GetParticleName()<<" "<<RightHadron->GetParticleName()<<G4endl;
     974
     975    }  // End of if(!string->FourQuarkString())
    405976
    406977    G4LorentzVector  LeftMom, RightMom;
    … …  
    409980    Sample4Momentum(&LeftMom,  LeftHadron->GetPDGMass(),
    410981                    &RightMom, RightHadron->GetPDGMass(),
    411                     ResidualMass);
     982                    StringMass);
    412983
    413984    LeftMom.boost(ClusterVel);
    … …  
    4291000     G4double MassMt2, AntiMassMt2;                                         
    4301001     G4double AvailablePz, AvailablePz2;                                   
    431                                                                            
    432     if(Mass > 930. || AntiMass > 930.)              // If there is a baryon
     1002
     1003//G4cout<<"Masses "<<InitialMass<<" "<<Mass<<" "<<AntiMass<<G4endl;
     1004//                                                                           
     1005
     1006    if((Mass > 930. || AntiMass > 930.)) //If there is a baryon
    4331007    {
    434      // ----------------- Isotripic decay ------------------------------------
     1008// ----------------- Isotropic decay ------------------------------------
    4351009       G4double r_val = sqr(InitialMass*InitialMass - Mass*Mass - AntiMass*AntiMass) -
    4361010                          sqr(2.*Mass*AntiMass);
    4371011       G4double Pabs = (r_val > 0.)? std::sqrt(r_val)/(2.*InitialMass) : 0;
     1012//G4cout<<"P for isotr decay "<<Pabs<<G4endl;
    4381013
    4391014     //... sample unit vector       
    440        G4double pz = 1. - 2.*G4UniformRand(); 
     1015       G4double pz =1. - 2.*G4UniformRand(); 
    4411016       G4double st     = std::sqrt(1. - pz * pz)*Pabs;
    4421017       G4double phi    = 2.*pi*G4UniformRand();
    … …  
    4501025       AntiMom->setPx(-px); AntiMom->setPy(-py); AntiMom->setPz(-pz);
    4511026       AntiMom->setE (std::sqrt(Pabs*Pabs + AntiMass*AntiMass));
     1027//G4int Uzhi; G4cin>>Uzhi;
    4521028    }         
    4531029    else
     1030//
    4541031   {
    4551032      do                                                                     
    … …  
    4611038         G4double termN = 2*termD + 4*Mass*Mass + 4*AntiMass*AntiMass;
    4621039         G4double pt2max=(termD*termD - termab )/ termN ;
     1040//G4cout<<"Anis "<<pt2max<<" "<<(termD*termD-termab)/(4.*InitialMass*InitialMass)<<G4endl;
    4631041                                               
    4641042         Pt=SampleQuarkPt(std::sqrt(pt2max)); Pt.setZ(0); G4double Pt2=Pt.mag2();
    465 
     1043//G4cout<<"Sampl pt2 "<<Pt2<<G4endl;
    4661044         MassMt2    =     Mass *     Mass + Pt2;                             
    4671045         AntiMassMt2= AntiMass * AntiMass + Pt2;                             
    … …  
    4911069        G4FragmentingString * string, G4FragmentingString * newString)
    4921070{
     1071//G4cout<<"Start SplitEandP "<<G4endl;
    4931072       G4LorentzVector String4Momentum=string->Get4Momentum();
    4941073       G4double StringMT2=string->Get4Momentum().mt2();
    … …  
    4961075       G4double HadronMass = pHadron->GetPDGMass();
    4971076
    498        SetMinimalStringMass(newString);                                       
     1077       SetMinimalStringMass(newString);           
     1078//G4cout<<"HadM MinimalStringMassLeft StringM "<<HadronMass<<" "<<MinimalStringMass<<" "<<String4Momentum.mag()<<G4endl;
     1079   
     1080if(HadronMass + MinimalStringMass > String4Momentum.mag()) {return 0;}// have to start all over!
    4991081       String4Momentum.setPz(0.);
    5001082       G4ThreeVector StringPt=String4Momentum.vect();
    … …  
    5171099        G4double Pz2 = (sqr(StringMT2 - HadronMassT2 - ResidualMassT2) -             
    5181100                                      4*HadronMassT2 * ResidualMassT2)/4./StringMT2;
    519 
     1101//G4cout<<"Pz2 "<<Pz2<<G4endl;
    5201102        if(Pz2 < 0 ) {return 0;}          // have to start all over!           
    5211103
    … …  
    5261108       G4double zMax = (std::sqrt(HadronMassT2+Pz2) + Pz)/std::sqrt(StringMT2); 
    5271109
     1110//G4cout<<"if (zMin >= zMax) return 0 "<<zMin<<" "<<zMax<<G4endl;
    5281111       if (zMin >= zMax) return 0;              // have to start all over!
    5291112       
    … …  
    5311114                       string->GetDecayParton()->GetPDGEncoding(), pHadron,
    5321115                       HadronPt.x(), HadronPt.y());     
    533        
     1116//G4cout<<"z "<<z<<G4endl;       
    5341117       //... now compute hadron longitudinal momentum and energy
    5351118       // longitudinal hadron momentum component HadronPz
    … …  
    5431126
    5441127       G4LorentzVector * a4Momentum= new G4LorentzVector(HadronPt,HadronE);
    545 
     1128//G4cout<<"Out SplitEandP "<<G4endl;
    5461129       return a4Momentum;
    5471130}
    … …  
    5961179    return z;
    5971180    }
     1181
     1182//------------------------------------------------------------------------
     1183G4double G4LundStringFragmentation::lambda(G4double s, G4double m1_Sqr, G4double m2_Sqr)
     1184{
     1185    G4double lam = sqr(s - m1_Sqr - m2_Sqr) - 4.*m1_Sqr*m2_Sqr;
     1186    return lam;
     1187}
     1188

  • trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4QGSMFragmentation.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4QGSMFragmentation.cc,v 1.9 2008/06/23 08:35:55 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4QGSMFragmentation.cc,v 1.10 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// -----------------------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4VKinkyStringDecay.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4VKinkyStringDecay.cc,v 1.4 2008/04/25 14:20:14 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VKinkyStringDecay.cc,v 1.5 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//  Maxim Komogorov
    3030//

  • trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4VLongitudinalStringDecay.cc,v 1.20 2010/06/21 17:50:48 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VLongitudinalStringDecay.cc,v 1.22 2010/09/20 12:46:23 vuzhinsk Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// -----------------------------------------------------------------------------
    … …  
    7171
    7272// Changable Parameters below.
    73    SigmaQT = 0.5 * GeV;
     73   SigmaQT = 0.5 * GeV;  // 0.5
    7474   
    7575   StrangeSuppress  = 0.44;    //  27 % strange quarks produced, ie. u:d:s=1:1:0.27
    … …  
    250250           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
    251251                                                 string->GetRightParton());
     252//G4cout<<"Hadron1 "<<Hadron1->GetParticleName()<<G4endl;
    252253           mass= (Hadron1)->GetPDGMass();
    253254        } else
    … …  
    323324                        G4FragmentingString *&newString)
    324325{
     326//G4cout<<"Start SplitUP"<<G4endl;
    325327       //... random choice of string end to use for creating the hadron (decay)   
    326328       SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
    … …  
    341343           HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
    342344       }     
     345
     346//G4cout<<"New had "<<HadronDefinition->GetParticleName()<<G4endl;
    343347// create new String from old, ie. keep Left and Right order, but replace decay
    344348
    345349       newString=new G4FragmentingString(*string,newStringEnd); // To store possible
    346350                                                                // quark containt of new string
     351//G4cout<<"SplitEandP "<<G4endl;
    347352       G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
    348353
    … …  
    360365           delete HadronMomentum;
    361366       }     
     367//G4cout<<"End SplitUP"<<G4endl;
    362368       return Hadron;
    363369}

  • trunk/source/processes/hadronic/models/parton_string/management/History

    r1196 r1340  
    1 $Id: History,v 1.7 2009/07/17 12:41:20 vuzhinsk Exp $
     1$Id: History,v 1.9 2010/09/08 16:57:50 gunter Exp $
    22-------------------------------------------------------------------
    33
    … …  
    1515     * Please list in reverse chronological order (last date on top)
    1616     ---------------------------------------------------------------
     17
     188-Sept-2010, G.Folger       (had-partonstring-mgt-V09-03-00)
     19  use integer interface of G4Nucleus for A&Z
     20 
     216 Dec. 2009, V. Uzhinsky  (had-partonstring-mgt-V09-02-02)
     22  Repeatation of string fragmentation if
     23  energy corr. can not be done is implemented.
     24
    172517-July-2009 V. Uzhinsky  (had-partonstring-mgt-V09-02-01)
    1826  A Status of nuclear nucleon involved in an interaction is introdused.

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4EventGenerator.hh

    r1337 r1340  
    2626//
    2727// $Id: G4EventGenerator.hh,v 1.3 2006/06/29 20:55:13 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030#ifndef G4EventGenerator_h

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4InteractionCode.hh

    r1337 r1340  
    2626//
    2727// $Id: G4InteractionCode.hh,v 1.3 2006/06/29 20:55:15 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030#ifndef G4InteractionCode_h

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4InteractionContent.hh

    r1337 r1340  
    2626//
    2727// $Id: G4InteractionContent.hh,v 1.5 2009/07/17 12:36:41 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4PomeronCrossSection.hh

    r1337 r1340  
    2828//
    2929// $Id: G4PomeronCrossSection.hh,v 1.3 2006/06/29 20:55:19 gunter Exp $
    30 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     30// GEANT4 tag $Name: geant4-09-03-ref-09 $
    3131//
    3232#include "G4Proton.hh"

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4StringModel.hh

    r1337 r1340  
    2626//
    2727// $Id: G4StringModel.hh,v 1.3 2006/06/29 20:55:23 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030#ifndef G4StringModel_h

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4VParticipants.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4VParticipants.hh,v 1.6 2009/11/19 14:23:09 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4VParticipants.hh,v 1.7 2010/09/08 16:58:04 gunter Exp $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030
    … …  
    5959      int operator!=(const G4VParticipants &right) const;
    6060
    61       void Init(G4double theZ, G4double theA);
     61      void Init(G4int theZ, G4int theA);
    6262     
    6363      void SetNucleus(G4V3DNucleus * aNucleus);
    … …  
    8686}
    8787
    88 inline void G4VParticipants::Init(G4double theA, G4double theZ)
     88inline void G4VParticipants::Init(G4int theA, G4int theZ)
    8989{
    9090        if ( theNucleus == NULL ) theNucleus = new G4Fancy3DNucleus();

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4VPartonStringModel.hh

    r1337 r1340  
    2626//
    2727// $Id: G4VPartonStringModel.hh,v 1.3 2006/06/29 20:55:27 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030#ifndef G4VPartonStringModel_h

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4VSplitableHadron.hh

    r1337 r1340  
    2626//
    2727// $Id: G4VSplitableHadron.hh,v 1.6 2009/07/17 12:36:41 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4VStringFragmentation.hh

    r1337 r1340  
    2626//
    2727// $Id: G4VStringFragmentation.hh,v 1.3 2006/06/29 20:55:31 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030#ifndef G4VStringFragmentation_h

  • trunk/source/processes/hadronic/models/parton_string/management/include/G4VertexCode.hh

    r1337 r1340  
    2626//
    2727// $Id: G4VertexCode.hh,v 1.3 2006/06/29 20:55:33 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030#ifndef G4VertexCode_h

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4EventGenerator.cc

    r1337 r1340  
    2626//
    2727// $Id: G4EventGenerator.cc,v 1.4 2006/06/29 20:55:37 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// G4EventGenerator

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4InteractionContent.cc

    r1337 r1340  
    2626//
    2727// $Id: G4InteractionContent.cc,v 1.4 2006/06/29 20:55:39 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// ------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4PomeronCrossSection.cc

    r1337 r1340  
    2626//
    2727// $Id: G4PomeronCrossSection.cc,v 1.6 2006/11/07 12:51:39 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4StringModel.cc

    r1337 r1340  
    2626//
    2727// $Id: G4StringModel.cc,v 1.4 2006/06/29 20:55:45 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// G4StringModel

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4VParticipants.cc

    r1337 r1340  
    2626//
    2727// $Id: G4VParticipants.cc,v 1.3 2006/06/29 20:55:47 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// ------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4VPartonStringModel.cc

    r1337 r1340  
    2626//
    2727// $Id: G4VPartonStringModel.cc,v 1.6 2009/10/05 12:52:48 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030//// ------------------------------------------------------------

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4VSplitableHadron.cc

    r1337 r1340  
    2626//
    2727// $Id: G4VSplitableHadron.cc,v 1.7 2009/07/17 12:36:41 vuzhinsk Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/parton_string/management/src/G4VStringFragmentation.cc

    r1337 r1340  
    2626//
    2727// $Id: G4VStringFragmentation.cc,v 1.4 2006/06/29 20:55:53 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     28// GEANT4 tag $Name: geant4-09-03-ref-09 $
    2929//
    3030// G4VStringFragmentation

  • trunk/source/processes/hadronic/models/parton_string/qgsm/History

    r1315 r1340  
    1 $Id: History,v 1.9 2010/03/12 15:58:21 gunter Exp $
     1$Id: History,v 1.10 2010/09/08 15:51:28 gunter Exp $
    22-------------------------------------------------------------------
    33
    … …  
    1515     * Please list in reverse chronological order (last date on top)
    1616     ---------------------------------------------------------------
     17
     18
     198 Sep 2010, G.Folger            (hadr-qgsm-V09-03-01)
     20-----------------------------------------------------
     21- G4QGSModel.icc: use integer (A,Z) interface of nucleus
    1722
    182312-Mar-2010, G.Folger           (hadr-qgsm-V09-03-00)

  • trunk/source/processes/hadronic/models/parton_string/qgsm/include/G4QGSModel.icc

    r819 r1340  
    4646    {
    4747     // clean-up and consistency with design, HPW Feb 1999
    48     theParticipants.Init(aNucleus.GetN(),aNucleus.GetZ());
     48    theParticipants.Init(aNucleus.GetA_asInt(),aNucleus.GetZ_asInt());
    4949    theCurrentVelocity.setX(0);   
    5050    theCurrentVelocity.setY(0);
Note: See TracChangeset for help on using the changeset viewer.