// @(#)root/venus:$Name: $:$Id: TVenus.cxx,v 1.1.1.1 2000/05/16 17:00:48 rdm Exp $
// Author: Ola Nordmann 21/09/95
/*************************************************************************
* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
* All rights reserved. *
* *
* For the licensing terms see $ROOTSYS/LICENSE. *
* For the list of contributors see $ROOTSYS/README/CREDITS. *
*************************************************************************/
//////////////////////////////////////////////////////////////////////////////
// //
// TVenus //
// //
// TVenus is an interface class between the event generator VENUS and //
// the ROOT system. The current implementation is based on VENUS 5.21 //
// //
// Authors of VENUS: //
// Klaus WERNER //
// Eugen FURLER (upgrade 5.04) //
// Michael HLADIK (upgrades 5.05, 5.13, 5.15, 5.17) //
// //
// Laboratoire Subatech, Universite de Nantes - IN2P3/CNRS - EMN //
// 4 rue Alfred Kastler, 44070 Nantes Cedex 03, France //
// //
// Email: <last name>@nanhp3.in2p3.fr //
// //
// VENUS is a Monte Carlo procedure to simulate hadronic interactions at //
// ultrarelativistic energies (hadron-hadron, hadron-nucleus, nucleus- //
// nucleus scattering). //
// //
// VENUS is based on Gribov-Regge theory (of multiple Pomeron exchange) //
// and classical relativistic string dynamics. A detailed description can // //
// be found in a review article, published in Physics Reports 232 (1993) //
// pp. 87-299. //
// //
// //
//////////////////////////////////////////////////////////////////////////////
#include "TGenerator.h"
#include "TAttParticle.h"
#include "TPrimary.h"
#include "TVenus.h"
#include "Vcommon.h"
#ifndef WIN32
# define aaset aaset_
# define atitle atitle_
# define veanly veanly_
# define ainit ainit_
# define avenus avenus_
# define qnbaaa qnbaaa_
# define aseed aseed_
# define afiles afiles_
# define type_of_call
#else
# define aaset AASET
# define atitle ATITLE
# define veanly VEANLY
# define ainit AINIT
# define avenus AVENUS
# define qnbaaa QNBAAA
# define aseed ASEED
# define afiles AFILES
# define type_of_call _stdcall
#endif
ClassImp(TVenus)
extern "C" {
// Venus function calls
void type_of_call aaset(Int_t &key);
void type_of_call atitle();
void type_of_call ainit();
void type_of_call avenus();
void type_of_call qnbaaa();
void type_of_call aseed();
void type_of_call afiles();
}
//______________________________________________________________________________
TVenus::TVenus():TGenerator("Venus","Venus")
{
//
// Event generator Venus default constructor
//
}
//______________________________________________________________________________
TVenus::TVenus(char *choice , Int_t /*numberOfEvents*/,
Int_t zprojectile , Int_t aprojectile,
Int_t ztarget , Int_t atarget,
Double_t incidentMomentum,
Bool_t labSys , Bool_t lastGeneration,
Double_t impactParameterMin, Double_t impactParameterMax,
Double_t phiMin , Double_t phiMax)
:TGenerator("Venus","Venus")
{
//
// Event generator Venus normal constructor
//
//
// Zero initilisation and reset of all parameters
//
Int_t zero=0;
aaset(zero);
if (!strcmp(choice,"Analysis")) {
PARO2.iappl = 0;
fChoice = choice;
}
else if (!strcmp(choice,"Hadron")) {
PARO2.iappl = 1;
fChoice = choice;
}
else if (!strcmp(choice,"Geometry")) {
PARO2.iappl = 2;
fChoice = choice;
}
else if (!strcmp(choice,"Lepton")) {
PARO2.iappl = 3;
fChoice = choice;
}
else if (!strcmp(choice,"Cluster")) {
PARO2.iappl = 4;
fChoice = choice;
}
else {
Error("Venus","Not a valid choice : %s, reset to Hadron",choice);
PARO2.iappl = 1;
fChoice = "Hadron";
}
if (aprojectile < 0) {
Error("Venus","Negative A of projectile = %i, reset to 1 !",aprojectile);
aprojectile = 1;
}
PARO2.maproj = aprojectile;
fAProjectile = aprojectile;
if (atarget < 0) {
Error("Venus","Negative A of target = %i, reset to 1 !",atarget);
atarget = 1;
}
PARO2.matarg = atarget;
fATarget = atarget;
if (zprojectile < 0) {
Error("Venus","Negative Z of projectile = %i, reset to 1 !",zprojectile);
zprojectile = 1;
}
PARO2.laproj = zprojectile;
fZProjectile = zprojectile;
if (ztarget < 0) {
Error("Venus","Negative Z of target = %i, reset to 1 !",atarget);
ztarget = 1;
}
PARO2.latarg = ztarget;
fZTarget = ztarget;
PARO1.labsys = labSys;
fLabSys = labSys;
PARO2.istmax = !lastGeneration;
fLastGeneration = lastGeneration;
if (incidentMomentum < 0.0) {
Error("Venus","Negative incident hadron momentum = %d, reset to 200 !",
incidentMomentum);
incidentMomentum = 200.;
}
PARO2.pnll = Float_t(incidentMomentum);
fIncidentMomentum = incidentMomentum;
if (impactParameterMin < 0.0 || impactParameterMin > 100. ||
impactParameterMin > impactParameterMax ) {
Error("Venus","Negative impact parameter = %d, reset to 0 !",
impactParameterMin);
impactParameterMin = 0.0;
}
PAROI.bminim = Float_t(impactParameterMin);
fImpactParameterMin = impactParameterMin;
if (impactParameterMax < 0.0 || impactParameterMax > 10000. ||
impactParameterMin > impactParameterMax ) {
Error("Venus","Invalid impact parameter = %d, reset to 0 !",
impactParameterMax);
impactParameterMax = 0.0;
}
PAROI.bmaxim = Float_t(impactParameterMax);
fImpactParameterMax = impactParameterMax;
if (phiMin < 0.0 || phiMin > 2*TMath::Pi() || phiMin > phiMax) {
Error("Venus","Invalid impact angles %d %d, reset to 0 and 0 !",
phiMin,phiMax);
phiMin = 0.0;
phiMax = 0.0;
}
fPhiMin = phiMin;
PAROI.phimin = phiMin;
if (phiMax < 0.0 || phiMax > 2*TMath::Pi() || phiMin > phiMax) {
Error("Venus","Invalid impact angles %d %d, reset to 0 and 0 !",
phiMin,phiMax);
phiMin = 0.0;
phiMax = 0.0;
}
fPhiMax = phiMax;
PAROI.phimax = phiMax;
//
// Set some default values for the rest of the data members
//
SetVersionNumber(521);
SetU_D_QuarkProductionProb(PARO1.pud);
SetQQ_QQbarProbability(PARO1.pdiqua);
SetLightFlavoursSpinProb(PARO1.pspinl);
SetHeavyFlavoursSpinProb(PARO1.pspinh);
SetIsoSpinProb(PARO1.pispn);
Setp_T_Distribution(PARO1.ioptf);
SetAveragep_T(PARO1.ptf);
SetStringTension(PARO1.tensn);
SetStringDecayParameter(PARO1.parea);
SetThresholdResonanceToString(PARO1.delrem);
SetCutOffForKmaxor(PARO2.kutdiq);
SetBreakingProcedureOption(PARO1.iopbrk);
SetQuarkp_TDistributionOption(PARO1.ioptq);
SetMeanTransverseQuarkMomentum(PARO8.ptq1,PARO8.ptq2,PARO8.ptq3);
SetSemihardInteractionProb(PARO1.phard);
SetSemihardCutOff(PARO1.pth);
SetSeaRatio(PARO1.rstras);
SetProjectileDiffractiveProb(PARO1.wproj);
SetTargetDiffractiveProb(PARO1.wtarg);
SetStructureFunctionSeaValence(PARO1.cutmsq);
SetStructureFunctionCutOffMass(PARO1.cutmss);
SetDiffractiveValenceQuarkFrac(PARO1.pvalen);
SetPhaseSpace(PARO1.delmss);
SetGribovReggeGamma(PARO4.grigam);
SetGribovReggeRSquared(PARO4.grirsq);
SetGribovReggeDelta(PARO4.gridel);
SetGribovReggeSlope(PARO4.grislo);
SetGribovReggeCrossSecWeight(PARO4.gricel);
SetHardCoreDistance(PARO1.core);
SetJ_PsiNucleonCrossSec(PARO1.sigj);
SetReactionTime(PARO2.taurea);
SetBaryonRadius(PARO9.radbar);
SetMesonRadius(PARO9.radmes);
SetInteractionMass(PARO1.amsiac);
SetJIntaOption(PARO1.iojint);
SetPrintOptionAmprif(PARO1.amprif);
SetPrintOptionDelvol(PAROH.delvol);
SetPrintOptionDeleps(PAROH.deleps);
SetEntropyOption(PARO1.iopent,PARO3.uentro,PARO1.kentro);
SetDecayTime(PARO1.taunll);
SetOscillatorQuantum(PARO3.omega);
SetSpaceTimeEvolutionMinTau(PARO1.taumin);
SetTauSteps(PARO1.numtau);
Setp_TDistributionRange(PARO1.ptmx);
SetGaussDistributionRange(PARO1.gaumx);
SetDensityDistributionRange(PARO1.fctrmx);
SetTryAgain(PARO1.ntrymx);
SetJ_PsiEvolutionTime(PARO1.taumx);
SetJ_PsiEvolutionTimeSteps(PARO1.nsttau);
SetMinimumEnergyOption(PARO1.iopenu);
SetBergerJaffeTheta(PARO1.themas);
SetSeaProbability(PARO2.prosea);
SetInelasticProtonProtonCrossSec(PARO1.sigppi);
SetEntropyCalculated(PARO2.ientro);
SetDualPartonModel(PARO2.idpm);
SetAntiQuarkColourExchange(PARO1.iaqu);
SetMinNumberOfValenceQuarks(PARO1.neqmn);
SetMaxNumberOfValenceQuarks(PARO1.neqmx);
SetRapidityUpperLimit(PAROF.ymximi);
SetClean(PARO1.nclean);
SetCMToLabTransformation(PARO1.labsys);
SetMaxNumberOfCollisions(PARO1.ncolmx);
SetMaxResonanceSpin(PARO1.maxres);
SetMomentumRescaling(PARO1.irescl);
SetNueEnergy(PARO2.elepti);
SetMuonEnergy(PARO2.elepto);
SetMuonAngle(PARO2.angmue);
SetCollisionTrigger(PARO1.ko1ko2);
SetPrintOption(PARO2.ish);
SetPrintSubOption(PARO2.ishsub);
SetEventPrint(PARO2.ishevt);
SetPrintMarks(PARO2.ipagi);
SetMaxImpact(PAROI.bmaxim);
SetMinImpact(PAROI.bminim);
SetStoreOnlyStable(PARO2.istmax);
SetInitialRandomSeed(CSEED.seedi);
SetJFRADESuppression(PARO1.ifrade);
SetResonanceStable(P13.ndecay);
SetSpaceTimeEvolution(PAROG.ispall);
SetMinTimeInEvolution(PAROG.wtmini);
SetTimeStepInEvolution(PAROG.wtstep);
SetCentralPointInEvolution(PAROG.iwcent);
SetsMass(PARO8.smas);
SetuuMass(PARO8.uumas);
SetusMass(PARO8.usmas);
SetssMass(PARO8.ssmas);
SetStorage(PAROB.istore);
//
// Finish initialization
//
fCascadeStable = kFALSE;
fKStable = kFALSE;
fLambdaStable = kFALSE;
fOmegaStable = kFALSE;
fPiZeroStable = kFALSE;
fSigmaStable = kFALSE;
atitle();
afiles();
fUpdate = kTRUE;
SetTitle("Venus event");
}
//______________________________________________________________________________
TVenus::~TVenus()
{
//
// Event generator VENUS default destructor
//
}
//______________________________________________________________________________
void TVenus::GenerateEvent(Option_t *option)
{
//
// Generate next event
//
if (fUpdate) {
ainit();
fUpdate = kFALSE;
}
if (fChoice.Contains("Analysis") || fChoice.Contains("Hadron") ||
fChoice.Contains("Lepton")) {
avenus();
}
else if (fChoice.Contains("Cluster")) {
qnbaaa();
}
else {
Error("GenerateEvent","Not a valid choice : %s, cannot generate event",
fChoice.Data());
}
aseed();
ImportParticles(option);
}
//______________________________________________________________________________
TObjArray* TVenus::ImportParticles(Option_t *option)
{
//
// Overloaded primary creation method. The event generator does
// not use the HEPEVT common block, and has not the PDG numbering scheme.
//
fParticles->Delete();
Int_t identifier;
Int_t nptevt = 0;
Int_t ipart = 0;
for (Int_t j = 0; j < CPTL.nptl; j++) {
if (CPTL.istptl[j] <= PARO2.istmax) nptevt++;
}
Printf("Number of final particles : %d",nptevt);
if (!strcmp(option,"") || !strcmp(option,"Final")) {
for (Int_t i = 0; i<VCOMMON_MXPTL; i++) {
if (CPTL.idptl[i] == 0) break;
if (CPTL.istptl[i] <= PARO2.istmax) {
//
// Use the common block values for the TPrimary constructor
//
identifier = TAttParticle::ConvertISAtoPDG(CPTL.idptl[i]);
if (identifier) {
TPrimary *p = new TPrimary(
identifier,
-1,
-1,
CPTL.istptl[i],
CPTL.pptl[i][0],
CPTL.pptl[i][1],
CPTL.pptl[i][2],
CPTL.pptl[i][3],
CPTL.xorptl[i][0],
CPTL.xorptl[i][1],
CPTL.xorptl[i][2],
CPTL.xorptl[i][3],
CPTL.tivptl[i][1]);
fParticles->Add(p);
ipart++;
}
}
}
}
else if (!strcmp(option,"All")) {
for (Int_t i = 0; i<VCOMMON_MXPTL; i++) {
if (CPTL.idptl[i] != 0) {
identifier = TAttParticle::ConvertISAtoPDG(CPTL.idptl[i]);
if (identifier) {
TPrimary *p = new TPrimary(
identifier,
CPTL.iorptl[i],
CPTL.jorptl[i],
CPTL.istptl[i],
CPTL.pptl[i][0],
CPTL.pptl[i][1],
CPTL.pptl[i][2],
CPTL.pptl[i][3],
CPTL.xorptl[i][0],
CPTL.xorptl[i][1],
CPTL.xorptl[i][2],
CPTL.xorptl[i][3],
CPTL.tivptl[i][1]);
fParticles->Add(p);
ipart++;
}
}
}
}
return fParticles;
}
//______________________________________________________________________________
Int_t TVenus::ImportParticles(TClonesArray *particles, Option_t *option)
{
//
// Default primary creation method. It reads the /HEPEVT/ common block which
// has been filled by the GenerateEvent method. If the event generator does
// not use the HEPEVT common block, This routine has to be overloaded by
// the subclasses.
// The function loops on the generated particles and store them in
// the TClonesArray pointed by the argument particles.
// The default action is to store only the stable particles (ISTHEP = 1)
// This can be demanded explicitly by setting the option = "Final"
// If the option = "All", all the particles are stored.
//
return TGenerator::ImportParticles(particles,option);
}
//______________________________________________________________________________
void TVenus::SetVersionNumber(Int_t iversn)
{
//
// Set VENUS version number, the default is version 5.21
//
if (iversn < 521) {
Error("Venus","Version number too low = %d, reset to 521",
iversn);
iversn = 521;
}
fVersion = iversn;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetU_D_QuarkProductionProb(Float_t pud)
{
//
// Set VENUS ud quark production probability
//
if (pud < 0.0) {
Error("Venus",
"VENUS ud quark production probability = %f, reset to 0.455",
pud);
pud = 0.455;
}
PARO1.pud = pud;
fPud = pud;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetQQ_QQbarProbability(Float_t pdiqua)
{
//
// Set VENUS qq - qqbar probability
//
if (pdiqua < 0.0) {
Error("Venus",
"VENUS ud quark production probability = %f, reset to 0.455",
pdiqua);
pdiqua = 0.08;
}
PARO1.pdiqua = pdiqua;
fPDiQuark = pdiqua;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetLightFlavoursSpinProb(Float_t pspinl)
{
//
// Set VENUS light flavour spin probability
//
if (pspinl < 0.0) {
Error("Venus",
"VENUS light flavour spin probability = %f, reset to 0.5",
pspinl);
pspinl = 0.5;
}
PARO1.pspinl = pspinl;
fPSpinLight = pspinl;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetHeavyFlavoursSpinProb(Float_t pspinh)
{
//
// Set VENUS heavy flavour spin probability
//
if (pspinh < 0.0) {
Error("Venus",
"VENUS heavy flavour spin probability = %f, reset to 0.5",
pspinh);
pspinh = 0.5;
}
PARO1.pspinh = pspinh;
fPSpinHeavy = pspinh;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetIsoSpinProb(Float_t pispn)
{
//
// Set VENUS isospin probability
//
if (pispn < 0.0) {
Error("Venus",
"VENUS isospin probability = %f, reset to 0.5",
pispn);
pispn = 0.5;
}
PARO1.pispn = pispn;
fPIsospin = pispn;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::Setp_T_Distribution(Int_t ioptf)
{
//
// Set VENUS transverse momentum distribution
// ioptf = 1 -> exponential
// ioptf = 2 -> gaussian
//
if (ioptf < 1 || ioptf > 2) {
Error("Venus",
"VENUS invalid pt distribution parameter = %d, reset to 1 ",
ioptf);
ioptf = 1;
}
PARO1.ioptf = ioptf;
fPTDistribution = ioptf;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetAveragep_T(Float_t ptf)
{
//
// Set VENUS average transverse momentum
//
if (ptf < 0.0) {
Error("Venus",
"VENUS invalid average transverse momentum = %f, reset to 0.45 ",
ptf);
ptf = 0.5;
}
PARO1.ptf = ptf;
fAveragePt = ptf;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetStringTension(Float_t tensn)
{
//
// Set VENUS string tension
//
if (tensn < 0.0) {
Error("Venus",
"VENUS invalid string tension = %f, reset to 1.0 ",
tensn);
tensn = 0.5;
}
PARO1.tensn = tensn;
fStringTension = tensn;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetStringDecayParameter(Float_t parea)
{
//
// Set VENUS string decay parameter
//
if (parea < 0.0) {
Error("Venus",
"VENUS invalid string decay parameter = %f, reset to 0.20 ",
parea);
parea = 0.20;
}
PARO1.parea = parea;
fStringDecay = parea;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetThresholdResonanceToString(Float_t delrem)
{
//
// Set VENUS threshold for resonance to string
//
if (delrem < 0.0) {
Error("Venus",
"VENUS invalid threshold for resonance to string = %f, reset to 1.0 ",
delrem);
delrem = 1.0;
}
PARO1.delrem = delrem;
fResThreshold = delrem;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetCutOffForKmaxor(Int_t kutdiq)
{
//
// Set VENUS cut off for Kmaror
//
if (kutdiq < 0) {
Error("Venus",
"VENUS invalid cutoff value for Kmaxor = %d, reset to 4 ",
kutdiq);
kutdiq = 4;
}
PARO2.kutdiq = kutdiq;
fCutKmaxor = kutdiq;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetBreakingProcedureOption(Int_t iopbrk)
{
//
// Set VENUS breaking procedure option
// iopbrk = 1 -> amor
// iopbrk = 2 -> samba
//
if (iopbrk < 1 || iopbrk > 2) {
Error("Venus",
"VENUS invalid breaking procedure option = %d, reset to 1 ",
iopbrk);
iopbrk = 1;
}
PARO1.iopbrk = iopbrk;
fBreaking = iopbrk;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetQuarkp_TDistributionOption(Int_t ioptq)
{
//
// Set VENUS quark p_T distribution option
// ioptq = 1 -> exponential
// ioptq = 2 -> gaussian
// ioptq = 3 -> power
//
if (ioptq < 1 || ioptq > 3) {
Error("Venus",
"VENUS invalid Quark transverse momentum option = %d, reset to 2 ",
ioptq);
ioptq = 2;
}
PARO1.ioptq = ioptq;
fQuarkPt = ioptq;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMeanTransverseQuarkMomentum(Float_t ptq1,
Float_t ptq2,
Float_t ptq3)
{
//
// Set VENUS mean quark transverse momentum
// with the energy dependence of mean transverse momentum of quarks:
// ptq1+ptq2*alog(e)+ptq3*alog(e)**2
// with e=sqrt(s)
//
if (ptq1 < 0.0) {
Error("Venus",
"VENUS invalid mean transverse quark momentum component 1 = %f, reset to 0.26 ",
ptq1);
ptq1 = .26;
}
PARO8.ptq1 = ptq1;
fMeanQMomentum1 = ptq1;
if (ptq2 < 0.0) {
Error("Venus",
"VENUS invalid mean transverse quark momentum component 2 = %f, reset to 0.0 ",
ptq2);
ptq2 = 0.0;
}
PARO8.ptq2 = ptq2;
fMeanQMomentum2 = ptq2;
if (ptq3 < 0.0) {
Error("Venus",
"VENUS invalid mean transverse quark momentum component 3 = %f, reset to 0.0 ",
ptq3);
ptq1 = 0.0;
}
PARO8.ptq3 = ptq3;
fMeanQMomentum3 = ptq3;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetSemihardInteractionProb(Float_t phard)
{
//
// Set VENUS semihard interaction probability (not used if negative)
//
PARO1.phard = phard;
fSemihard = phard;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetSemihardCutOff(Float_t pth)
{
//
// Set VENUS cutoff parameter for p_t distr for semihard interactions
//
if (pth < 0.0) {
Error("Venus",
"Invalid parameter for semihard interactions = %f, reset to 1.0",
pth);
pth = 0.;
}
PARO1.pth = pth;
fCutSemi = pth;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetSeaRatio(Float_t rstras)
{
//
// Set VENUS ratio of strang sea quark contents over up sea contents
//
if (rstras < 0.0) {
Error("Venus",
"Invalid sea ratio = %f, reset to 0.0",
rstras);
rstras = 0.;
}
PARO1.rstras = rstras;
fSeaRatio = rstras;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetProjectileDiffractiveProb(Float_t wproj)
{
//
// Set VENUS projectile diffractive probability
//
if (wproj < 0.0) {
Error("Venus",
"Invalid projectile diffractive probability = %f, reset to 0.32",
wproj);
wproj = 0.32;
}
PARO1.wproj = wproj;
fProjDiffProb = wproj;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetTargetDiffractiveProb(Float_t wtarg)
{
//
// Set VENUS target diffractive probability
//
if (wtarg < 0.0) {
Error("Venus","Invalid target diffractive probability = %f, reset to 0.32",
wtarg);
wtarg = 0.32;
}
PARO1.wtarg = wtarg;
fTargDiffProb = wtarg;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetStructureFunctionSeaValence(Float_t cutmsq)
{
//
// Set VENUS effective cutoff mass in structure fcts for sea-valence ratio
//
if (cutmsq < 0.0) {
Error("Venus",
"Invalid cutoff mass in structure fcts = %f, reset to 2.0",
cutmsq);
cutmsq = 2.0;
}
PARO1.cutmsq = cutmsq;
fSeaValenceCut = cutmsq;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetStructureFunctionCutOffMass(Float_t cutmss)
{
//
// Set VENUS effective cutoff mass in structure fcts for sea-valence ratio
//
if (cutmss < 0.0) {
Error("Venus",
"Invalid cutoff mass for sea-valence ratio= %f, reset to 0.001",
cutmss);
cutmss = 2.0;
}
PARO1.cutmss = cutmss;
fCutMass = cutmss;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetDiffractiveValenceQuarkFrac(Float_t pvalen)
{
//
// Set VENUS valence quark fraction in case of diffractive interaction
//
if (pvalen < 0.0) {
Error("Venus","Invalid valence quark fraction = %f, reset to 0.30",
pvalen);
pvalen = .30;
}
PARO1.pvalen = pvalen;
fValenceFrac = pvalen;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPhaseSpace(Float_t delmss)
{
//
// Set VENUS phase space parameter
//
if (delmss < 0.0) {
Error("Venus",
"Invalid phase space parameter = %f, reset to 0.30",
delmss);
delmss = .30;
}
PARO1.delmss = delmss;
fPhaseSpace = delmss;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetGribovReggeGamma(Float_t grigam)
{
//
// Set VENUS gribov-regge-theory gamma
//
if (grigam < 0.0) {
Error("Venus",
"Invalid gribov-regge-theory gamma = %f, reset to 3.64*0.04",
grigam);
grigam = 3.64*0.04;
}
PARO4.grigam = grigam;
fGribovGamma = grigam;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetGribovReggeRSquared(Float_t grirsq)
{
//
// Set VENUS gribov-regge-theory r^2
//
if (grirsq < 0.0) {
Error("Venus",
"Invalid gribov-regge-theory r squared = %f, reset to 3.56*0.04",
grirsq);
grirsq = 3.56*0.04;
}
PARO4.grirsq = grirsq;
fGribovR2 = grirsq;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetGribovReggeDelta(Float_t gridel)
{
//
// Set VENUS gribov-regge-theory delta
//
if (gridel < 0.0) {
Error("Venus",
"Invalid gribov-regge-theory delta = %f, reset to 3.56*0.04",
gridel);
gridel = 0.07;
}
PARO4.gridel = gridel;
fGribovDelta = gridel;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetGribovReggeSlope(Float_t grislo)
{
//
// Set VENUS gribov-regge-theory slope
//
if (grislo < 0.0) {
Error("Venus",
"Invalid gribov-regge-theory slope = %f, reset to 0.25*0.04",
grislo);
grislo = 0.25*0.04;
}
PARO4.grislo = grislo;
fGribovSlope = grislo;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetGribovReggeCrossSecWeight(Float_t gricel)
{
//
// Set VENUS gribov-regge-theory cross section weight
//
if (gricel < 0.0) {
Error("Venus",
"Invalid gribov-regge-theory cross section weight = %f, reset to 1.5",
gricel);
gricel = 1.5;
}
PARO4.gricel = gricel;
fGribovCross = gricel;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetHardCoreDistance(Float_t core)
{
//
// Set VENUS hard core distance
//
if (core < 0.0) {
Error("Venus",
"Invalid hard core distance = %f, reset to 0.8",
core);
core = 0.8;
}
PARO1.core = core;
fCore = core;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetJ_PsiNucleonCrossSec(Float_t sigj)
{
//
// Set VENUS J/Psi nucleon cross section
//
if (sigj < 0.0) {
Error("Venus",
"Invalid J/Psi nucleon cross section = %f, reset to 0.2",
sigj);
sigj = 0.2;
}
PARO1.sigj = sigj;
fSigmaJ_Psi = sigj;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetReactionTime(Float_t taurea)
{
//
// Set VENUS reaction time
//
if (taurea < 0.0) {
Error("Venus",
"Invalid reaction time = %f, reset to 1.5",
taurea);
taurea = 1.5;
}
PARO2.taurea = taurea;
fReacTime = taurea;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetBaryonRadius(Float_t radbar)
{
//
// Set VENUS baryon radius
//
if (radbar < 0.0) {
Error("Venus",
"Invalid baryon radius = %f, reset to 0.63",
radbar);
radbar = 0.63;
}
PARO9.radbar = radbar;
fBaryonRadius = radbar;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMesonRadius(Float_t radmes)
{
//
// Set VENUS meson radius
//
if (radmes < 0.0) {
Error("Venus",
"Invalid meson radius = %f, reset to 0.40",
radmes);
radmes = 0.40;
}
PARO9.radmes = radmes;
fMesonRadius = radmes;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetInteractionMass(Float_t amsiac)
{
//
// Set VENUS interaction mass
//
if (amsiac < 0.0) {
Error("Venus",
"Invalid interaction mass = %f, reset to 0.8",
amsiac);
amsiac = 0.8;
}
PARO1.amsiac = amsiac;
fInteractionMass = amsiac;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetJIntaOption(Int_t iojint)
{
//
// Set VENUS option to call jinta1 (1) or jinta2 (2)
//
if (iojint < 1 || iojint > 2) {
Error("Venus",
"Invalid option to call jintaN = %d, reset to 2",
iojint);
iojint = 2;
}
PARO1.iojint = iojint;
fJintalOpt = iojint;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPrintOptionAmprif(Float_t amprif)
{
//
// Set VENUS print option
//
if (amprif < 0.0) {
Error("Venus",
"Invalid print option = %g, reset to 0",
amprif);
amprif = 0.0;
}
PARO1.amprif = amprif;
fPrintOption1 = (Int_t)amprif;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPrintOptionDelvol(Float_t delvol)
{
//
// Set VENUS print option
//
if (delvol < 0.0) {
Error("Venus",
"Invalid print option = %g, reset to 1",
delvol);
delvol = 1.0;
}
PAROH.delvol = delvol;
fPrintOption2 = (Int_t)delvol;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPrintOptionDeleps(Float_t deleps)
{
//
// Set VENUS print option
//
if (deleps < 0.0) {
Error("Venus",
"Invalid print option = %g, reset to 1",
deleps);
deleps = 1.0;
}
PAROH.deleps = deleps;
fPrintOption3 = (Int_t)deleps;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetEntropyOption(Int_t iopent,
Float_t uentro,
Int_t kentro)
{
//
// Set VENUS options for entropy calculation
// option for entropy calculation
// iopent = 0 -> zero entropy
// iopent = 1 -> oscillator model (0 for k.le.uentro)
// iopent = 2 -> fermi gas w const volume (0 for k.le.uentro)
// iopent = 3 -> fermi gas w const density (0 for k.le.uentro)
// iopent = 4 -> fermi gas w const vol - new (0 for k.le.uentro)
// iopent = 5 -> resonance gas (hagedorn) (0 for u.le.uentro)
//
if (iopent < 0) {
Error("Venus",
"Invalid option for entropy calculation = %d, reset to 5",
iopent);
iopent = 5;
}
PARO1.iopent = iopent;
fEntropy1 = iopent;
if (uentro < 0.0) {
Error("Venus",
"Invalid option for entropy calculation = %d, reset to 4.0",
uentro);
uentro = 5;
}
PARO3.uentro = uentro;
fEntropy2 = uentro;
if (kentro < 0) {
Error("Venus",
"Invalid option for entropy calculation = %d, reset to 10000",
kentro);
kentro = 10000;
}
PARO1.kentro = kentro;
fEntropy3 = kentro;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetDecayTime(Float_t taunll)
{
//
// Set VENUS decay time of comoving frame
//
if (taunll < 0) {
Error("Venus",
"Invalid decay time = %f, reset to 1.0",
taunll);
taunll = 1.0;
}
PARO1.taunll = taunll;
fDecayTime = taunll;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetOscillatorQuantum(Float_t omega)
{
//
// Set VENUS oscillator quantum
//
if (omega < 0.) {
Error("Venus",
"Invalid oscillator quantum = %f, reset to 0.5",
omega);
omega = 0.5;
}
PARO3.omega = omega;
fOsciQuantum = omega;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetSpaceTimeEvolutionMinTau(Float_t taumin)
{
//
// Set VENUS minimum tau for space-time evolution
//
if (taumin < 0.) {
Error("Venus",
"Invalid minimum tau for space-time evolution = %f, reset to 1.0",
taumin);
taumin = 0.5;
}
PARO1.taumin = taumin;
fTauMin = taumin;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetTauSteps(Int_t numtau)
{
//
// Set VENUS number of tau steps
//
if (numtau < 0) {
Error("Venus",
"Invalid number of tau steps = %d, reset to 86",
numtau);
numtau = 86;
}
PARO1.numtau = numtau;
fTauSteps = numtau;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::Setp_TDistributionRange(Float_t ptmx)
{
//
// Set VENUS transverse momentum distribution range
//
if (ptmx < 0.) {
Error("Venus",
"Invalid transverse momentum distribution range = %f, reset to 6.0",
ptmx);
ptmx = 6.0;
}
PARO1.ptmx = ptmx;
fPtRange = ptmx;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetGaussDistributionRange(Float_t gaumx)
{
//
// Set VENUS gaussian distribution range
//
if (gaumx < 0.) {
Error("Venus",
"Invalid gaussian distribution range = %f, reset to 8.0",
gaumx);
gaumx = 8.0;
}
PARO1.gaumx = gaumx;
fGaussianRange = gaumx;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetDensityDistributionRange(Float_t fctrmx)
{
//
// Set VENUS density distribution range
//
if (fctrmx < 0.) {
Error("Venus",
"Invalid density distribution range = %f, reset to 10.0",
fctrmx);
fctrmx = 10.0;
}
PARO1.fctrmx = fctrmx;
fDensityRange = fctrmx;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetTryAgain(Int_t ntrymx)
{
//
// Set VENUS number of retries
//
if (ntrymx < 0) {
Error("Venus",
"Invalid density distribution range = %d, reset to 10",
ntrymx);
ntrymx = 10;
}
PARO1.ntrymx = ntrymx;
fRetries = ntrymx;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetJ_PsiEvolutionTime(Float_t taumx)
{
//
// Set VENUS J/Psi evolution time
//
if (taumx < 0) {
Error("Venus",
"Invalid J/Psi evolution time = %f, reset to 20.0",
taumx);
taumx = 20.0;
}
PARO1.taumx = taumx;
fJ_PsiEvolution = taumx;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetJ_PsiEvolutionTimeSteps(Int_t nsttau)
{
//
// Set VENUS J/Psi evolution time steps
//
if (nsttau < 0) {
Error("Venus",
"Invalid number of J/Psi evolution time steps = %d, reset to 100",
nsttau);
nsttau = 100;
}
PARO1.nsttau = nsttau;
fJ_PsiSteps = nsttau;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMinimumEnergyOption(Int_t iopenu)
{
//
// Set VENUS minimum energy option
// iopent = 1 -> sum of hadron masses
// iopent = 2 -> bag model curve with minimum at nonzero strangen
//
if (iopenu < 1 || iopenu > 2) {
Error("Venus",
"Invalid minimum energy option = %d, reset to 1",
iopenu);
iopenu = 1;
}
PARO1.iopenu = iopenu;
fMinEnergy = iopenu;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetBergerJaffeTheta(Float_t themas)
{
//
// Set VENUS parameter theta in berger/jaffe mass formula
//
if (themas < 0.0) {
Error("Venus",
"Invalid minimum energy option = %f, reset to 0.51225",
themas);
themas = 0.51225;
}
PARO1.themas = themas;
fMassTheta = themas;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetSeaProbability(Float_t prosea)
{
//
// Set VENUS sea prob (if < 0 then calculated from structure fncts)
//
PARO2.prosea = prosea;
fSeaProbability = prosea;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetInelasticProtonProtonCrossSec(Float_t sigppi)
{
//
// Set VENUS inelastic pp cross section [fm**2]
// if negative: calculated from gribov-regge-theory
//
PARO1.sigppi = sigppi;
fPPInelastic = sigppi;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetEntropyCalculated(Int_t ientro)
{
//
// Set VENUS entro() calculated (1) or from data (2)
//
if (ientro < 1 || ientro > 2) {
Error("Venus",
"Invalid entropy calculation option = %d, reset to 2",
ientro);
ientro = 2;
}
PARO2.ientro = ientro;
fEntropyCalc = ientro;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetDualPartonModel(Int_t idpm)
{
//
// Set VENUS dual parton model (1) or not (else)
//
if (idpm < 0) {
Error("Venus",
"Invalid dual parton model selection option = %d, reset to 0",
idpm);
idpm = 0;
}
PARO2.idpm = idpm;
fDualParton = idpm;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetAntiQuarkColourExchange(Int_t iaqu)
{
//
// Set VENUS antiquark color exchange (1) or not (0)
//
if (iaqu < 0 || iaqu > 1) {
Error("Venus",
"Invalid antiquark color exchange option = %d, reset to 1",
iaqu);
iaqu = 1;
}
PARO1.iaqu = iaqu;
fColourExchange = iaqu;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMinNumberOfValenceQuarks(Int_t neqmn)
{
//
// Set VENUS minimum number of valence quarks
//
if (neqmn > 0) {
Error("Venus",
"Invalid minimum number of valence quarks = %d, reset to -5",
neqmn);
neqmn = -5;
}
PARO1.neqmn = neqmn;
fMinValence = neqmn;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMaxNumberOfValenceQuarks(Int_t neqmx)
{
//
// Set VENUS maximum number of valence quarks
//
if (neqmx < 0) {
Error("Venus",
"Invalid maximum number of valence quarks = %d, reset to 5",
neqmx);
neqmx = 5;
}
PARO1.neqmx = neqmx;
fMaxValence = neqmx;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetRapidityUpperLimit(Float_t ymximi)
{
//
// Set VENUS upper limit for rapidity interval for intermittency analysis
//
if (ymximi < 0.0) {
Error("Venus",
"Invalid upper limit for rapidity interval = %f, reset to 2.0",
ymximi);
ymximi = 2.0;
}
PAROF.ymximi = ymximi;
fInterval = ymximi;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetClean(Int_t nclean)
{
//
// Set VENUS clean /cptl/ if nclean > 0 (every nclean_th time step)
//
if (nclean < 0) {
Error("Venus",
"Invalid clean step number = %d, reset to 0",
nclean);
nclean = 0;
}
PARO1.nclean = nclean;
fClean = nclean;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetCMToLabTransformation(Int_t labsys)
{
//
// Set VENUS trafo from pp-cm into lab-system (1) or not (else)
//
if (labsys < 0) {
Error("Venus",
"Invalid CMS to Laboratory system transformation = %d, reset to 1",
labsys);
labsys = 1;
}
PARO1.labsys = labsys;
fLabSys = labsys;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMaxNumberOfCollisions(Int_t ncolmx)
{
//
// Set VENUS maximum number of collisions
//
if (ncolmx < 0) {
Error("Venus",
"Invalid maximum number of collisions = %d, reset to 10000",
ncolmx);
ncolmx = 10000;
}
PARO1.ncolmx = ncolmx;
fMaxCollisions = ncolmx;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMaxResonanceSpin(Int_t maxres)
{
//
// Set VENUS maximum resonance spin
//
if (maxres < 0) {
Error("Venus",
"Invalid maximum resonance spin = %d, reset to 99999",
maxres);
maxres = 99999;
}
PARO1.maxres = maxres;
fMaxSpin = maxres;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMomentumRescaling(Int_t irescl)
{
//
// Set VENUS momentum rescaling (1) or not (else)
//
if (irescl < 0) {
Error("Venus",
"Invalid momentum rescaling parameter = %d, reset to 1",
irescl);
irescl = 1;
}
PARO1.irescl = irescl;
fRescale = irescl;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetNueEnergy(Float_t elepti)
{
//
// Set VENUS nue energy
//
if (elepti < 0.0) {
Error("Venus",
"Invalid nue energy = %f, reset to 43.00",
elepti);
elepti = 43.00;
}
PARO2.elepti = elepti;
fNueEnergy = elepti;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMuonEnergy(Float_t elepto)
{
//
// Set VENUS muon energy
//
if (elepto < 0.0) {
Error("Venus",
"Invalid muon energy = %f, reset to 26.24",
elepto);
elepto = 26.24;
}
PARO2.elepto = elepto;
fMuonEnergy = elepto;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMuonAngle(Float_t angmue)
{
//
// Set VENUS muon angle
//
if (angmue < 0.0) {
Error("Venus",
"Invalid muon angle = %f, reset to 3.9645/360.0*2*3.14159",
angmue);
angmue = 3.9645/360.0*2*3.14159;
}
PARO2.angmue = angmue;
fMuonAngle = angmue;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetCollisionTrigger(Int_t ko1ko2)
{
//
// Set VENUS collision trigger (only coll between ko1 and ko2 are used)
//
if (ko1ko2 < 0) {
Error("Venus",
"Invalid collision trigger = %d, reset to 9999",
ko1ko2);
ko1ko2 = 9999;
}
PARO1.ko1ko2 = ko1ko2;
fCollisionTrigger = ko1ko2;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPrintOption(Int_t ish)
{
//
// Set VENUS print option
// ish=0 option for printout
// 14 -> call uttima
// 16 -> prints sea prob.
// 18 -> sr jclude, no-phase-space droplets
// 19 -> sr ainitl, call smassp
// 21 -> creates histogram for sea distribution
// 22 -> sr jfrade, msg after call utclea
// 23 -> call jintfp
// 24 -> call jintcl
// 25 -> call jchprt
// 26 -> call qgcpen (plot of energy and flavor density)
// 27 -> call qnbcor
// 29 -> call qgcpfl (plot of dispersion)
// 90,91,92,93,94,95 -> more and more detailed messages.
//
if (ish != 0 && ish != 14 && ish != 16 && ish != 18 && ish != 19 &&
ish != 21 && ish != 22 && ish != 23 && ish != 24 && ish != 25 &&
ish != 26 && ish != 27 && ish != 29 && ish != 90 && ish != 91 &&
ish != 92 && ish != 93 && ish != 94 && ish != 95) {
Error("Venus",
"Invalid print option = %d, reset to 0",
ish);
ish = 0;
}
PARO2.ish = ish;
fPrintOption = ish;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPrintSubOption(Int_t ishsub)
{
//
// Set VENUS print sub option
// ishsub=0 option for printout
// ishsub=ijmn, ij specifies location where ish=mn.
// ij=01 -> sr jcludc
// ij=02 -> sr jetgen
// ij=03 -> sr jfrade, starting before fragmentation
// ij=04 -> sr jdecay
// ij=05 -> sr jdecax
// ij=06 -> sr nucoll
// ij=07 -> sr nucoge+-
// ij=08 -> sr aastor
// ij=09 -> sr jfrade, starting after fragmentation
// ij=10 -> sr jfrade, starting before decay
// ij=11 -> sr jfrade, starting after interactions
// ij=12 -> sr jcentr, entro() in data format
// ij=13 -> sr jcentp
// ij=14 -> sr jdecax if droplet decay
// ij=15 -> sr jsplit
// ij=16 -> sr jfrade
// ij=17 -> sr racpro
// ij=18 -> sr utclea
// ij=19 -> sr jinta1, jinta2, after call utclea
// ij=20 -> sr jdecas
// ij=21 -> sr jdecas (without jdecax)
// ij=22 -> sr utcley
// ij=50 -> sr qgcnbi
//
if ((ishsub < 0 || ishsub > 22) && ishsub != 50) {
Error("Venus",
"Invalid print sub option = %d, reset to 0",
ishsub);
ishsub = 0;
}
PARO2.ishsub = ishsub;
fPrintSubOption = ishsub;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetEventPrint(Int_t ishevt)
{
//
// Set VENUS ishevt != 0: for evt# != ishevt ish is set to 0
//
if (ishevt < 0) {
Error("Venus",
"Invalid request to print event = %d, reset to 0",
ishevt);
ishevt = 0;
}
PARO2.ishevt = ishevt;
fPrintEvent = ishevt;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPrintMarks(Int_t ipagi)
{
//
// Set VENUS print marks between whom ish is set to ish(init)
//
if (ipagi < 0) {
Error("Venus",
"Invalid request to print marks = %d, reset to 0",
ipagi);
ipagi = 0;
}
PARO2.ipagi = ipagi;
fPrintMarks = ipagi;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMaxImpact(Float_t bmaxim)
{
//
// Set VENUS maximum beam impact parameter
//
if (bmaxim < 0.0 || bmaxim > 10000.) {
Error("Venus","Invalid maximum impact parameter = %f, reset to 10000.",
bmaxim);
bmaxim = 10000.0;
}
PAROI.bmaxim = bmaxim;
fImpactParameterMax = bmaxim;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMinImpact(Float_t bminim)
{
//
// Set VENUS minimum beam impact parameter
//
if (bminim < 0.0 || bminim > 10000.) {
Error("Venus","Invalid minimum impact parameter = %f, reset to 0.0!",
bminim);
bminim = 0.0;
}
PAROI.bminim = bminim;
fImpactParameterMin = bminim;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetStoreOnlyStable(Int_t istmax)
{
//
// Set VENUS store only stable ptl (0) or also parents (1)
//
if (istmax < 0 || istmax > 1) {
Error("Venus",
"Invalid request for stable partcile storage = %d, reset to 0",
istmax);
istmax = 0;
}
PARO2.istmax = istmax;
fLastGeneration = !istmax;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetInitialRandomSeed(Double_t seedi)
{
//
// Set VENUS initial random number seed
//
CSEED.seedi = seedi;
fInitialSeed = seedi;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetJFRADESuppression(Int_t ifrade)
{
//
// Set VENUS suppression of calling jfrade (0). jfrade=fragm+decay+rescatt
//
if (ifrade < 0 || ifrade > 1) {
Error("Venus",
"Invalid suppression in calling jfrade = %d, reset to 0",
ifrade);
ifrade = 1;
}
PARO1.ifrade = ifrade;
fJfradeSup = ifrade;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetResonanceStable(Bool_t stable)
{
//
// Set VENUS all resonance decays suppressed
//
if (stable) {
P13.ndecay = 1;
}
else {
P13.ndecay = 0;
}
fAllStable = stable;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetKShortKLongStable(Bool_t stable)
{
//
// Set VENUS k_short/long (+-20) decays suppressed
//
if (stable && !fKStable) {
P13.ndecay += 10;
}
else if (!stable && fKStable) {
P13.ndecay -= 10;
}
fKStable = stable;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetLambdaStable(Bool_t stable)
{
//
// Set VENUS lambda (+-2130) decays suppressed
//
if (stable && !fLambdaStable) {
P13.ndecay += 100;
}
else if (!stable && fLambdaStable) {
P13.ndecay -= 100;
}
fLambdaStable = stable;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetSigmaStable(Bool_t stable)
{
//
// Set VENUS sigma (+-1130,+-2230) decays suppressed
//
if (stable && !fSigmaStable) {
P13.ndecay += 1000;
}
else if (!stable && fSigmaStable) {
P13.ndecay -= 1000;
}
fSigmaStable = stable;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetCascadeStable(Bool_t stable)
{
//
// Set VENUS cascade (+-2330,+-1330) decays suppressed
//
if (stable && !fCascadeStable) {
P13.ndecay += 10000;
}
else if (!stable && fCascadeStable) {
P13.ndecay -= 10000;
}
fCascadeStable = stable;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetOmegaStable(Bool_t stable)
{
//
// Set VENUS omega (+-3331) decays suppressed
//
if (stable && !fOmegaStable) {
P13.ndecay += 100000;
}
else if (!stable && fOmegaStable) {
P13.ndecay -= 100000;
}
fOmegaStable = stable;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetPiZeroStable(Bool_t stable)
{
//
// Set VENUS pi0 (110) decays suppressed
//
if (stable && !fPiZeroStable) {
P13.ndecay += 1000000;
}
else if (!stable && fPiZeroStable) {
P13.ndecay -= 1000000;
}
fPiZeroStable = stable;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetRhoPhiRatio(Float_t rhophi)
{
//
// Set VENUS rho/rho+phi ratio
//
if (rhophi < 0.0) {
Error("Venus",
"Invalid rho/rho+phi ratio = %f, reset to 0.5",
rhophi);
rhophi = 0.5;
}
PARO2.rhophi = rhophi;
fRhoPhi = rhophi;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetSpaceTimeEvolution(Int_t ispall)
{
//
// Set VENUS wspa: all ptls (1) or only interacting ptls (else)
//
if (ispall < 0) {
Error("Venus",
"Invalid space time evolution paramter = %d, reset to 1",
ispall);
ispall = 1;
}
PAROG.ispall = ispall;
fSpaceTime = ispall;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetMinTimeInEvolution(Float_t wtmini)
{
//
// Set VENUS tmin in wspa
//
PAROG.wtmini = wtmini;
fMinTime = wtmini;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetTimeStepInEvolution(Float_t wtstep)
{
//
// Set VENUS t-step in wspa
//
if (wtstep < 0) {
Error("Venus",
"Invalid space time steps = %f, reset to 1.0",
wtstep);
wtstep = 1.0;
}
PAROG.wtstep = wtstep;
fSpaceTimeStep = wtstep;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetCentralPointInEvolution(Int_t iwcent)
{
//
// Set VENUS only central point (1) or longitudinal distr (else) in wspa
//
if (iwcent < 0) {
Error("Venus",
"Invalid central point parameter = %d, reset to 0",
iwcent);
iwcent = 0;
}
PAROG.iwcent = iwcent;
fCentralPoint = iwcent;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetsMass(Float_t smas)
{
//
// Set VENUS s quark mass
//
if (smas < 0) {
Error("Venus",
"Invalid s quark mass = %f, reset to 0.0",
smas);
smas = 0.0;
}
PARO8.smas = smas;
fSQuarkMass = smas;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetuuMass(Float_t uumas)
{
//
// Set VENUS uu diquark mass
//
if (uumas < 0) {
Error("Venus",
"Invalid uu diquark quark mass = %f, reset to 0.0",
uumas);
uumas = 0.0;
}
PARO8.uumas = uumas;
fuuQuarkMass = uumas;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetusMass(Float_t usmas)
{
//
// Set VENUS us diquark mass
//
if (usmas < 0) {
Error("Venus",
"Invalid us diquark quark mass = %f, reset to 0.0",
usmas);
usmas = 0.0;
}
PARO8.usmas = usmas;
fusQuarkMass = usmas;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetssMass(Float_t ssmas)
{
//
// Set VENUS ss diquark mass
//
if (ssmas < 0) {
Error("Venus",
"Invalid ss diquark quark mass = %f, reset to 0.0",
ssmas);
ssmas = 0.0;
}
PARO8.ssmas = ssmas;
fssQuarkMass = ssmas;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::SetStorage(Int_t istore)
{
//
// Set VENUS internal storage parameter
//
if (istore < 0 || istore > 2) {
Error("Venus","Invalid internal storage parameter = %d, reset to 0 !",
istore);
istore = 0;
}
PAROB.istore = istore;
fIstore = istore;
fUpdate = kTRUE;
}
//______________________________________________________________________________
void TVenus::Show()
{
//
// Shows the actual values of some common block variables as in
// the original VENUS command 'show'
//
Printf("iversn %d",CVSN.iversn);
Printf("iappl %d",PARO2.iappl);
Printf("nevent %d",PARO2.nevent);
Printf("iprmpt %d",PAROB.iprmpt);
Printf("ish %d",PARO2.ish);
Printf("ishsub %d",PARO2.ishsub);
Printf("irandm %d",PARO2.irandm);
Printf("irewch %d",PARO2.irewch);
Printf("ishevt %d",PARO2.ishevt);
Printf("iecho %d",PAROB.iecho);
Printf("modsho %d",PARO2.modsho);
Printf("idensi %d",PARO7.idensi);
Printf("pud %f",PARO1.pud);
Printf("pdiqua %f",PARO1.pdiqua);
Printf("pspinl %f",PARO1.pspinl);
Printf("pspinh %f",PARO1.pspinh);
Printf("pispn %f",PARO1.pispn);
Printf("ioptf %d",PARO1.ioptf);
Printf("ptf %f",PARO1.ptf);
Printf("ptmx %f",PARO1.ptmx);
Printf("tensn %f",PARO1.tensn);
Printf("parea %f",PARO1.parea);
Printf("delrem %f",PARO1.delrem);
Printf("delrex %f",PARO1.delrex);
Printf("kutdiq %i",PARO2.kutdiq);
Printf("iopbrk %d",PARO1.iopbrk);
Printf("smas %f",PARO8.smas);
Printf("uumas %f",PARO8.uumas);
Printf("usmas %f",PARO8.usmas);
Printf("ssmas %f",PARO8.ssmas);
Printf("ndecay %d",P13.ndecay);
Printf("maxres %d",PARO1.maxres);
Printf("rhophi %f",PARO2.rhophi);
Printf("engy %f",PARO2.engy);
Printf("elepti %f",PARO2.elepti);
Printf("elepto %f",PARO2.elepto);
Printf("angmue %f",PARO2.angmue);
Printf("pnll %f",PARO2.pnll);
Printf("idproj %d",PARO2.idproj);
Printf("idtarg %d",PARO2.idtarg);
Printf("ioptq %d",PARO1.ioptq);
Printf("ptq1 %f",PARO8.ptq1);
Printf("ptq2 %f",PARO8.ptq2);
Printf("ptq3 %f",PARO8.ptq3);
Printf("phard %f",PARO1.phard);
Printf("pth %f",PARO1.pth);
Printf("rstras %f",PARO1.rstras);
Printf("wproj %f",PARO1.wproj);
Printf("wtarg %f",PARO1.wtarg);
Printf("cutmsq %f",PARO1.cutmsq);
Printf("cutmss %f",PARO1.cutmss);
Printf("pvalen %f",PARO1.pvalen);
Printf("delmss %f",PARO1.delmss);
Printf("neqmn %d",PARO1.neqmn);
Printf("neqmx %d",PARO1.neqmx);
Printf("iaqu %d",PARO1.iaqu);
Printf("prosea %f",PARO2.prosea);
Printf("idpm %d",PARO2.idpm);
Printf("iopadi %d",PAROA.iopadi);
Printf("q2soft %f",PAROA.q2soft);
Printf("grigam %f",PARO4.grigam);
Printf("grirsq %f",PARO4.grirsq);
Printf("gridel %f",PARO4.gridel);
Printf("grislo %f",PARO4.grislo);
Printf("gricel %f",PARO4.gricel);
Printf("sigppi %f",PARO1.sigppi);
Printf("laproj %d",PARO2.laproj);
Printf("maproj %d",PARO2.maproj);
Printf("latarg %d",PARO2.latarg );
Printf("matarg %d",PARO2.matarg);
Printf("core %f",PARO1.core);
Printf("ncolmx %d",PARO1.ncolmx);
Printf("fctrmx %f",PARO1.fctrmx);
Printf("ko1ko2 %d",PARO1.ko1ko2);
Printf("bmaxim %f",PAROI.bmaxim);
Printf("bminim %f",PAROI.bminim);
Printf("phimax %f",PAROI.phimax);
Printf("phimin %f",PAROI.phimin);
Printf("taurea %f",PARO2.taurea);
Printf("sigmes %f",PARO9.sigmes);
Printf("sigbar %f",PARO9.sigbar);
Printf("rinmes %f",PARO9.rinmes);
Printf("rinbar %f",PARO9.rinbar);
Printf("epscri %f",PARO9.epscri);
Printf("amsiac %f",PARO1.amsiac);
Printf("iojint %d",PARO1.iojint);
Printf("amprif %f",PARO1.amprif);
Printf("delvol %f",PAROH.delvol);
Printf("deleps %f",PAROH.deleps);
Printf("taumin %f",PARO1.taumin);
Printf("deltau %f",PARO1.deltau);
Printf("factau %f",PARO1.factau);
Printf("numtau %d",PARO1.numtau);
Printf("etafac %f",PAROH.etafac);
Printf("dlzeta %f",PAROH.dlzeta);
Printf("ioclud %d",PARO7.ioclud);
Printf("corlen %f",PARO5.corlen);
Printf("dezzer %f",PARO5.dezzer);
Printf("amuseg %f",PARO5.amuseg);
Printf("bag4rt %f",PARO5.bag4rt);
Printf("iopent %d",PARO1.iopent);
Printf("uentro %f",PARO3.uentro);
Printf("kentro %d",PARO1.kentro);
Printf("taunll %f",PARO1.taunll);
Printf("omega %f",PARO3.omega);
Printf("ientro %d",PARO2.ientro);
Printf("tecm %f",CONFIG.tecm);
Printf("volu %f",CONFIG.volu);
Printf("keu %d",CINFLA.keu);
Printf("ked %d",CINFLA.ked);
Printf("kes %d",CINFLA.kes);
Printf("kec %d",CINFLA.kec);
Printf("keb %d",CINFLA.keb);
Printf("ket %d",CINFLA.ket);
Printf("iterma %d",CITER.iterma);
Printf("iterpr %d",CITER.iterpr);
Printf("iterpl %d",CITER.iterpl);
Printf("iternc %d",CITER.iternc );
Printf("iospec %d",PARO6.iospec );
Printf("iocova %d",PARO6.iocova);
Printf("iopair %d",PARO6.iopair);
Printf("iozero %d",PARO6.iozero );
Printf("ioflac %d",PARO6.ioflac);
Printf("iomom %d",PARO6.iomom);
Printf("iograc %d",PARO7.iograc);
Printf("iocite %d",PARO7.iocite);
Printf("ioceau %d",PARO7.ioceau);
Printf("iociau %d",PARO7.iociau);
Printf("nadd %d",PARO7.nadd);
Printf("epsr %f",CEPSR.epsr);
Printf("keepr %d",CMETRO.keepr);
Printf("iopenu %d",PARO1.iopenu);
Printf("themas %f",PARO1.themas);
Printf("jpsi %d",PARO2.jpsi);
Printf("jpsifi %d",PARO2.jpsifi);
Printf("sigj %f",PARO1.sigj);
Printf("taumx %f",PARO1.taumx);
Printf("nsttau %d",PARO1.nsttau);
Printf("ijphis %d",PARO2.ijphis);
Printf("ymximi %f",PAROF.ymximi);
Printf("imihis %d",PAROF.imihis);
Printf("isphis %d",PAROG.isphis);
Printf("ispall %d",PAROG.ispall);
Printf("wtmini %f",PAROG.wtmini);
Printf("wtstep %f",PAROG.wtstep);
Printf("iwcent %d",PAROG.iwcent);
Printf("iclhis %d",PAROF.iclhis);
Printf("iwtime %d",PAROF.iwtime);
Printf("wtimet %f",PAROF.wtimet);
Printf("wtimei %f",PAROF.wtimei);
Printf("wtimea %f",PAROF.wtimea);
Printf("gaumx %f",PARO1.gaumx);
Printf("nclean %d",PARO1.nclean);
Printf("istore %d",PAROB.istore);
Printf("labsys %d",PARO1.labsys);
Printf("irescl %d",PARO1.irescl);
Printf("ifrade %d",PARO1.ifrade);
Printf("ntrymx %d",PARO1.ntrymx);
Printf("istmax %d",PARO2.istmax);
Printf("seedi %f",CSEED.seedi);
}
ROOT page - Class index - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.