예제 #1
0
 private void InitOverlapField()
 {
     OverlapField = new SimpleFireballField(
         FireballFieldType.Overlap,
         CoordinateSystem,
         (x, y) => NucleonNumberColumnDensityFieldA[x, y] * NucleonNumberColumnDensityFieldB[x, y]);
 }
예제 #2
0
 private void InitNumberCollisionsField()
 {
     NumberCollisionsField = new SimpleFireballField(
         FireballFieldType.NumberCollisions,
         CoordinateSystem,
         (x, y) => InelasticppCrossSection_fm2 * OverlapField[x, y]);
 }
예제 #3
0
        public double AverageByBottomiumDistribution(
            LCFFieldFunction function
            )
        {
            CoordinateSystem   system  = new CoordinateSystem(Param);
            GlauberCalculation glauber = new GlauberCalculation(Param);

            double[,] functionColumnDensityValues
                = new double[system.XAxis.Count, system.YAxis.Count];

            for (int i = 0; i < system.XAxis.Count; i++)
            {
                for (int j = 0; j < system.YAxis.Count; j++)
                {
                    Func <double, double> integrand
                        = rapidity => function(system.XAxis[i], system.YAxis[j], rapidity);

                    functionColumnDensityValues[i, j]
                        = AverageRapidityDependence(integrand)
                          * glauber.NumberCollisionsField[i, j];
                }
            }
            SimpleFireballField functionColumnDensity = new SimpleFireballField(
                FireballFieldType.NumberCollisions, system, functionColumnDensityValues);

            return(functionColumnDensity.IntegrateValues()
                   / glauber.NumberCollisionsField.IntegrateValues());
        }
예제 #4
0
        /********************************************************************************************
        * Constructors
        ********************************************************************************************/

        public FireballDecayWidthField(
            CoordinateSystem system,
            IList <double> transverseMomenta,
            FireballTemperatureField temperature,
            SimpleFireballField vx,
            SimpleFireballField vy,
            FireballElectromagneticField electricField,
            FireballElectromagneticField magneticField,
            Dictionary <BottomiumState, double> formationTimes,
            double initialTime,
            DecayWidthRetrievalFunction decayWidthFunction
            )
            : base(FireballFieldType.DecayWidth, system, transverseMomenta)
        {
            Temperature    = temperature;
            VelocityX      = vx;
            VelocityY      = vy;
            ElectricField  = electricField;
            MagneticField  = magneticField;
            FormationTimes = SetFormationTimes(formationTimes);
            InitialTime    = initialTime;
            GetDecayWidth  = decayWidthFunction;

            SetTransverseBottomiumVelocityAndLorentzFactor(out BetaT, out GammaT);
            SetInitialValues();
        }
예제 #5
0
        // temperature is normalized such that T(0, 0, ThermalTime_fm) = T0
        // for a central collision (ImpactParameter = 0) and TransverseMomentum = 0
        private void InitTemperatureNormalizationField()
        {
            double norm = InitialMaximumTemperature * Math.Pow(ThermalTime, 1 / 3.0);

            TemperatureNormalizationField = new SimpleFireballField(
                FireballFieldType.TemperatureNormalization,
                System,
                (x, y) => norm * TemperatureScalingField[x, y]);
        }
예제 #6
0
        public double IntegrateFireballField(
            FireballFieldType fieldType,
            BottomiumState state = BottomiumState.Y1S,
            int pTIndex          = 0
            )
        {
            SimpleFireballField field = GetFireballField(fieldType, state, pTIndex);

            return(field.IntegrateValues());
        }
예제 #7
0
 private void InitNumberParticipantsField()
 {
     NumberParticipantsField = new SimpleFireballField(
         FireballFieldType.NumberParticipants,
         CoordinateSystem,
         (x, y) =>
         NucleonNumberColumnDensityFieldA[x, y] * (1.0 - Math.Pow(
                                                       1.0 - InelasticppCrossSection_fm2 * NucleonNumberColumnDensityFieldB[x, y]
                                                       / Param.NucleonNumberB, Param.NucleonNumberB))
         + NucleonNumberColumnDensityFieldB[x, y] * (1.0 - Math.Pow(
                                                         1.0 - InelasticppCrossSection_fm2 * NucleonNumberColumnDensityFieldA[x, y]
                                                         / Param.NucleonNumberA, Param.NucleonNumberA)));
 }
