source: trunk/source/processes/hadronic/models/parton_string/hadronization/src/G4VLongitudinalStringDecay.cc @ 1228

Last change on this file since 1228 was 1228, checked in by garnier, 14 years ago

update geant4.9.3 tag
File size: 25.9 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26//
27// $Id: G4VLongitudinalStringDecay.cc,v 1.18 2009/08/03 13:21:25 vuzhinsk Exp $
28// GEANT4 tag $Name: geant4-09-03 $
29//
30// -----------------------------------------------------------------------------
31//      GEANT 4 class implementation file
32//
33//      History: first implementation, Maxim Komogorov, 1-Jul-1998
34//               redesign  Gunter Folger, August/September 2001
35// -----------------------------------------------------------------------------
36#include "G4ios.hh"
37#include "Randomize.hh"
38#include "G4VLongitudinalStringDecay.hh"
39#include "G4FragmentingString.hh"
40
41#include "G4ParticleDefinition.hh"
42#include "G4ParticleTypes.hh"
43#include "G4ParticleChange.hh"
44#include "G4VShortLivedParticle.hh"
45#include "G4ShortLivedConstructor.hh"
46#include "G4ParticleTable.hh"
47#include "G4ShortLivedTable.hh"
48#include "G4PhaseSpaceDecayChannel.hh"
49#include "G4VDecayChannel.hh"
50#include "G4DecayTable.hh"
51
52#include "G4DiQuarks.hh"
53#include "G4Quarks.hh"
54#include "G4Gluons.hh"
55
56//------------------------debug switches
57//#define DEBUG_LightFragmentationTest 1
58
59
60//********************************************************************************
61// Constructors
62
63G4VLongitudinalStringDecay::G4VLongitudinalStringDecay()
64{
65   MassCut  = 0.35*GeV; 
66   ClusterMass = 0.15*GeV;
67
68   SmoothParam      = 0.9; 
69   StringLoopInterrupt    = 1000;
70   ClusterLoopInterrupt   =  500;
71
72// Changable Parameters below.
73   SigmaQT = 0.5 * GeV;
74   
75   StrangeSuppress  = 0.44;    //  27 % strange quarks produced, ie. u:d:s=1:1:0.27
76   DiquarkSuppress  = 0.07;
77   DiquarkBreakProb = 0.1;
78   
79   //... pspin_meson is probability to create vector meson
80   pspin_meson = 0.5;
81
82   //... pspin_barion is probability to create 3/2 barion
83   pspin_barion = 0.5;
84
85   //... vectorMesonMix[] is quark mixing parameters for vector mesons (Variable spin = 3)
86   vectorMesonMix.resize(6);
87   vectorMesonMix[0] = 0.5;
88   vectorMesonMix[1] = 0.0;
89   vectorMesonMix[2] = 0.5;
90   vectorMesonMix[3] = 0.0;
91   vectorMesonMix[4] = 1.0;
92   vectorMesonMix[5] = 1.0; 
93
94   //... scalarMesonMix[] is quark mixing parameters for scalar mesons (Variable spin=1)
95   scalarMesonMix.resize(6);
96   scalarMesonMix[0] = 0.5; 
97   scalarMesonMix[1] = 0.25; 
98   scalarMesonMix[2] = 0.5; 
99   scalarMesonMix[3] = 0.25; 
100   scalarMesonMix[4] = 1.0; 
101   scalarMesonMix[5] = 0.5; 
102
103// Parameters may be changed until the first fragmentation starts
104   PastInitPhase=false;
105   hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
106                                scalarMesonMix,vectorMesonMix);
107   Kappa = 1.0 * GeV/fermi;
108
109
110}
111   
112
113G4VLongitudinalStringDecay::~G4VLongitudinalStringDecay()
114   {
115   delete hadronizer;
116   }
117
118//=============================================================================
119
120// Operators
121
122//const  & G4VLongitudinalStringDecay::operator=(const G4VLongitudinalStringDecay &)
123//    {
124//    }
125
126//-----------------------------------------------------------------------------
127
128int G4VLongitudinalStringDecay::operator==(const G4VLongitudinalStringDecay &) const
129    {
130        throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::operator== forbidden");
131        return false;
132    }
133
134//-------------------------------------------------------------------------------------
135
136int G4VLongitudinalStringDecay::operator!=(const G4VLongitudinalStringDecay &) const
137    {
138        throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::operator!= forbidden");
139        return true;
140    }
141
142//***********************************************************************************
143
144// For changing Mass Cut used for selection of very small mass strings
145void G4VLongitudinalStringDecay::SetMassCut(G4double aValue){MassCut=aValue;}
146
147//-----------------------------------------------------------------------------
148
149// For handling a string with very low mass
150
151G4KineticTrackVector* G4VLongitudinalStringDecay::LightFragmentationTest(const
152                G4ExcitedString * const string)
153{
154   // Check string decay threshold
155               
156        G4KineticTrackVector * result=0;  // return 0 when string exceeds the mass cut
157       
158        pDefPair hadrons((G4ParticleDefinition *)0,(G4ParticleDefinition *)0);
159
160        G4FragmentingString aString(*string);
161
162        if ( sqr(FragmentationMass(&aString,0,&hadrons)+MassCut) < aString.Mass2()) {
163                return 0;
164        }
165
166// The string mass is very low ---------------------------
167       
168        result=new G4KineticTrackVector;
169       
170        if ( hadrons.second ==0 )
171        {
172// Substitute string by light hadron, Note that Energy is not conserved here!
173
174/*               
175#ifdef DEBUG_LightFragmentationTest
176               G4cout << "VlongSF Warning replacing string by single hadron " <<G4endl;
177               G4cout << hadrons.first->GetParticleName()
178                      << "string .. " << string->Get4Momentum() << " "
179                      << string->Get4Momentum().m() << G4endl;
180#endif               
181G4cout << "VlongSF Warning replacing string by single hadron " <<G4endl;
182G4cout << hadrons.first->GetParticleName() << " string .. " <<G4endl;
183G4cout << string->Get4Momentum() << " " << string->Get4Momentum().m() << G4endl;
184*/
185               G4ThreeVector   Mom3 = string->Get4Momentum().vect();
186               G4LorentzVector Mom(Mom3, 
187                                   std::sqrt(Mom3.mag2() + 
188                                             sqr(hadrons.first->GetPDGMass())));
189               result->push_back(new G4KineticTrack(hadrons.first, 0, 
190                                                  string->GetPosition(),
191                                                          Mom));
192        } else 
193        {
194//... string was qq--qqbar type: Build two stable hadrons,
195
196#ifdef DEBUG_LightFragmentationTest
197               G4cout << "VlongSF Warning replacing qq-qqbar string by TWO hadrons " 
198                      << hadrons.first->GetParticleName() << " / " 
199                      << hadrons.second->GetParticleName()
200                      << "string .. " << string->Get4Momentum() << " " 
201                      << string->Get4Momentum().m() << G4endl;
202#endif               
203
204// Uzhi Formation time in the case???
205
206               G4LorentzVector  Mom1, Mom2;
207               Sample4Momentum(&Mom1, hadrons.first->GetPDGMass(), 
208                               &Mom2,hadrons.second->GetPDGMass(),
209                               string->Get4Momentum().mag());
210
211               result->push_back(new G4KineticTrack(hadrons.first, 0, 
212                                                    string->GetPosition(), 
213                                                            Mom1));
214               result->push_back(new G4KineticTrack(hadrons.second, 0, 
215                                                    string->GetPosition(), 
216                                                    Mom2));
217
218               G4ThreeVector Velocity = string->Get4Momentum().boostVector();
219               result->Boost(Velocity);         
220        }
221
222        return result;
223       
224}
225
226//----------------------------------------------------------------------------------------
227
228G4double G4VLongitudinalStringDecay::FragmentationMass(
229            const G4FragmentingString * const string,
230                Pcreate build, pDefPair * pdefs       )
231{
232       
233        G4double mass;
234        static G4bool NeedInit(true);
235        static std::vector<double> nomix;
236        static G4HadronBuilder * minMassHadronizer;
237        if ( NeedInit ) 
238        {
239           NeedInit = false;
240           nomix.resize(6);
241           for ( G4int i=0; i<6 ; i++ ) nomix[i]=0;
242
243//         minMassHadronizer=new G4HadronBuilder(pspin_meson,pspin_barion,nomix,nomix);
244           minMassHadronizer=hadronizer;
245        }
246
247        if ( build==0 ) build=&G4HadronBuilder::BuildLowSpin;
248
249        G4ParticleDefinition *Hadron1, *Hadron2=0;
250
251        if (!string->FourQuarkString() )
252        {
253           // spin 0 meson or spin 1/2 barion will be built
254
255           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
256                                                 string->GetRightParton());
257           mass= (Hadron1)->GetPDGMass();
258        } else
259        {
260           //... string is qq--qqbar: Build two stable hadrons,
261           //...    with extra uubar or ddbar quark pair
262           G4int iflc = (G4UniformRand() < 0.5)? 1 : 2;
263           if (string->GetLeftParton()->GetPDGEncoding() < 0) iflc = -iflc;
264
265           //... theSpin = 4; spin 3/2 baryons will be built
266           Hadron1 = (minMassHadronizer->*build)(string->GetLeftParton(),
267                                                 FindParticle(iflc)       );
268           Hadron2 = (minMassHadronizer->*build)(string->GetRightParton(),
269                                                 FindParticle(-iflc)      );
270           mass = (Hadron1)->GetPDGMass() + (Hadron2)->GetPDGMass();
271        }
272       
273        if ( pdefs != 0 ) 
274        { // need to return hadrons as well....
275           pdefs->first  = Hadron1;
276           pdefs->second = Hadron2;
277        }
278           
279        return mass;
280}
281
282//----------------------------------------------------------------------------
283
284G4ParticleDefinition* G4VLongitudinalStringDecay::FindParticle(G4int Encoding) 
285   {
286   G4ParticleDefinition* ptr = G4ParticleTable::GetParticleTable()->FindParticle(Encoding);
287      if (ptr == NULL)
288       {
289       G4cout << "Particle with encoding "<<Encoding<<" does not exist!!!"<<G4endl;
290       throw G4HadronicException(__FILE__, __LINE__, "Check your particle table");
291       }
292   return ptr;   
293   }
294
295//-----------------------------------------------------------------------------
296//   virtual void Sample4Momentum(G4LorentzVector* Mom,     G4double Mass,
297//                                G4LorentzVector* AntiMom, G4double AntiMass,
298//                                G4double InitialMass)=0;
299//-----------------------------------------------------------------------------
300
301//*********************************************************************************
302//   For decision on continue or stop string fragmentation
303//   virtual G4bool StopFragmenting(const G4FragmentingString  * const string)=0;
304//   virtual G4bool IsFragmentable(const G4FragmentingString * const string)=0;
305
306//   If a string can not fragment, make last break into 2 hadrons
307//   virtual G4bool SplitLast(G4FragmentingString * string,
308//                            G4KineticTrackVector * LeftVector,
309//                            G4KineticTrackVector * RightVector)=0;
310//-----------------------------------------------------------------------------
311//
312//   If a string fragments, do the following
313//
314//   For transver of a string to its CMS frame
315//-----------------------------------------------------------------------------
316
317G4ExcitedString *G4VLongitudinalStringDecay::CPExcited(const G4ExcitedString & in)
318{
319        G4Parton *Left=new G4Parton(*in.GetLeftParton());
320        G4Parton *Right=new G4Parton(*in.GetRightParton());
321        return new G4ExcitedString(Left,Right,in.GetDirection());
322}
323
324//-----------------------------------------------------------------------------
325
326G4KineticTrack * G4VLongitudinalStringDecay::Splitup(
327                        G4FragmentingString *string, 
328                        G4FragmentingString *&newString)
329{
330//G4cout<<"In G4VLong String Dec######################"<<G4endl;
331
332       //... random choice of string end to use for creating the hadron (decay)   
333       SideOfDecay = (G4UniformRand() < 0.5)? 1: -1;
334       if (SideOfDecay < 0)
335       {
336          string->SetLeftPartonStable();
337       } else
338       {
339          string->SetRightPartonStable();
340       }
341
342       G4ParticleDefinition *newStringEnd;
343       G4ParticleDefinition * HadronDefinition;
344       if (string->DecayIsQuark())
345       {
346           HadronDefinition= QuarkSplitup(string->GetDecayParton(), newStringEnd);
347       } else {
348           HadronDefinition= DiQuarkSplitup(string->GetDecayParton(), newStringEnd);
349       }     
350// create new String from old, ie. keep Left and Right order, but replace decay
351
352       newString=new G4FragmentingString(*string,newStringEnd); // To store possible
353                                                                // quark containt of new string
354       G4LorentzVector* HadronMomentum=SplitEandP(HadronDefinition, string, newString);
355
356       delete newString; newString=0;                          // Uzhi 20.06.08
357       
358       G4KineticTrack * Hadron =0;
359       if ( HadronMomentum != 0 ) {   
360
361           G4ThreeVector   Pos;
362           Hadron = new G4KineticTrack(HadronDefinition, 0,Pos, *HadronMomentum);
363 
364           newString=new G4FragmentingString(*string,newStringEnd,
365                                        HadronMomentum);
366
367//G4cout<<"Out G4VLong String Dec######################"<<G4endl;         
368//G4cout<<"newString 4Mom"<<newString->Get4Momentum()<<G4endl;
369//G4cout<<"newString Pl  "<<newString->LightConePlus()<<G4endl;
370//G4cout<<"newString Mi  "<<newString->LightConeMinus()<<G4endl;
371//G4cout<<"newString Pts "<<newString->StablePt()<<G4endl;
372//G4cout<<"newString Ptd "<<newString->DecayPt()<<G4endl;
373//G4cout<<"newString M2  "<<newString->Mass2()<<G4endl;
374//G4cout<<"newString M2  "<<newString->Mass()<<G4endl;
375           delete HadronMomentum;
376       }     
377       return Hadron;
378}
379
380//--------------------------------------------------------------------------------------
381
382G4ParticleDefinition *
383                G4VLongitudinalStringDecay::QuarkSplitup(G4ParticleDefinition*
384                decay, G4ParticleDefinition *&created)
385{
386    G4int IsParticle=(decay->GetPDGEncoding()>0) ? -1 : +1; // if we have a quark,
387                                                            // we need antiquark
388                                                            // (or diquark)
389    pDefPair QuarkPair = CreatePartonPair(IsParticle);
390    created = QuarkPair.second;
391    return hadronizer->Build(QuarkPair.first, decay);
392   
393}
394
395//-----------------------------------------------------------------------------
396
397G4ParticleDefinition *G4VLongitudinalStringDecay::DiQuarkSplitup(
398                                                        G4ParticleDefinition* decay,
399                                                        G4ParticleDefinition *&created)
400{
401   //... can Diquark break or not?
402   if (G4UniformRand() < DiquarkBreakProb ){
403   //... Diquark break
404
405      G4int stableQuarkEncoding = decay->GetPDGEncoding()/1000;
406      G4int decayQuarkEncoding = (decay->GetPDGEncoding()/100)%10;
407      if (G4UniformRand() < 0.5)
408         {
409         G4int Swap = stableQuarkEncoding;
410         stableQuarkEncoding = decayQuarkEncoding;
411         decayQuarkEncoding = Swap;
412         }
413
414      G4int IsParticle=(decayQuarkEncoding>0) ? -1 : +1; 
415                        // if we have a quark, we need antiquark)
416      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
417      //... Build new Diquark
418      G4int QuarkEncoding=QuarkPair.second->GetPDGEncoding();
419      G4int i10  = std::max(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
420      G4int i20  = std::min(std::abs(QuarkEncoding), std::abs(stableQuarkEncoding));
421      G4int spin = (i10 != i20 && G4UniformRand() <= 0.5)? 1 : 3;
422      G4int NewDecayEncoding = -1*IsParticle*(i10 * 1000 + i20 * 100 + spin);
423      created = FindParticle(NewDecayEncoding);
424      G4ParticleDefinition * decayQuark=FindParticle(decayQuarkEncoding);
425      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decayQuark);
426      return had;
427//      return hadronizer->Build(QuarkPair.first, decayQuark);
428   
429   } else {
430   //... Diquark does not break
431 
432      G4int IsParticle=(decay->GetPDGEncoding()>0) ? +1 : -1; 
433                        // if we have a diquark, we need quark)
434      pDefPair QuarkPair = CreatePartonPair(IsParticle,false);  // no diquarks wanted
435      created = QuarkPair.second;
436
437      G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
438      return had;
439//      return G4ParticleDefinition * had=hadronizer->Build(QuarkPair.first, decay);
440   }
441}
442
443//-----------------------------------------------------------------------------
444
445G4int G4VLongitudinalStringDecay::SampleQuarkFlavor(void)
446   {
447   return (1 + (int)(G4UniformRand()/StrangeSuppress));
448   }
449
450//-----------------------------------------------------------------------------
451
452G4VLongitudinalStringDecay::pDefPair G4VLongitudinalStringDecay::CreatePartonPair(G4int NeedParticle,G4bool AllowDiquarks)
453{
454//  NeedParticle = +1 for Particle, -1 for Antiparticle
455
456    if ( AllowDiquarks && G4UniformRand() < DiquarkSuppress )
457    {
458      // Create a Diquark - AntiDiquark pair , first in pair is anti to IsParticle
459      G4int q1  = SampleQuarkFlavor();
460      G4int q2  = SampleQuarkFlavor();
461      G4int spin = (q1 != q2 && G4UniformRand() <= 0.5)? 1 : 3;
462                                     //   convention: quark with higher PDG number is first
463      G4int PDGcode = (std::max(q1,q2) * 1000 + std::min(q1,q2) * 100 + spin) * NeedParticle;
464      return pDefPair (FindParticle(-PDGcode),FindParticle(PDGcode));
465     
466
467    } else {
468      // Create a Quark - AntiQuark pair, first in pair  IsParticle
469      G4int PDGcode=SampleQuarkFlavor()*NeedParticle;
470      return pDefPair (FindParticle(PDGcode),FindParticle(-PDGcode));
471    }
472
473}
474
475//-----------------------------------------------------------------------------
476
477// G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt()
478//    {
479//    G4double width_param= 2.0 * GeV*GeV;
480//    G4double R = G4UniformRand();
481//    G4double Pt = std::sqrt(width_param*R/(1-R));
482//    G4double phi = 2.*pi*G4UniformRand();
483//    return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
484//    }
485
486G4ThreeVector G4VLongitudinalStringDecay::SampleQuarkPt(G4double ptMax)
487   {
488   G4double Pt;
489   if ( ptMax < 0 ) {
490      // sample full gaussian
491      Pt = -std::log(G4UniformRand());
492   } else {
493      // sample in limited range
494      Pt = -std::log(CLHEP::RandFlat::shoot(std::exp(-sqr(ptMax)/sqr(SigmaQT)), 1.));
495   }
496   Pt = SigmaQT * std::sqrt(Pt);
497   G4double phi = 2.*pi*G4UniformRand();
498   return G4ThreeVector(Pt * std::cos(phi),Pt * std::sin(phi),0);
499   }
500
501//******************************************************************************
502
503void G4VLongitudinalStringDecay::CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector* Hadrons)
504   {
505
506//   `yo-yo` formation time
507//   const G4double kappa = 1.0 * GeV/fermi/4.;      // Uzhi String tension 1.06.08
508     G4double kappa = GetStringTensionParameter();
509//G4cout<<"Kappa "<<kappa<<G4endl;                   // Uzhi 20.06.08
510//G4int Uzhi; G4cin>>Uzhi;                           // Uzhi 20.06.08
511//G4cout<<"Number of hadrons "<<Hadrons->size()<<G4endl; // Vova
512   for(size_t c1 = 0; c1 < Hadrons->size(); c1++)
513      {
514      G4double SumPz = 0; 
515      G4double SumE  = 0;
516      for(size_t c2 = 0; c2 < c1; c2++)
517         {
518         SumPz += Hadrons->operator[](c2)->Get4Momentum().pz();
519         SumE  += Hadrons->operator[](c2)->Get4Momentum().e();   
520         } 
521      G4double HadronE  = Hadrons->operator[](c1)->Get4Momentum().e();
522      G4double HadronPz = Hadrons->operator[](c1)->Get4Momentum().pz();
523      Hadrons->operator[](c1)->SetFormationTime(
524(theInitialStringMass - 2.*SumPz + HadronE - HadronPz)/(2.*kappa)/c_light); //Uzhi1.07.09c_light
525
526      G4ThreeVector aPosition(0, 0,     
527(theInitialStringMass - 2.*SumE  - HadronE + HadronPz)/(2.*kappa));
528      Hadrons->operator[](c1)->SetPosition(aPosition);
529
530/*
531G4cout<<"kappa "<<kappa<<G4endl;
532G4cout<<c1<<" Partic time, position Old "<<
533(theInitialStringMass - 2.*SumPz + HadronE - HadronPz)/(2.*kappa)<<' '<<
534(theInitialStringMass - 2.*SumE  - HadronE + HadronPz)/(2.*kappa)<<G4endl;
535
536G4cout<<c1<<" Partic time, position New "<<
537(theInitialStringMass - 2.*SumPz + HadronE - HadronPz)/(2.*kappa)/c_light<<' '<<
538(theInitialStringMass - 2.*SumE  - HadronE + HadronPz)/(2.*kappa)<<G4endl;
539
540G4cout<<"fermi "<<fermi<<" 1/fermi "<<1./fermi<<' '<<"1*fermi/c "<<1.*fermi/c_light<<G4endl;
541G4int Uzhi; G4cin>>Uzhi;                           // Uzhi 20.06.08
542*/
543      } 
544   }
545
546//-----------------------------------------------------------------------------
547
548/*
549void G4VLongitudinalStringDecay::CalculateHadronTimePosition(G4double theInitialStringMass, G4KineticTrackVector* Hadrons)
550   {
551   // 'constituent' formation time
552   const G4double kappa = 1.0 * GeV/fermi;
553   for(G4int c1 = 0; c1 < Hadrons->length(); c1++)
554      {
555      G4double SumPz = 0;
556      G4double SumE  = 0;
557      for(G4int c2 = 0; c2 <= c1; c2++)
558         {
559         SumPz += Hadrons->at(c2)->Get4Momentum().pz();
560         SumE  += Hadrons->at(c2)->Get4Momentum().e();   
561         }
562      Hadrons->at(c1)->SetFormationTime((theInitialStringMass - 2.*SumPz)/(2.*kappa));
563      G4ThreeVector aPosition(0, 0,     (theInitialStringMass - 2.*SumE)/(2.*kappa));
564      Hadrons->at(c1)->SetPosition(aPosition);
565      }
566   c1 = Hadrons->length()-1;   
567   Hadrons->at(c1)->SetFormationTime(Hadrons->at(c1-1)->GetFormationTime());
568   Hadrons->at(c1)->SetPosition(Hadrons->at(c1-1)->GetPosition());
569   }
570*/
571
572
573//*****************************************************************************
574
575void G4VLongitudinalStringDecay::SetSigmaTransverseMomentum(G4double aValue)
576{
577        if ( PastInitPhase ) {
578                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetSigmaTransverseMomentum after FragmentString() not allowed");
579        } else {
580                SigmaQT = aValue;
581        }
582}
583
584//----------------------------------------------------------------------------------------------------------
585
586void G4VLongitudinalStringDecay::SetStrangenessSuppression(G4double aValue)
587{
588        if ( PastInitPhase ) {
589                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetStrangenessSuppression after FragmentString() not allowed");
590        } else {
591                StrangeSuppress = aValue;
592        }
593}
594
595//----------------------------------------------------------------------------------------------------------
596
597void G4VLongitudinalStringDecay::SetDiquarkSuppression(G4double aValue)
598{
599        if ( PastInitPhase ) {
600                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkSuppression after FragmentString() not allowed");
601        } else {
602                DiquarkSuppress = aValue;
603        }
604}
605
606//----------------------------------------------------------------------------------------
607
608void G4VLongitudinalStringDecay::SetDiquarkBreakProbability(G4double aValue)
609{
610        if ( PastInitPhase ) {
611                throw G4HadronicException(__FILE__, __LINE__, "4VLongitudinalStringDecay::SetDiquarkBreakProbability after FragmentString() not allowed");
612        } else {
613                DiquarkBreakProb = aValue;
614        }
615}
616
617//----------------------------------------------------------------------------------------------------------
618
619void G4VLongitudinalStringDecay::SetVectorMesonProbability(G4double aValue)
620{
621        if ( PastInitPhase ) {
622                throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonProbability after FragmentString() not allowed");
623        } else {
624                pspin_meson = aValue;
625                delete hadronizer;
626                hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
627                                scalarMesonMix,vectorMesonMix);
628        }
629}
630
631//----------------------------------------------------------------------------------------------------------
632
633void G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability(G4double aValue)
634{
635        if ( PastInitPhase ) {
636                throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetSpinThreeHalfBarionProbability after FragmentString() not allowed");
637        } else {
638                pspin_barion = aValue;
639                delete hadronizer;
640                hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
641                                scalarMesonMix,vectorMesonMix);
642        }
643}
644
645//----------------------------------------------------------------------------------------------------------
646
647void G4VLongitudinalStringDecay::SetScalarMesonMixings(std::vector<G4double> aVector)
648{
649        if ( PastInitPhase ) {
650                throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings after FragmentString() not allowed");
651        } else {
652          if ( aVector.size() < 6 ) 
653              throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetScalarMesonMixings( argument Vector too small");
654          scalarMesonMix[0] = aVector[0];
655          scalarMesonMix[1] = aVector[1];
656          scalarMesonMix[2] = aVector[2];
657          scalarMesonMix[3] = aVector[3];
658          scalarMesonMix[4] = aVector[4];
659          scalarMesonMix[5] = aVector[5];
660          delete hadronizer;
661          hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
662                                scalarMesonMix,vectorMesonMix);
663        }
664}
665
666//----------------------------------------------------------------------------------------------------------
667
668void G4VLongitudinalStringDecay::SetVectorMesonMixings(std::vector<G4double> aVector)
669{
670        if ( PastInitPhase ) {
671                throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings after FragmentString() not allowed");
672        } else {
673          if ( aVector.size() < 6 ) 
674              throw G4HadronicException(__FILE__, __LINE__, "G4VLongitudinalStringDecay::SetVectorMesonMixings( argument Vector too small");
675          vectorMesonMix[0] = aVector[0];
676          vectorMesonMix[1] = aVector[1];
677          vectorMesonMix[2] = aVector[2];
678          vectorMesonMix[3] = aVector[3];
679          vectorMesonMix[4] = aVector[4];
680          vectorMesonMix[5] = aVector[5];
681          delete hadronizer;
682          hadronizer = new G4HadronBuilder(pspin_meson,pspin_barion,
683                                scalarMesonMix,vectorMesonMix);
684 
685        }
686}
687
688//-------------------------------------------------------------------------------------------
689void G4VLongitudinalStringDecay::SetStringTensionParameter(G4double aValue)// Uzhi 20 June 08
690{
691          Kappa = aValue * GeV/fermi;
692}       
693//**************************************************************************************
694
Note: See TracBrowser for help on using the repository browser.