* provided "as is" without express or implied warranty. *
**************************************************************************/
-/*
-$Log$
-Revision 1.8 2000/12/21 16:24:06 morsch
-Coding convention clean-up
-
-Revision 1.7 2000/10/02 15:16:37 morsch
-Correct coding rule violation for member data names of type fi -> fI.
-
-Revision 1.6 2000/06/14 15:19:47 morsch
-Include clean-up (IH)
-
-Revision 1.5 2000/06/09 20:35:32 morsch
-All coding rule violations except RS3 corrected
-
-Revision 1.4 2000/03/20 18:03:24 morsch
-Change muon particle code to PDG code.
-
-Revision 1.3 1999/09/29 09:24:08 fca
-Introduction of the Copyright and cvs Log
-
-*/
+/* $Id$ */
/*
Class for dimuon analysis and fast dimuon simulation.
andreas.morsch@cern.ch
*/
-
-#include "AliDimuCombinator.h"
-#include "AliPDG.h"
-#include "AliRun.h"
-#include <TRandom.h>
#include <TClonesArray.h>
#include <TParticle.h>
+#include <TPDGCode.h>
+#include <TRandom.h>
#include <TTree.h>
+#include "AliDimuCombinator.h"
+#include "AliRun.h"
+#include "AliMC.h"
+
//
ClassImp(AliDimuCombinator)
AliDimuCombinator::AliDimuCombinator()
}
AliDimuCombinator::AliDimuCombinator(const AliDimuCombinator & combinator)
+ :TObject(combinator)
{
// Dummy copy constructor
+ combinator.Copy(*this);
}
//
TParticle* AliDimuCombinator::Particle(Int_t i)
{
- return gAlice->Particle(i);
+ return gAlice->GetMCApp()->Particle(i);
}
TParticle* AliDimuCombinator::FirstMuon()
{
// Calculate decay probability for muons from pion and kaon decays
//
+
Float_t d, h, theta, cTau;
TParticle* parent = Parent(part);
Int_t ipar = Type(parent);
//
// this part is still very ALICE muon-arm specific
//
+
+
theta = parent->Theta();
h = 90*TMath::Tan(theta);
}
}
+//Begin_Html
+/*
+<p> In the the code above :
+<P>If h is less than 4 cm, pions or kaons go in the beam pipe and can have a long way
+<BR>If h is greater than 4 cm, pions or kaons crash into the front absorber
+<P><IMG SRC="absorbeur.jpg" HEIGHT=292 WIDTH=819>
+*/
+//End_Html
+
+
Float_t AliDimuCombinator::Weight(TParticle* part1, TParticle* part2)
{
// Dimuon weight
Float_t wgt = (part1->GetWeight())*(part2->GetWeight());
if (Correlated(part1, part2)) {
- return wgt/(Parent(part1)->GetWeight())*fRate1;
+ if ( part1->GetFirstMother() == part2->GetFirstMother()) {
+ return part1->GetWeight()*fRate1;
+ } else {
+ return wgt/(Parent(part1)->GetWeight())*fRate1;
+ }
} else {
return wgt*fRate1*fRate2;
}
}
+//Begin_Html
+/*
+<p>Some clarifications on the calculation of the dimuons weight :
+<P>We must keep in mind that if we force the meson decay in muons and we put
+lot of mesons (J/psi, upsilon, ...) to have a good statistic we are
+obliged to calculate different weights to correct the number
+of muons
+<BR>
+<P>First -->
+<BR>The particle weight is given by w=R*M*Br
+<BR> with :
+<UL>R = the rate by event. This number gives the number
+of produced J/psi, upsilon, pion ... in a collision.
+<BR>It corresponds of the weight 0.06 given for example in gener->AddGenerator(jpsi,"J/Psi",
+0.06); from the config.C macro.
+<BR>In this example R=0.06
+
+<P>M = the rate of the mother production. This number depend on :
+<BR> - the number of generated events --> fParentWeight=1./Float_t(fNpart) in AliGenPythia.cxx . This
+is a normalization to 1 of the number of generated particles.
+<BR> - the kinematic bias coming
+from the y and Pt cuts. Method AliGenPythia::AdjustWeights() in AliGenPythia.cxx
+<BR>(in AliGenParam.cxx this 2 things are taken into account in fParentWeight
+= fYWgt*fPtWgt*phiWgt/fNpart )
+
+<P>Br = the branching ratio in muon from the mother decay</UL>
+
+<P><BR>In this method, part->GetWeight() = M*Br
+<UL> </UL>
+Next -->
+<BR>The weight of the dimuon depends on the correlation between muons
+<BR>
+<UL>If the muons are correlated and come from a resonance (for example
+J/psi -> mu+ mu-) , the weight of the dimuon is the weight of one muon then
+<BR>w12= R*M*Br = w1* R1 (in this method this gives part1->GetWeight()*fRate1)
+
+<P>If the muons are correlated and come from a charm or a bottom pair then
+w12 = M*R*Br1*Br2 = w1*w2*R1/M1
+<BR>(in this method this gives wgt/(Parent(part1)->GetWeight())*fRate1).
+Indeed the 2 muons come from the same mother so the
+<BR>weight of a DD~ or BB~ is M*Br and they are no correlation in the decay
+(Br1*Br2)
+
+<P>If the muons are not correlated w12 = M1*M2*R1*R2*Br1*Br2 = w1*w2*R1*R2
+(in this method this gives wgt*fRate1*fRate2)
+<BR> </UL>
+*/
+//End_Html
+
Float_t AliDimuCombinator::Weight(TParticle* part)
{
{
// Check if muons are correlated
//
- if (Origin(part1) == Origin(part2)) {
+ if ((Origin(part1) >= 0) && Origin(part1) == Origin(part2)) {
+/*
+ printf("\n origin %d %d ",
+ Type(Particle(Origin(part1))),
+ Type(Particle(Origin(part2))));
+ printf("\n parent %d %d \n \n ",
+ Type(Parent(part1)),
+ Type(Parent(part2)));
+*/
return kTRUE;
} else {
return kFALSE;
AliDimuCombinator& AliDimuCombinator::operator=(const AliDimuCombinator& rhs)
{
// Assignment operator
+ rhs.Copy(*this);
return *this;
}
-void AliDimuCombinator::Copy(AliDimuCombinator &combi) const
+void AliDimuCombinator::Copy(AliDimuCombinator&) const
{
//
- // Copy *this onto lego -- not implemented
+ // Copy
//
Fatal("Copy","Not implemented!\n");
}