예제 #8
0
        private void InitNucleonNumberColumnDensityFieldsAB()
        {
            NucleonNumberColumnDensityFieldA = new SimpleFireballField(
                FireballFieldType.ColumnDensityA,
                CoordinateSystem,
                (x, y) => NucleusA.GetNucleonNumberColumnDensity_per_fm3(
                    XAxis[x] - Param.NucleusPositionA, YAxis[y]));

            NucleonNumberColumnDensityFieldB = new SimpleFireballField(
                FireballFieldType.ColumnDensityB,
                CoordinateSystem,
                (x, y) => NucleusB.GetNucleonNumberColumnDensity_per_fm3(
                    XAxis[x] - Param.NucleusPositionB, YAxis[y]));
        }
예제 #9
0
        private void InitNucleonNumberDensityFieldsAB()
        {
            NucleonNumberDensityFieldA = new SimpleFireballField(
                FireballFieldType.NucleonDensityA,
                CoordinateSystem,
                (x, y) => NucleusA.GetNucleonNumberDensity_per_fm3(Math.Sqrt(Math.Pow(
                                                                                 XAxis[x] - Param.NucleusPositionA, 2) + Math.Pow(YAxis[y], 2))));

            NucleonNumberDensityFieldB = new SimpleFireballField(
                FireballFieldType.NucleonDensityB,
                CoordinateSystem,
                (x, y) => NucleusB.GetNucleonNumberDensity_per_fm3(Math.Sqrt(Math.Pow(
                                                                                 XAxis[x] - Param.NucleusPositionB, 2) + Math.Pow(YAxis[y], 2))));
        }
예제 #10
0
        /********************************************************************************************
        * Constructors
        ********************************************************************************************/

        public FireballTemperatureField(
            CoordinateSystem system,
            SimpleFireballField temperatureScalingField,
            double initialMaximumTemperature,
            double thermalTime,
            double initialTime
            )
            : base(FireballFieldType.Temperature, system)
        {
            TemperatureScalingField   = temperatureScalingField;
            InitialMaximumTemperature = initialMaximumTemperature;
            ThermalTime = thermalTime;
            InitialTime = initialTime;

            AssertValidMembers();

            InitTemperatureNormalizationField();
            Advance(InitialTime);
        }
예제 #11
0
        private void InitTemperatureScalingField()
        {
            double norm = 1.0 / GetTemperatureScalingFieldNormalization();

            TemperatureScalingField = new SimpleFireballField(
                FireballFieldType.TemperatureScaling,
                CoordinateSystem,
                (x, y) =>
            {
                switch (Param.TemperatureProfile)
                {
                case TemperatureProfile.Ncoll:
                    return(norm * NumberCollisionsField[x, y]);

                case TemperatureProfile.Npart:
                    return(norm * NumberParticipantsField[x, y]);

                case TemperatureProfile.Ncoll13:
                    return(norm * Math.Pow(NumberCollisionsField[x, y], 1 / 3.0));

                case TemperatureProfile.Npart13:
                    return(norm * Math.Pow(NumberParticipantsField[x, y], 1 / 3.0));

                case TemperatureProfile.NmixPHOBOS13:
                    return(norm * Math.Pow(GetNmixPHOBOS(
                                               NumberCollisionsField[x, y], NumberParticipantsField[x, y]), 1 / 3.0));

                case TemperatureProfile.NmixALICE13:
                    return(norm * Math.Pow(GetNmixALICE(
                                               NumberCollisionsField[x, y], NumberParticipantsField[x, y]), 1 / 3.0));

                default:
                    throw new Exception("Invalid Profile.");
                }
            });
        }
예제 #12
0
 private void InitV()
 {
     VelocityX = new SimpleFireballField(FireballFieldType.VelocityX, CoordinateSystem);
     VelocityY = new SimpleFireballField(FireballFieldType.VelocityY, CoordinateSystem);
 }